blob: 38c7f2b70a71290ae5c51388d23f62d61da442be [file] [log] [blame]
Jamie Gennis134f0422011-03-08 12:18:54 -08001/*
2 * Copyright (C) 2011 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
Jim Shargo785d2e22024-07-29 23:21:08 +000017#include "gui/view/Surface.h"
Nolan Scobie9c427942023-05-01 16:41:28 -040018#include "Constants.h"
Peiyong Lind8460c82020-07-28 16:04:22 -070019#include "MockConsumer.h"
Dan Stozac6f30bd2015-06-08 09:32:50 -070020
Jamie Gennis134f0422011-03-08 12:18:54 -080021#include <gtest/gtest.h>
Jamie Gennis7a4d0df2011-03-09 17:05:02 -080022
Sundong Ahnf33c9f12020-04-23 21:31:20 +090023#include <SurfaceFlingerProperties.h>
Brian Lindahlf5fdff82024-11-01 09:28:47 -060024#include <android/gui/IActivePictureListener.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080025#include <android/gui/IDisplayEventConnection.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080026#include <android/gui/ISurfaceComposer.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060027#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Jim Shargoc6049932024-07-08 22:40:59 +000028#include <android/hardware_buffer.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070029#include <binder/ProcessState.h>
Jim Shargo00886392024-07-12 22:12:20 +000030#include <com_android_graphics_libgui_flags.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060031#include <configstore/Utils.h>
Alec Mouri924f9502024-08-15 20:01:08 +000032#include <gui/AidlUtil.h>
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -070033#include <gui/BufferItemConsumer.h>
Jim Shargoc6049932024-07-08 22:40:59 +000034#include <gui/BufferQueue.h>
Jim Shargo00886392024-07-12 22:12:20 +000035#include <gui/CpuConsumer.h>
Jim Shargoc6049932024-07-08 22:40:59 +000036#include <gui/IConsumerListener.h>
37#include <gui/IGraphicBufferConsumer.h>
38#include <gui/IGraphicBufferProducer.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080039#include <gui/ISurfaceComposer.h>
40#include <gui/Surface.h>
41#include <gui/SurfaceComposerClient.h>
chaviwe7b9f272020-08-18 16:08:59 -070042#include <gui/SyncScreenCaptureListener.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070043#include <private/gui/ComposerService.h>
Huihong Luof5029222021-12-16 14:33:46 -080044#include <private/gui/ComposerServiceAIDL.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080045#include <sys/types.h>
Jim Shargoc6049932024-07-08 22:40:59 +000046#include <system/window.h>
Yiwei Zhang74c9cc32020-06-20 03:35:17 -070047#include <ui/BufferQueueDefs.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010048#include <ui/DisplayMode.h>
Jim Shargo00886392024-07-12 22:12:20 +000049#include <ui/GraphicBuffer.h>
Dan Stozac1879002014-05-22 15:59:05 -070050#include <ui/Rect.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080051#include <utils/Errors.h>
Jamie Gennis134f0422011-03-08 12:18:54 -080052#include <utils/String8.h>
53
Jim Shargoa3da3022024-07-10 23:39:10 +000054#include <chrono>
Jim Shargo00886392024-07-12 22:12:20 +000055#include <cstddef>
Jim Shargoa3da3022024-07-10 23:39:10 +000056#include <cstdint>
57#include <future>
Brian Anderson3da8d272016-07-28 16:20:47 -070058#include <limits>
Kalle Raita643f0942016-12-07 09:20:14 -080059#include <thread>
60
Jim Shargo550dbaa2024-07-22 22:19:55 +000061#include "testserver/TestServerClient.h"
62
Jamie Gennis134f0422011-03-08 12:18:54 -080063namespace android {
64
Kalle Raita643f0942016-12-07 09:20:14 -080065using namespace std::chrono_literals;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060066// retrieve wide-color and hdr settings from configstore
67using namespace android::hardware::configstore;
68using namespace android::hardware::configstore::V1_0;
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050069using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
Huihong Luo6fac5232021-11-22 16:05:23 -080070using gui::IDisplayEventConnection;
Huihong Luoecc1f902021-11-20 11:55:05 -080071using gui::IRegionSamplingListener;
Peiyong Lin9f034472018-03-28 15:29:00 -070072using ui::ColorMode;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060073
Robert Carr4cdc58f2017-08-23 14:22:20 -070074using Transaction = SurfaceComposerClient::Transaction;
75
Sundong Ahnf33c9f12020-04-23 21:31:20 +090076static bool hasWideColorDisplay = android::sysprop::has_wide_color_display(false);
Kalle Raita643f0942016-12-07 09:20:14 -080077
Sundong Ahnf33c9f12020-04-23 21:31:20 +090078static bool hasHdrDisplay = android::sysprop::has_HDR_display(false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -070079
Brian Anderson3da8d272016-07-28 16:20:47 -070080class FakeSurfaceComposer;
81class FakeProducerFrameEventHistory;
82
83static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
84
Peiyong Lind8460c82020-07-28 16:04:22 -070085class FakeSurfaceListener : public SurfaceListener {
Shuzhen Wang067fcd32019-08-14 10:41:12 -070086public:
Peiyong Lind8460c82020-07-28 16:04:22 -070087 FakeSurfaceListener(bool enableReleasedCb = false)
88 : mEnableReleaseCb(enableReleasedCb), mBuffersReleased(0) {}
89 virtual ~FakeSurfaceListener() = default;
Shuzhen Wang067fcd32019-08-14 10:41:12 -070090
91 virtual void onBufferReleased() {
92 mBuffersReleased++;
93 }
94 virtual bool needsReleaseNotify() {
95 return mEnableReleaseCb;
96 }
97 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers) {
98 mDiscardedBuffers.insert(mDiscardedBuffers.end(), buffers.begin(), buffers.end());
99 }
Carlos Martinez Romeroab8443c2024-07-03 13:50:10 -0700100 virtual void onBufferDetached(int /*slot*/) {}
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700101 int getReleaseNotifyCount() const {
102 return mBuffersReleased;
103 }
104 const std::vector<sp<GraphicBuffer>>& getDiscardedBuffers() const {
105 return mDiscardedBuffers;
106 }
107private:
108 // No need to use lock given the test triggers the listener in the same
109 // thread context.
110 bool mEnableReleaseCb;
111 int32_t mBuffersReleased;
112 std::vector<sp<GraphicBuffer>> mDiscardedBuffers;
113};
114
Jim Shargoa3da3022024-07-10 23:39:10 +0000115class DeathWatcherListener : public StubSurfaceListener {
116public:
117 virtual void onRemoteDied() { mDiedPromise.set_value(true); }
118
119 virtual bool needsDeathNotify() { return true; }
120
121 std::future<bool> getDiedFuture() { return mDiedPromise.get_future(); }
122
123private:
124 std::promise<bool> mDiedPromise;
125};
126
Jamie Gennis134f0422011-03-08 12:18:54 -0800127class SurfaceTest : public ::testing::Test {
128protected:
Mathias Agopian7c1a4872013-03-20 15:56:04 -0700129 SurfaceTest() {
130 ProcessState::self()->startThreadPool();
131 }
132
Jamie Gennis134f0422011-03-08 12:18:54 -0800133 virtual void SetUp() {
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800134 mComposerClient = new SurfaceComposerClient;
Jamie Gennis134f0422011-03-08 12:18:54 -0800135 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
136
Brian Andersond0010582017-03-07 13:20:31 -0800137 // TODO(brianderson): The following sometimes fails and is a source of
138 // test flakiness.
Jamie Gennisfc850122011-04-25 16:40:05 -0700139 mSurfaceControl = mComposerClient->createSurface(
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700140 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
arthurhungdba591c2021-02-08 17:28:49 +0800141 SurfaceComposerClient::Transaction().apply(true);
Jamie Gennis134f0422011-03-08 12:18:54 -0800142
Yi Konga03e0442018-07-17 11:16:57 -0700143 ASSERT_TRUE(mSurfaceControl != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800144 ASSERT_TRUE(mSurfaceControl->isValid());
145
Robert Carr4cdc58f2017-08-23 14:22:20 -0700146 Transaction t;
arthurhungdba591c2021-02-08 17:28:49 +0800147 ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff).show(mSurfaceControl).apply());
Jamie Gennis134f0422011-03-08 12:18:54 -0800148
149 mSurface = mSurfaceControl->getSurface();
Yi Konga03e0442018-07-17 11:16:57 -0700150 ASSERT_TRUE(mSurface != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800151 }
152
153 virtual void TearDown() {
154 mComposerClient->dispose();
155 }
156
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700157 void testSurfaceListener(bool hasSurfaceListener, bool enableReleasedCb,
158 int32_t extraDiscardedBuffers) {
159 sp<IGraphicBufferProducer> producer;
160 sp<IGraphicBufferConsumer> consumer;
161 BufferQueue::createBufferQueue(&producer, &consumer);
162
Peiyong Lind8460c82020-07-28 16:04:22 -0700163 sp<MockConsumer> mockConsumer(new MockConsumer);
164 consumer->consumerConnect(mockConsumer, false);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700165 consumer->setConsumerName(String8("TestConsumer"));
166
167 sp<Surface> surface = new Surface(producer);
168 sp<ANativeWindow> window(surface);
Peiyong Lind8460c82020-07-28 16:04:22 -0700169 sp<FakeSurfaceListener> listener;
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700170 if (hasSurfaceListener) {
Peiyong Lind8460c82020-07-28 16:04:22 -0700171 listener = new FakeSurfaceListener(enableReleasedCb);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700172 }
Carlos Martinez Romero6a5fdc12024-07-22 09:40:33 -0700173 ASSERT_EQ(OK,
174 surface->connect(NATIVE_WINDOW_API_CPU,
175 /*listener*/ listener,
176 /*reportBufferRemoval*/ true));
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700177 const int BUFFER_COUNT = 4 + extraDiscardedBuffers;
178 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
Nolan Scobie9c427942023-05-01 16:41:28 -0400179 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700180
181 ANativeWindowBuffer* buffers[BUFFER_COUNT];
182 // Dequeue first to allocate a number of buffers
183 for (int i = 0; i < BUFFER_COUNT; i++) {
184 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffers[i]));
185 }
186 for (int i = 0; i < BUFFER_COUNT; i++) {
187 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], -1));
188 }
189
190 ANativeWindowBuffer* buffer;
191 // Fill BUFFER_COUNT-1 buffers
192 for (int i = 0; i < BUFFER_COUNT-1; i++) {
193 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
194 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, -1));
195 }
196
197 // Dequeue 1 buffer
198 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
199
200 // Acquire and free 1+extraDiscardedBuffers buffer, check onBufferReleased is called.
201 std::vector<BufferItem> releasedItems;
202 releasedItems.resize(1+extraDiscardedBuffers);
Siarhei Vishniakoubf98a572024-03-29 13:34:42 -0700203 for (size_t i = 0; i < releasedItems.size(); i++) {
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700204 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&releasedItems[i], 0));
Jim Shargo52108082024-11-15 16:53:57 +0000205 ASSERT_EQ(NO_ERROR,
206 consumer->releaseBuffer(releasedItems[i].mSlot, releasedItems[i].mFrameNumber,
207 Fence::NO_FENCE));
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700208 }
209 int32_t expectedReleaseCb = (enableReleasedCb ? releasedItems.size() : 0);
210 if (hasSurfaceListener) {
211 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
212 }
213
214 // Acquire 1 buffer, leaving 1+extraDiscardedBuffers filled buffer in queue
215 BufferItem item;
216 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&item, 0));
217
218 // Discard free buffers
219 ASSERT_EQ(NO_ERROR, consumer->discardFreeBuffers());
220
221 if (hasSurfaceListener) {
222 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
223
224 // Check onBufferDiscarded is called with correct buffer
225 auto discardedBuffers = listener->getDiscardedBuffers();
226 ASSERT_EQ(discardedBuffers.size(), releasedItems.size());
Siarhei Vishniakoubf98a572024-03-29 13:34:42 -0700227 for (size_t i = 0; i < releasedItems.size(); i++) {
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700228 ASSERT_EQ(discardedBuffers[i], releasedItems[i].mGraphicBuffer);
229 }
230
231 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
232 }
233
234 // Disconnect the surface
235 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
236 }
237
Jamie Gennis134f0422011-03-08 12:18:54 -0800238 sp<Surface> mSurface;
239 sp<SurfaceComposerClient> mComposerClient;
240 sp<SurfaceControl> mSurfaceControl;
241};
242
Robert Carr740eaf02018-03-27 12:59:18 -0700243TEST_F(SurfaceTest, CreateSurfaceReturnsErrorBadClient) {
244 mComposerClient->dispose();
245 ASSERT_EQ(NO_INIT, mComposerClient->initCheck());
246
247 sp<SurfaceControl> sc;
248 status_t err = mComposerClient->createSurfaceChecked(
249 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, &sc, 0);
250 ASSERT_EQ(NO_INIT, err);
251}
252
Jamie Gennis134f0422011-03-08 12:18:54 -0800253TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
254 sp<ANativeWindow> anw(mSurface);
255 int result = -123;
256 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
257 &result);
258 EXPECT_EQ(NO_ERROR, err);
259 EXPECT_EQ(1, result);
260}
261
262TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
263 mSurfaceControl.clear();
Kalle Raita643f0942016-12-07 09:20:14 -0800264 // Wait for the async clean-up to complete.
265 std::this_thread::sleep_for(50ms);
Jamie Gennis134f0422011-03-08 12:18:54 -0800266
267 sp<ANativeWindow> anw(mSurface);
268 int result = -123;
269 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
270 &result);
271 EXPECT_EQ(NO_ERROR, err);
272 EXPECT_EQ(1, result);
273}
274
Jamie Gennis391bbe22011-03-14 15:00:06 -0700275TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
276 sp<ANativeWindow> anw(mSurface);
277 int result = -123;
278 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
279 EXPECT_EQ(NO_ERROR, err);
280 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
281}
282
Craig Donner6ebc46a2016-10-21 15:23:44 -0700283TEST_F(SurfaceTest, LayerCountIsOne) {
284 sp<ANativeWindow> anw(mSurface);
285 int result = -123;
286 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
287 EXPECT_EQ(NO_ERROR, err);
288 EXPECT_EQ(1, result);
289}
290
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700291TEST_F(SurfaceTest, QueryConsumerUsage) {
292 const int TEST_USAGE_FLAGS =
293 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
Jim Shargod30823a2024-07-27 02:49:39 +0000294 sp<BufferItemConsumer> c = new BufferItemConsumer(TEST_USAGE_FLAGS);
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700295
Jim Shargod30823a2024-07-27 02:49:39 +0000296 sp<Surface> s = c->getSurface();
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700297 sp<ANativeWindow> anw(s);
298
299 int flags = -1;
300 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
301
302 ASSERT_EQ(NO_ERROR, err);
303 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
304}
305
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800306TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
Peiyong Lin14724e62018-12-05 07:27:30 -0800307 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_V0_SRGB;
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800308
Jim Shargod30823a2024-07-27 02:49:39 +0000309 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800310 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
311
Jim Shargod30823a2024-07-27 02:49:39 +0000312 sp<Surface> s = cpuConsumer->getSurface();
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800313 sp<ANativeWindow> anw(s);
314
315 android_dataspace dataSpace;
316
317 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
318 reinterpret_cast<int*>(&dataSpace));
319
320 ASSERT_EQ(NO_ERROR, err);
321 ASSERT_EQ(TEST_DATASPACE, dataSpace);
322}
323
Dan Stoza812ed062015-06-02 15:45:22 -0700324TEST_F(SurfaceTest, SettingGenerationNumber) {
Jim Shargod30823a2024-07-27 02:49:39 +0000325 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
326 sp<Surface> surface = cpuConsumer->getSurface();
Dan Stoza812ed062015-06-02 15:45:22 -0700327 sp<ANativeWindow> window(surface);
328
329 // Allocate a buffer with a generation number of 0
330 ANativeWindowBuffer* buffer;
331 int fenceFd;
Pablo Ceballos583b1b32015-09-03 18:23:52 -0700332 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
333 NATIVE_WINDOW_API_CPU));
Dan Stoza812ed062015-06-02 15:45:22 -0700334 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
335 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
336
337 // Detach the buffer and check its generation number
338 sp<GraphicBuffer> graphicBuffer;
339 sp<Fence> fence;
340 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
341 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
342
343 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
344 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
345
346 // This should change the generation number of the GraphicBuffer
347 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
348
349 // Check that the new generation number sticks with the buffer
350 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
351 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
352 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
353 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
354}
355
Dan Stozac6f30bd2015-06-08 09:32:50 -0700356TEST_F(SurfaceTest, GetConsumerName) {
357 sp<IGraphicBufferProducer> producer;
358 sp<IGraphicBufferConsumer> consumer;
359 BufferQueue::createBufferQueue(&producer, &consumer);
360
Peiyong Lind8460c82020-07-28 16:04:22 -0700361 sp<MockConsumer> mockConsumer(new MockConsumer);
362 consumer->consumerConnect(mockConsumer, false);
Dan Stozac6f30bd2015-06-08 09:32:50 -0700363 consumer->setConsumerName(String8("TestConsumer"));
364
365 sp<Surface> surface = new Surface(producer);
366 sp<ANativeWindow> window(surface);
367 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
368
Tomasz Wasilczykb19fe0c2023-08-11 00:06:51 +0000369 EXPECT_STREQ("TestConsumer", surface->getConsumerName().c_str());
Dan Stozac6f30bd2015-06-08 09:32:50 -0700370}
371
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700372TEST_F(SurfaceTest, GetWideColorSupport) {
373 sp<IGraphicBufferProducer> producer;
374 sp<IGraphicBufferConsumer> consumer;
375 BufferQueue::createBufferQueue(&producer, &consumer);
376
Peiyong Lind8460c82020-07-28 16:04:22 -0700377 sp<MockConsumer> mockConsumer(new MockConsumer);
378 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700379 consumer->setConsumerName(String8("TestConsumer"));
380
381 sp<Surface> surface = new Surface(producer);
382 sp<ANativeWindow> window(surface);
383 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
384
385 bool supported;
386 surface->getWideColorSupport(&supported);
387
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -0600388 // NOTE: This test assumes that device that supports
389 // wide-color (as indicated by BoardConfig) must also
390 // have a wide-color primary display.
391 // That assumption allows this test to cover devices
392 // that advertised a wide-color color mode without
393 // actually supporting wide-color to pass this test
394 // as well as the case of a device that does support
395 // wide-color (via BoardConfig) and has a wide-color
396 // primary display.
397 // NOT covered at this time is a device that supports
398 // wide color in the BoardConfig but does not support
399 // a wide-color color mode on the primary display.
400 ASSERT_EQ(hasWideColorDisplay, supported);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700401}
402
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700403TEST_F(SurfaceTest, GetHdrSupport) {
404 sp<IGraphicBufferProducer> producer;
405 sp<IGraphicBufferConsumer> consumer;
406 BufferQueue::createBufferQueue(&producer, &consumer);
407
Peiyong Lind8460c82020-07-28 16:04:22 -0700408 sp<MockConsumer> mockConsumer(new MockConsumer);
409 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700410 consumer->setConsumerName(String8("TestConsumer"));
411
412 sp<Surface> surface = new Surface(producer);
413 sp<ANativeWindow> window(surface);
414 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
415
416 bool supported;
417 status_t result = surface->getHdrSupport(&supported);
418 ASSERT_EQ(NO_ERROR, result);
419
420 // NOTE: This is not a CTS test.
421 // This test verifies that when the BoardConfig TARGET_HAS_HDR_DISPLAY
422 // is TRUE, getHdrSupport is also true.
423 // TODO: Add check for an HDR color mode on the primary display.
424 ASSERT_EQ(hasHdrDisplay, supported);
425}
426
427TEST_F(SurfaceTest, SetHdrMetadata) {
428 sp<IGraphicBufferProducer> producer;
429 sp<IGraphicBufferConsumer> consumer;
430 BufferQueue::createBufferQueue(&producer, &consumer);
431
Peiyong Lind8460c82020-07-28 16:04:22 -0700432 sp<MockConsumer> mockConsumer(new MockConsumer);
433 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700434 consumer->setConsumerName(String8("TestConsumer"));
435
436 sp<Surface> surface = new Surface(producer);
437 sp<ANativeWindow> window(surface);
438 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
439
440 bool supported;
441 status_t result = surface->getHdrSupport(&supported);
442 ASSERT_EQ(NO_ERROR, result);
443
444 if (!hasHdrDisplay || !supported) {
445 return;
446 }
447 const android_smpte2086_metadata smpte2086 = {
448 {0.680, 0.320},
449 {0.265, 0.690},
450 {0.150, 0.060},
451 {0.3127, 0.3290},
452 100.0,
453 0.1,
454 };
455 const android_cta861_3_metadata cta861_3 = {
456 78.0,
457 62.0,
458 };
Valerie Haua82679d2018-11-21 09:31:43 -0800459
460 std::vector<uint8_t> hdr10plus;
461 hdr10plus.push_back(0xff);
462
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700463 int error = native_window_set_buffers_smpte2086_metadata(window.get(), &smpte2086);
464 ASSERT_EQ(error, NO_ERROR);
465 error = native_window_set_buffers_cta861_3_metadata(window.get(), &cta861_3);
466 ASSERT_EQ(error, NO_ERROR);
Valerie Haua82679d2018-11-21 09:31:43 -0800467 error = native_window_set_buffers_hdr10_plus_metadata(window.get(), hdr10plus.size(),
468 hdr10plus.data());
469 ASSERT_EQ(error, NO_ERROR);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700470}
471
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800472TEST_F(SurfaceTest, DynamicSetBufferCount) {
473 sp<IGraphicBufferProducer> producer;
474 sp<IGraphicBufferConsumer> consumer;
475 BufferQueue::createBufferQueue(&producer, &consumer);
476
Peiyong Lind8460c82020-07-28 16:04:22 -0700477 sp<MockConsumer> mockConsumer(new MockConsumer);
478 consumer->consumerConnect(mockConsumer, false);
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800479 consumer->setConsumerName(String8("TestConsumer"));
480
481 sp<Surface> surface = new Surface(producer);
482 sp<ANativeWindow> window(surface);
483
484 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
485 NATIVE_WINDOW_API_CPU));
Nolan Scobie9c427942023-05-01 16:41:28 -0400486 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), 4));
487 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800488
489 int fence;
490 ANativeWindowBuffer* buffer;
491 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
492 native_window_set_buffer_count(window.get(), 3);
493 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
494 native_window_set_buffer_count(window.get(), 2);
495 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
496 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
497}
498
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700499TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
500 sp<IGraphicBufferProducer> producer;
501 sp<IGraphicBufferConsumer> consumer;
502 BufferQueue::createBufferQueue(&producer, &consumer);
503
Peiyong Lind8460c82020-07-28 16:04:22 -0700504 sp<MockConsumer> mockConsumer(new MockConsumer);
505 consumer->consumerConnect(mockConsumer, false);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700506 consumer->setConsumerName(String8("TestConsumer"));
507
508 sp<Surface> surface = new Surface(producer);
509 sp<ANativeWindow> window(surface);
Carlos Martinez Romeroab8443c2024-07-03 13:50:10 -0700510 sp<StubSurfaceListener> listener = new StubSurfaceListener();
Carlos Martinez Romero6a5fdc12024-07-22 09:40:33 -0700511 ASSERT_EQ(OK,
512 surface->connect(NATIVE_WINDOW_API_CPU,
513 /*listener*/ listener,
514 /*reportBufferRemoval*/ true));
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700515 const int BUFFER_COUNT = 4;
516 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
Nolan Scobie9c427942023-05-01 16:41:28 -0400517 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700518
519 sp<GraphicBuffer> detachedBuffer;
520 sp<Fence> outFence;
521 int fences[BUFFER_COUNT];
522 ANativeWindowBuffer* buffers[BUFFER_COUNT];
523 // Allocate buffers because detachNextBuffer requires allocated buffers
524 for (int i = 0; i < BUFFER_COUNT; i++) {
525 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
526 }
527 for (int i = 0; i < BUFFER_COUNT; i++) {
528 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
529 }
530
531 // Test detached buffer is correctly reported
532 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
533 std::vector<sp<GraphicBuffer>> removedBuffers;
534 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
535 ASSERT_EQ(1u, removedBuffers.size());
536 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
537 // Test the list is flushed one getAndFlushRemovedBuffers returns
538 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
539 ASSERT_EQ(0u, removedBuffers.size());
540
541
542 // Test removed buffer list is cleanup after next dequeueBuffer call
543 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
544 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
545 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
546 ASSERT_EQ(0u, removedBuffers.size());
547 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
548
549 // Test removed buffer list is cleanup after next detachNextBuffer call
550 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
551 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
552 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
553 ASSERT_EQ(1u, removedBuffers.size());
554 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
555
556 // Re-allocate buffers since all buffers are detached up to now
557 for (int i = 0; i < BUFFER_COUNT; i++) {
558 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
559 }
560 for (int i = 0; i < BUFFER_COUNT; i++) {
561 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
562 }
563
564 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
565 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
566 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
567 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
568 // get 0 or 1 buffer removed.
569 ASSERT_LE(removedBuffers.size(), 1u);
570}
Brian Anderson3da8d272016-07-28 16:20:47 -0700571
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700572TEST_F(SurfaceTest, SurfaceListenerTest) {
573 // Test discarding 1 free buffers with no listener
574 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/0);
575 // Test discarding 2 free buffers with no listener
576 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/1);
577 // Test discarding 1 free buffers with a listener, disabling onBufferReleased
578 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/0);
579 // Test discarding 2 free buffers with a listener, disabling onBufferReleased
580 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/1);
581 // Test discarding 1 free buffers with a listener, enabling onBufferReleased
582 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/0);
583 // Test discarding 3 free buffers with a listener, enabling onBufferReleased
584 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/2);
585}
586
Dan Stoza932f0082017-05-31 13:50:16 -0700587TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
588 sp<ANativeWindow> anw(mSurface);
589 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
590
591 ANativeWindowBuffer* buffer = nullptr;
592 int32_t fenceFd = -1;
593
594 nsecs_t before = systemTime(CLOCK_MONOTONIC);
595 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
596 nsecs_t after = systemTime(CLOCK_MONOTONIC);
597
Alec Mouria1619662019-08-21 19:30:48 -0700598 nsecs_t lastDequeueTime = ANativeWindow_getLastDequeueStartTime(anw.get());
Dan Stoza932f0082017-05-31 13:50:16 -0700599 ASSERT_LE(before, lastDequeueTime);
600 ASSERT_GE(after, lastDequeueTime);
601}
602
Brian Anderson3da8d272016-07-28 16:20:47 -0700603class FakeConsumer : public BnConsumerListener {
604public:
605 void onFrameAvailable(const BufferItem& /*item*/) override {}
606 void onBuffersReleased() override {}
607 void onSidebandStreamChanged() override {}
608
609 void addAndGetFrameTimestamps(
610 const NewFrameEventsEntry* newTimestamps,
611 FrameEventHistoryDelta* outDelta) override {
612 if (newTimestamps) {
613 if (mGetFrameTimestampsEnabled) {
614 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
615 "Test should set mNewFrameEntryOverride before queuing "
616 "a frame.";
617 EXPECT_EQ(newTimestamps->frameNumber,
618 mNewFrameEntryOverride.frameNumber) <<
619 "Test attempting to add NewFrameEntryOverride with "
620 "incorrect frame number.";
621 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
622 mNewFrameEntryOverride.frameNumber = 0;
623 }
624 mAddFrameTimestampsCount++;
625 mLastAddedFrameNumber = newTimestamps->frameNumber;
626 }
627 if (outDelta) {
628 mFrameEventHistory.getAndResetDelta(outDelta);
629 mGetFrameTimestampsCount++;
630 }
631 mAddAndGetFrameTimestampsCallCount++;
632 }
633
634 bool mGetFrameTimestampsEnabled = false;
635
636 ConsumerFrameEventHistory mFrameEventHistory;
637 int mAddAndGetFrameTimestampsCallCount = 0;
638 int mAddFrameTimestampsCount = 0;
639 int mGetFrameTimestampsCount = 0;
640 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
641
642 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
643};
644
Pablo Gamito6ee484d2020-07-30 14:26:28 +0000645class FakeSurfaceComposer : public ISurfaceComposer {
Brian Anderson3da8d272016-07-28 16:20:47 -0700646public:
647 ~FakeSurfaceComposer() override {}
648
Brian Anderson6b376712017-04-04 10:51:39 -0700649 void setSupportsPresent(bool supportsPresent) {
650 mSupportsPresent = supportsPresent;
651 }
652
Pablo Gamito23780be2023-04-18 08:30:00 +0000653 status_t setTransactionState(
654 const FrameTimelineInfo& /*frameTimelineInfo*/, Vector<ComposerState>& /*state*/,
Patrick Williamsf65da8a2024-07-24 17:11:19 +0000655 Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
Pablo Gamito23780be2023-04-18 08:30:00 +0000656 const sp<IBinder>& /*applyToken*/, InputWindowCommands /*inputWindowCommands*/,
657 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
658 const std::vector<client_cache_t>& /*cachedBuffer*/, bool /*hasListenerCallbacks*/,
659 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/, uint64_t /*transactionId*/,
660 const std::vector<uint64_t>& /*mergedTransactionIds*/) override {
chaviw308ddba2020-08-11 16:23:51 -0700661 return NO_ERROR;
Marissa Wall3dad52d2019-03-22 14:03:19 -0700662 }
Marissa Wall17b4e452018-12-26 16:32:34 -0800663
Brian Anderson3da8d272016-07-28 16:20:47 -0700664protected:
665 IBinder* onAsBinder() override { return nullptr; }
666
667private:
668 bool mSupportsPresent{true};
Brian Anderson3da8d272016-07-28 16:20:47 -0700669};
670
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800671class FakeSurfaceComposerAIDL : public gui::ISurfaceComposer {
672public:
673 ~FakeSurfaceComposerAIDL() override {}
674
675 void setSupportsPresent(bool supportsPresent) { mSupportsPresent = supportsPresent; }
676
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700677 binder::Status bootFinished() override { return binder::Status::ok(); }
678
679 binder::Status createDisplayEventConnection(
680 VsyncSource /*vsyncSource*/, EventRegistration /*eventRegistration*/,
Rachel Lee2248f522023-01-27 16:45:23 -0800681 const sp<IBinder>& /*layerHandle*/,
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700682 sp<gui::IDisplayEventConnection>* outConnection) override {
683 *outConnection = nullptr;
684 return binder::Status::ok();
685 }
686
Huihong Luod3d8f8e2022-03-08 14:48:46 -0800687 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override {
688 *outClient = nullptr;
689 return binder::Status::ok();
690 }
691
Alan Dingd53801c2024-05-08 16:45:29 -0700692 binder::Status createVirtualDisplay(const std::string& /*displayName*/, bool /*isSecure*/,
693 const std::string& /*uniqueId*/,
694 float /*requestedRefreshRate*/,
695 sp<IBinder>* /*outDisplay*/) override {
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800696 return binder::Status::ok();
697 }
698
Alan Dingd53801c2024-05-08 16:45:29 -0700699 binder::Status destroyVirtualDisplay(const sp<IBinder>& /*displayToken*/) override {
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800700 return binder::Status::ok();
701 }
702
703 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* /*outDisplayIds*/) override {
704 return binder::Status::ok();
705 }
706
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800707 binder::Status getPhysicalDisplayToken(int64_t /*displayId*/,
708 sp<IBinder>* /*outDisplay*/) override {
709 return binder::Status::ok();
710 }
711
712 binder::Status setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {
713 return binder::Status::ok();
714 }
715
Huihong Luo0a81aa32022-02-22 16:02:36 -0800716 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override {
717 *outSupported = {FrameEvent::REQUESTED_PRESENT,
718 FrameEvent::ACQUIRE,
719 FrameEvent::LATCH,
720 FrameEvent::FIRST_REFRESH_START,
721 FrameEvent::LAST_REFRESH_START,
722 FrameEvent::GPU_COMPOSITION_DONE,
723 FrameEvent::DEQUEUE_READY,
724 FrameEvent::RELEASE};
725 if (mSupportsPresent) {
726 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
727 }
728 return binder::Status::ok();
729 }
730
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800731 binder::Status getDisplayStats(const sp<IBinder>& /*display*/,
732 gui::DisplayStatInfo* /*outStatInfo*/) override {
733 return binder::Status::ok();
734 }
735
736 binder::Status getDisplayState(const sp<IBinder>& /*display*/,
737 gui::DisplayState* /*outState*/) override {
738 return binder::Status::ok();
739 }
740
Sally Qi6bb12822022-10-05 11:42:30 -0700741 binder::Status getStaticDisplayInfo(int64_t /*displayId*/,
Huihong Luoa79ddf42022-02-17 00:01:38 -0800742 gui::StaticDisplayInfo* /*outInfo*/) override {
743 return binder::Status::ok();
744 }
745
Sally Qi6bb12822022-10-05 11:42:30 -0700746 binder::Status getDynamicDisplayInfoFromId(int64_t /*displayId*/,
747 gui::DynamicDisplayInfo* /*outInfo*/) override {
748 return binder::Status::ok();
749 }
750
751 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& /*display*/,
752 gui::DynamicDisplayInfo* /*outInfo*/) override {
Huihong Luo38603fd2022-02-21 14:32:54 -0800753 return binder::Status::ok();
754 }
755
Huihong Luoca3d9a42022-02-22 11:07:34 -0800756 binder::Status getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
757 gui::DisplayPrimaries* /*outPrimaries*/) override {
758 return binder::Status::ok();
759 }
760
761 binder::Status setActiveColorMode(const sp<IBinder>& /*display*/, int /*colorMode*/) override {
762 return binder::Status::ok();
763 }
764
765 binder::Status setBootDisplayMode(const sp<IBinder>& /*display*/,
766 int /*displayModeId*/) override {
767 return binder::Status::ok();
768 }
769
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800770 binder::Status clearBootDisplayMode(const sp<IBinder>& /*display*/) override {
771 return binder::Status::ok();
772 }
773
774 binder::Status getBootDisplayModeSupport(bool* /*outMode*/) override {
775 return binder::Status::ok();
776 }
777
Kriti Dang674b9372022-11-18 10:58:44 +0100778 binder::Status getHdrConversionCapabilities(
779 std::vector<gui::HdrConversionCapability>*) override {
780 return binder::Status::ok();
781 }
782
783 binder::Status setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +0100784 const gui::HdrConversionStrategy& /*hdrConversionStrategy*/,
785 int32_t* /*outPreferredHdrOutputType*/) override {
Kriti Dang674b9372022-11-18 10:58:44 +0100786 return binder::Status::ok();
787 }
788
789 binder::Status getHdrOutputConversionSupport(bool* /*outSupport*/) override {
790 return binder::Status::ok();
791 }
792
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800793 binder::Status setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {
794 return binder::Status::ok();
795 }
796
797 binder::Status setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {
798 return binder::Status::ok();
799 }
800
801 binder::Status captureDisplay(const DisplayCaptureArgs&,
802 const sp<IScreenCaptureListener>&) override {
803 return binder::Status::ok();
804 }
805
John Reck7e4c4872023-11-14 18:31:03 -0500806 binder::Status captureDisplayById(int64_t, const gui::CaptureArgs&,
807 const sp<IScreenCaptureListener>&) override {
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800808 return binder::Status::ok();
809 }
810
Chavi Weingartenf6fb4452024-01-23 21:10:30 +0000811 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults*) override {
812 return binder::Status::ok();
813 }
814
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800815 binder::Status captureLayers(const LayerCaptureArgs&,
816 const sp<IScreenCaptureListener>&) override {
817 return binder::Status::ok();
818 }
819
Huihong Luo4ed1c912022-02-22 14:30:01 -0800820 binder::Status clearAnimationFrameStats() override { return binder::Status::ok(); }
821
822 binder::Status getAnimationFrameStats(gui::FrameStats* /*outStats*/) override {
823 return binder::Status::ok();
824 }
825
Huihong Luo05539a12022-02-23 10:29:40 -0800826 binder::Status overrideHdrTypes(const sp<IBinder>& /*display*/,
827 const std::vector<int32_t>& /*hdrTypes*/) override {
828 return binder::Status::ok();
829 }
830
831 binder::Status onPullAtom(int32_t /*atomId*/, gui::PullAtomData* /*outPullData*/) override {
832 return binder::Status::ok();
833 }
834
Huihong Luo05539a12022-02-23 10:29:40 -0800835 binder::Status getCompositionPreference(gui::CompositionPreference* /*outPref*/) override {
836 return binder::Status::ok();
837 }
838
839 binder::Status getDisplayedContentSamplingAttributes(
840 const sp<IBinder>& /*display*/, gui::ContentSamplingAttributes* /*outAttrs*/) override {
841 return binder::Status::ok();
842 }
843
844 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
845 int8_t /*componentMask*/,
846 int64_t /*maxFrames*/) override {
847 return binder::Status::ok();
848 }
849
850 binder::Status getProtectedContentSupport(bool* /*outSupporte*/) override {
851 return binder::Status::ok();
852 }
853
Huihong Luo3bdef862022-03-03 11:57:19 -0800854 binder::Status getDisplayedContentSample(const sp<IBinder>& /*display*/, int64_t /*maxFrames*/,
855 int64_t /*timestamp*/,
856 gui::DisplayedFrameStats* /*outStats*/) override {
857 return binder::Status::ok();
858 }
859
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800860 binder::Status isWideColorDisplay(const sp<IBinder>& /*token*/,
861 bool* /*outIsWideColorDisplay*/) override {
862 return binder::Status::ok();
863 }
864
Huihong Luo02186fb2022-02-23 14:21:54 -0800865 binder::Status addRegionSamplingListener(
866 const gui::ARect& /*samplingArea*/, const sp<IBinder>& /*stopLayerHandle*/,
867 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
868 return binder::Status::ok();
869 }
870
871 binder::Status removeRegionSamplingListener(
872 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
873 return binder::Status::ok();
874 }
875
876 binder::Status addFpsListener(int32_t /*taskId*/,
877 const sp<gui::IFpsListener>& /*listener*/) override {
878 return binder::Status::ok();
879 }
880
881 binder::Status removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) override {
882 return binder::Status::ok();
883 }
884
885 binder::Status addTunnelModeEnabledListener(
886 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
887 return binder::Status::ok();
888 }
889
890 binder::Status removeTunnelModeEnabledListener(
891 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
892 return binder::Status::ok();
893 }
894
895 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700896 const gui::DisplayModeSpecs&) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800897 return binder::Status::ok();
898 }
899
900 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700901 gui::DisplayModeSpecs*) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800902 return binder::Status::ok();
903 }
904
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800905 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
906 bool* /*outSupport*/) override {
907 return binder::Status::ok();
908 }
909
910 binder::Status setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
911 const gui::DisplayBrightness& /*brightness*/) override {
912 return binder::Status::ok();
913 }
914
915 binder::Status addHdrLayerInfoListener(
916 const sp<IBinder>& /*displayToken*/,
917 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
918 return binder::Status::ok();
919 }
920
921 binder::Status removeHdrLayerInfoListener(
922 const sp<IBinder>& /*displayToken*/,
923 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
924 return binder::Status::ok();
925 }
926
927 binder::Status notifyPowerBoost(int /*boostId*/) override { return binder::Status::ok(); }
928
Huihong Luo3bdef862022-03-03 11:57:19 -0800929 binder::Status setGlobalShadowSettings(const gui::Color& /*ambientColor*/,
930 const gui::Color& /*spotColor*/, float /*lightPosY*/,
931 float /*lightPosZ*/, float /*lightRadius*/) override {
932 return binder::Status::ok();
933 }
934
935 binder::Status getDisplayDecorationSupport(
936 const sp<IBinder>& /*displayToken*/,
937 std::optional<gui::DisplayDecorationSupport>* /*outSupport*/) override {
938 return binder::Status::ok();
939 }
940
Andy Yu8c2703d2023-11-03 11:22:46 -0700941 binder::Status setGameModeFrameRateOverride(int32_t /*uid*/, float /*frameRate*/) override {
942 return binder::Status::ok();
943 }
944
945 binder::Status setGameDefaultFrameRateOverride(int32_t /*uid*/, float /*frameRate*/) override {
Huihong Luo3bdef862022-03-03 11:57:19 -0800946 return binder::Status::ok();
947 }
948
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +0000949 binder::Status enableRefreshRateOverlay(bool /*active*/) override {
950 return binder::Status::ok();
951 }
952
953 binder::Status setDebugFlash(int /*delay*/) override { return binder::Status::ok(); }
954
955 binder::Status scheduleComposite() override { return binder::Status::ok(); }
956
957 binder::Status scheduleCommit() override { return binder::Status::ok(); }
958
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +0000959 binder::Status forceClientComposition(bool /*enabled*/) override {
960 return binder::Status::ok();
961 }
962
Tony Huangf3621102023-09-04 17:14:22 +0800963 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& /*appIds*/,
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000964 const std::vector<float>& /*thresholds*/) {
965 return binder::Status::ok();
966 }
967
Tony Huangf3621102023-09-04 17:14:22 +0800968 binder::Status setSmallAreaDetectionThreshold(int32_t /*appId*/, float /*threshold*/) {
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000969 return binder::Status::ok();
970 }
971
Huihong Luo02186fb2022-02-23 14:21:54 -0800972 binder::Status getGpuContextPriority(int32_t* /*outPriority*/) override {
973 return binder::Status::ok();
974 }
975
976 binder::Status getMaxAcquiredBufferCount(int32_t* /*buffers*/) override {
977 return binder::Status::ok();
978 }
979
980 binder::Status addWindowInfosListener(
Patrick Williamsacd22582023-07-12 13:47:28 -0500981 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/,
982 gui::WindowInfosListenerInfo* /*outInfo*/) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800983 return binder::Status::ok();
984 }
985
986 binder::Status removeWindowInfosListener(
987 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
988 return binder::Status::ok();
989 }
990
Sally Qi0cbd08b2022-08-17 12:12:28 -0700991 binder::Status getOverlaySupport(gui::OverlayProperties* /*properties*/) override {
992 return binder::Status::ok();
993 }
994
Patrick Williams090ad062023-08-08 12:30:10 -0500995 binder::Status getStalledTransactionInfo(
996 int32_t /*pid*/, std::optional<gui::StalledTransactionInfo>* /*result*/) override {
997 return binder::Status::ok();
998 }
999
Ady Abraham07d03c42023-09-27 19:15:08 -07001000 binder::Status getSchedulingPolicy(gui::SchedulingPolicy*) override {
1001 return binder::Status::ok();
1002 }
1003
Wenhui Yangeafc18a2024-05-14 17:15:52 +00001004 binder::Status notifyShutdown() override { return binder::Status::ok(); }
1005
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001006 binder::Status addJankListener(const sp<IBinder>& /*layer*/,
1007 const sp<gui::IJankListener>& /*listener*/) override {
1008 return binder::Status::ok();
1009 }
1010
1011 binder::Status flushJankData(int32_t /*layerId*/) override { return binder::Status::ok(); }
1012
1013 binder::Status removeJankListener(int32_t /*layerId*/,
1014 const sp<gui::IJankListener>& /*listener*/,
1015 int64_t /*afterVsync*/) override {
1016 return binder::Status::ok();
1017 }
1018
Brian Lindahlf5fdff82024-11-01 09:28:47 -06001019 binder::Status setActivePictureListener(const sp<gui::IActivePictureListener>&) {
1020 return binder::Status::ok();
1021 }
1022
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001023protected:
1024 IBinder* onAsBinder() override { return nullptr; }
1025
1026private:
1027 bool mSupportsPresent{true};
1028};
1029
Brian Anderson3da8d272016-07-28 16:20:47 -07001030class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
1031public:
Chih-Hung Hsiehaaf62162018-12-20 15:45:04 -08001032 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001033
1034 ~FakeProducerFrameEventHistory() {}
1035
1036 void updateAcquireFence(uint64_t frameNumber,
1037 std::shared_ptr<FenceTime>&& acquire) override {
1038 // Verify the acquire fence being added isn't the one from the consumer.
1039 EXPECT_NE(mConsumerAcquireFence, acquire);
1040 // Override the fence, so we can verify this was called by the
1041 // producer after the frame is queued.
1042 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
1043 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
1044 }
1045
1046 void setAcquireFenceOverride(
1047 const std::shared_ptr<FenceTime>& acquireFenceOverride,
1048 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
1049 mAcquireFenceOverride = acquireFenceOverride;
1050 mConsumerAcquireFence = consumerAcquireFence;
1051 }
1052
1053protected:
1054 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
1055 const override {
1056 return mFenceMap->createFenceTimeForTest(fence);
1057 }
1058
1059 FenceToFenceTimeMap* mFenceMap{nullptr};
1060
1061 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
1062 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
1063};
1064
1065
1066class TestSurface : public Surface {
1067public:
Huihong Luo0a81aa32022-02-22 16:02:36 -08001068 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer, FenceToFenceTimeMap* fenceMap)
1069 : Surface(bufferProducer),
1070 mFakeSurfaceComposer(new FakeSurfaceComposer),
1071 mFakeSurfaceComposerAIDL(new FakeSurfaceComposerAIDL) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001072 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
1073 mFrameEventHistory.reset(mFakeFrameEventHistory);
1074 }
1075
1076 ~TestSurface() override {}
1077
1078 sp<ISurfaceComposer> composerService() const override {
1079 return mFakeSurfaceComposer;
1080 }
1081
Huihong Luo0a81aa32022-02-22 16:02:36 -08001082 sp<gui::ISurfaceComposer> composerServiceAIDL() const override {
1083 return mFakeSurfaceComposerAIDL;
1084 }
1085
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001086 nsecs_t now() const override {
1087 return mNow;
1088 }
1089
1090 void setNow(nsecs_t now) {
1091 mNow = now;
1092 }
1093
Brian Anderson3da8d272016-07-28 16:20:47 -07001094public:
1095 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001096 sp<FakeSurfaceComposerAIDL> mFakeSurfaceComposerAIDL;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001097 nsecs_t mNow = 0;
Brian Anderson3da8d272016-07-28 16:20:47 -07001098
1099 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
1100 // but this raw pointer gives access to test functionality.
1101 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
1102};
1103
1104
Brian Andersond0010582017-03-07 13:20:31 -08001105class GetFrameTimestampsTest : public ::testing::Test {
Brian Anderson3da8d272016-07-28 16:20:47 -07001106protected:
1107 struct FenceAndFenceTime {
1108 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001109 : mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
1110
1111 sp<Fence> mFence = sp<Fence>::make();
1112 std::shared_ptr<FenceTime> mFenceTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001113 };
1114
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001115 static CompositorTiming makeCompositorTiming(nsecs_t deadline = 1'000'000'000,
1116 nsecs_t interval = 16'666'667,
1117 nsecs_t presentLatency = 50'000'000) {
1118 CompositorTiming timing;
1119 timing.deadline = deadline;
1120 timing.interval = interval;
1121 timing.presentLatency = presentLatency;
1122 return timing;
1123 }
1124
Brian Anderson3da8d272016-07-28 16:20:47 -07001125 struct RefreshEvents {
1126 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001127 : mFenceMap(fenceMap),
1128 kCompositorTiming(
1129 makeCompositorTiming(refreshStart, refreshStart + 1, refreshStart + 2)),
1130 kStartTime(refreshStart + 3),
1131 kGpuCompositionDoneTime(refreshStart + 4),
1132 kPresentTime(refreshStart + 5) {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001133
1134 void signalPostCompositeFences() {
1135 mFenceMap.signalAllForTest(
1136 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1137 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1138 }
1139
1140 FenceToFenceTimeMap& mFenceMap;
1141
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001142 FenceAndFenceTime mGpuCompositionDone{mFenceMap};
1143 FenceAndFenceTime mPresent{mFenceMap};
Brian Anderson3da8d272016-07-28 16:20:47 -07001144
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001145 const CompositorTiming kCompositorTiming;
1146
Brian Anderson3da8d272016-07-28 16:20:47 -07001147 const nsecs_t kStartTime;
1148 const nsecs_t kGpuCompositionDoneTime;
1149 const nsecs_t kPresentTime;
1150 };
1151
1152 struct FrameEvents {
1153 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1154 : mFenceMap(fenceMap),
1155 kPostedTime(frameStartTime + 100),
1156 kRequestedPresentTime(frameStartTime + 200),
1157 kProducerAcquireTime(frameStartTime + 300),
1158 kConsumerAcquireTime(frameStartTime + 301),
1159 kLatchTime(frameStartTime + 500),
Brian Andersonf6386862016-10-31 16:34:13 -07001160 kDequeueReadyTime(frameStartTime + 600),
Brian Anderson4e606e32017-03-16 15:34:57 -07001161 kReleaseTime(frameStartTime + 700),
Brian Anderson3da8d272016-07-28 16:20:47 -07001162 mRefreshes {
1163 { mFenceMap, frameStartTime + 410 },
1164 { mFenceMap, frameStartTime + 420 },
1165 { mFenceMap, frameStartTime + 430 } } {}
1166
1167 void signalQueueFences() {
1168 mFenceMap.signalAllForTest(
1169 mAcquireConsumer.mFence, kConsumerAcquireTime);
1170 mFenceMap.signalAllForTest(
1171 mAcquireProducer.mFence, kProducerAcquireTime);
1172 }
1173
1174 void signalRefreshFences() {
1175 for (auto& re : mRefreshes) {
1176 re.signalPostCompositeFences();
1177 }
1178 }
1179
1180 void signalReleaseFences() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001181 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1182 }
1183
1184 FenceToFenceTimeMap& mFenceMap;
1185
1186 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1187 FenceAndFenceTime mAcquireProducer { mFenceMap };
Brian Anderson3da8d272016-07-28 16:20:47 -07001188 FenceAndFenceTime mRelease { mFenceMap };
1189
1190 const nsecs_t kPostedTime;
1191 const nsecs_t kRequestedPresentTime;
1192 const nsecs_t kProducerAcquireTime;
1193 const nsecs_t kConsumerAcquireTime;
1194 const nsecs_t kLatchTime;
Brian Andersonf6386862016-10-31 16:34:13 -07001195 const nsecs_t kDequeueReadyTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001196 const nsecs_t kReleaseTime;
1197
1198 RefreshEvents mRefreshes[3];
1199 };
1200
Brian Andersond0010582017-03-07 13:20:31 -08001201 GetFrameTimestampsTest() {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001202
1203 virtual void SetUp() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001204 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1205 mFakeConsumer = new FakeConsumer;
1206 mCfeh = &mFakeConsumer->mFrameEventHistory;
1207 mConsumer->consumerConnect(mFakeConsumer, false);
1208 mConsumer->setConsumerName(String8("TestConsumer"));
1209 mSurface = new TestSurface(mProducer, &mFenceMap);
1210 mWindow = mSurface;
1211
1212 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1213 NATIVE_WINDOW_API_CPU));
Nolan Scobie9c427942023-05-01 16:41:28 -04001214 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(mWindow.get(), 4));
1215 ASSERT_EQ(NO_ERROR, native_window_set_usage(mWindow.get(), TEST_PRODUCER_USAGE_BITS));
Brian Anderson3da8d272016-07-28 16:20:47 -07001216 }
1217
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001218 void disableFrameTimestamps() {
1219 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1220 native_window_enable_frame_timestamps(mWindow.get(), 0);
1221 mFrameTimestampsEnabled = false;
1222 }
1223
Brian Anderson3da8d272016-07-28 16:20:47 -07001224 void enableFrameTimestamps() {
1225 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1226 native_window_enable_frame_timestamps(mWindow.get(), 1);
1227 mFrameTimestampsEnabled = true;
1228 }
1229
Brian Anderson1049d1d2016-12-16 17:25:57 -08001230 int getAllFrameTimestamps(uint64_t frameId) {
1231 return native_window_get_frame_timestamps(mWindow.get(), frameId,
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001232 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1233 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1234 &outGpuCompositionDoneTime, &outDisplayPresentTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001235 &outDequeueReadyTime, &outReleaseTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001236 }
1237
Brian Anderson3da8d272016-07-28 16:20:47 -07001238 void resetTimestamps() {
1239 outRequestedPresentTime = -1;
1240 outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001241 outLatchTime = -1;
1242 outFirstRefreshStartTime = -1;
1243 outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001244 outGpuCompositionDoneTime = -1;
1245 outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001246 outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001247 outReleaseTime = -1;
1248 }
1249
Brian Anderson1049d1d2016-12-16 17:25:57 -08001250 uint64_t getNextFrameId() {
1251 uint64_t frameId = -1;
1252 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1253 EXPECT_EQ(status, NO_ERROR);
1254 return frameId;
1255 }
1256
Brian Anderson3da8d272016-07-28 16:20:47 -07001257 void dequeueAndQueue(uint64_t frameIndex) {
1258 int fence = -1;
1259 ANativeWindowBuffer* buffer = nullptr;
1260 ASSERT_EQ(NO_ERROR,
1261 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1262
1263 int oldAddFrameTimestampsCount =
1264 mFakeConsumer->mAddFrameTimestampsCount;
1265
1266 FrameEvents* frame = &mFrames[frameIndex];
1267 uint64_t frameNumber = frameIndex + 1;
1268
1269 NewFrameEventsEntry fe;
1270 fe.frameNumber = frameNumber;
1271 fe.postedTime = frame->kPostedTime;
1272 fe.requestedPresentTime = frame->kRequestedPresentTime;
1273 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1274 mFakeConsumer->mNewFrameEntryOverride = fe;
1275
1276 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1277 frame->mAcquireProducer.mFenceTime,
1278 frame->mAcquireConsumer.mFenceTime);
1279
1280 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1281
1282 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1283
1284 EXPECT_EQ(
1285 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1286 mFakeConsumer->mAddFrameTimestampsCount);
1287 }
1288
1289 void addFrameEvents(
1290 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1291 FrameEvents* oldFrame =
1292 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1293 FrameEvents* newFrame = &mFrames[iNewFrame];
1294
Courtney Goeltzenleuchter5e921442018-01-19 13:43:43 -08001295 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001296 uint64_t nNewFrame = iNewFrame + 1;
1297
Brian Anderson4e606e32017-03-16 15:34:57 -07001298 // Latch, Composite, and Release the frames in a plausible order.
1299 // Note: The timestamps won't necessarily match the order, but
Brian Anderson3da8d272016-07-28 16:20:47 -07001300 // that's okay for the purposes of this test.
1301 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1302
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001303 // Composite the previous frame one more time, which helps verify
1304 // LastRefresh is updated properly.
1305 if (oldFrame != nullptr) {
1306 mCfeh->addPreComposition(nOldFrame,
1307 oldFrame->mRefreshes[2].kStartTime);
1308 gpuDoneFenceTime = gpuComposited ?
1309 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1310 FenceTime::NO_FENCE;
1311 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001312 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1313 oldFrame->mRefreshes[2].kCompositorTiming);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001314 }
1315
1316 // Latch the new frame.
Brian Anderson3da8d272016-07-28 16:20:47 -07001317 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1318
1319 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1320 gpuDoneFenceTime = gpuComposited ?
1321 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1322 FenceTime::NO_FENCE;
1323 // HWC2 releases the previous buffer after a new latch just before
Leon Scroggins III5b581492023-10-31 14:29:41 -04001324 // calling onCompositionPresented.
Brian Anderson3da8d272016-07-28 16:20:47 -07001325 if (oldFrame != nullptr) {
Brian Andersonf6386862016-10-31 16:34:13 -07001326 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
Brian Anderson3da8d272016-07-28 16:20:47 -07001327 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1328 }
1329 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001330 newFrame->mRefreshes[0].mPresent.mFenceTime,
1331 newFrame->mRefreshes[0].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001332
Brian Anderson3da8d272016-07-28 16:20:47 -07001333 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1334 gpuDoneFenceTime = gpuComposited ?
1335 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1336 FenceTime::NO_FENCE;
1337 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001338 newFrame->mRefreshes[1].mPresent.mFenceTime,
1339 newFrame->mRefreshes[1].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001340 }
1341
Brian Anderson3da8d272016-07-28 16:20:47 -07001342 sp<IGraphicBufferProducer> mProducer;
1343 sp<IGraphicBufferConsumer> mConsumer;
1344 sp<FakeConsumer> mFakeConsumer;
1345 ConsumerFrameEventHistory* mCfeh;
1346 sp<TestSurface> mSurface;
1347 sp<ANativeWindow> mWindow;
1348
1349 FenceToFenceTimeMap mFenceMap;
1350
1351 bool mFrameTimestampsEnabled = false;
1352
1353 int64_t outRequestedPresentTime = -1;
1354 int64_t outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001355 int64_t outLatchTime = -1;
1356 int64_t outFirstRefreshStartTime = -1;
1357 int64_t outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001358 int64_t outGpuCompositionDoneTime = -1;
1359 int64_t outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001360 int64_t outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001361 int64_t outReleaseTime = -1;
1362
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001363 FrameEvents mFrames[3] {
1364 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
Brian Anderson3da8d272016-07-28 16:20:47 -07001365};
1366
1367
1368// This test verifies that the frame timestamps are not retrieved when not
1369// explicitly enabled via native_window_enable_frame_timestamps.
1370// We want to check this to make sure there's no overhead for users
1371// that don't need the timestamp information.
1372TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1373 int fence;
1374 ANativeWindowBuffer* buffer;
1375
1376 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1377 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1378
Brian Anderson1049d1d2016-12-16 17:25:57 -08001379 const uint64_t fId = getNextFrameId();
1380
Brian Anderson3da8d272016-07-28 16:20:47 -07001381 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1382 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1383 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1384 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1385
1386 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1387 // It is okay that frame timestamps are added in the consumer since it is
1388 // still needed for SurfaceFlinger dumps.
1389 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1390 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1391 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1392
1393 // Verify attempts to get frame timestamps fail.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001394 int result = getAllFrameTimestamps(fId);
Brian Anderson3da8d272016-07-28 16:20:47 -07001395 EXPECT_EQ(INVALID_OPERATION, result);
1396 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001397
1398 // Verify compositor timing query fails.
1399 nsecs_t compositeDeadline = 0;
1400 nsecs_t compositeInterval = 0;
1401 nsecs_t compositeToPresentLatency = 0;
1402 result = native_window_get_compositor_timing(mWindow.get(),
1403 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1404 EXPECT_EQ(INVALID_OPERATION, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001405}
1406
1407// This test verifies that the frame timestamps are retrieved if explicitly
1408// enabled via native_window_enable_frame_timestamps.
1409TEST_F(GetFrameTimestampsTest, EnabledSimple) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001410 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001411 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1412
Brian Anderson3da8d272016-07-28 16:20:47 -07001413 enableFrameTimestamps();
1414
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001415 // Verify the compositor timing query gets the initial compositor values
1416 // after timststamps are enabled; even before the first frame is queued
1417 // or dequeued.
1418 nsecs_t compositeDeadline = 0;
1419 nsecs_t compositeInterval = 0;
1420 nsecs_t compositeToPresentLatency = 0;
1421 mSurface->setNow(initialCompositorTiming.deadline - 1);
1422 int result = native_window_get_compositor_timing(mWindow.get(),
1423 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1424 EXPECT_EQ(NO_ERROR, result);
1425 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1426 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1427 EXPECT_EQ(initialCompositorTiming.presentLatency,
1428 compositeToPresentLatency);
1429
Brian Anderson3da8d272016-07-28 16:20:47 -07001430 int fence;
1431 ANativeWindowBuffer* buffer;
1432
1433 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001434 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001435
Brian Anderson1049d1d2016-12-16 17:25:57 -08001436 const uint64_t fId1 = getNextFrameId();
1437
Brian Anderson3da8d272016-07-28 16:20:47 -07001438 // Verify getFrameTimestamps is piggybacked on dequeue.
1439 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1440 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001441 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001442
1443 NewFrameEventsEntry f1;
1444 f1.frameNumber = 1;
1445 f1.postedTime = mFrames[0].kPostedTime;
1446 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1447 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1448 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1449 mFrames[0].mAcquireProducer.mFenceTime,
1450 mFrames[0].mAcquireConsumer.mFenceTime);
1451 mFakeConsumer->mNewFrameEntryOverride = f1;
1452 mFrames[0].signalQueueFences();
1453
1454 // Verify getFrameTimestamps is piggybacked on queue.
1455 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1456 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1457 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001458 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001459
1460 // Verify queries for timestamps that the producer doesn't know about
1461 // triggers a call to see if the consumer has any new timestamps.
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001462 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001463 EXPECT_EQ(NO_ERROR, result);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001464 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001465}
1466
Brian Anderson6b376712017-04-04 10:51:39 -07001467TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1468 bool displayPresentSupported = true;
1469 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001470 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001471
1472 // Verify supported bits are forwarded.
1473 int supportsPresent = -1;
1474 mWindow.get()->query(mWindow.get(),
1475 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1476 EXPECT_EQ(displayPresentSupported, supportsPresent);
1477}
1478
1479TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1480 bool displayPresentSupported = false;
1481 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001482 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001483
1484 // Verify supported bits are forwarded.
1485 int supportsPresent = -1;
1486 mWindow.get()->query(mWindow.get(),
1487 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1488 EXPECT_EQ(displayPresentSupported, supportsPresent);
1489}
1490
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001491TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1492 nsecs_t phase = 4000;
1493 nsecs_t interval = 1000;
1494
1495 // Timestamp in previous interval.
1496 nsecs_t timestamp = 3500;
1497 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1498 timestamp, phase, interval));
1499
1500 // Timestamp in next interval.
1501 timestamp = 4500;
1502 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1503 timestamp, phase, interval));
1504
1505 // Timestamp multiple intervals before.
1506 timestamp = 2500;
1507 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1508 timestamp, phase, interval));
1509
1510 // Timestamp multiple intervals after.
1511 timestamp = 6500;
1512 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1513 timestamp, phase, interval));
1514
1515 // Timestamp on previous interval.
1516 timestamp = 3000;
1517 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1518 timestamp, phase, interval));
1519
1520 // Timestamp on next interval.
1521 timestamp = 5000;
1522 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1523 timestamp, phase, interval));
1524
1525 // Timestamp equal to phase.
1526 timestamp = 4000;
1527 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1528 timestamp, phase, interval));
1529}
1530
1531// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1532// if the number of intervals elapsed is internally stored in an int.
1533TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1534 nsecs_t phase = 0;
1535 nsecs_t interval = 4000;
1536 nsecs_t big_timestamp = 8635916564000;
1537 int32_t intervals = big_timestamp / interval;
1538
1539 EXPECT_LT(intervals, 0);
1540 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1541 big_timestamp, phase, interval));
1542 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1543 big_timestamp, big_timestamp, interval));
1544}
1545
1546// This verifies the compositor timing is updated by refresh events
1547// and piggy backed on a queue, dequeue, and enabling of timestamps..
1548TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001549 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001550 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1551
1552 enableFrameTimestamps();
1553
1554 // We get the initial values before any frames are submitted.
1555 nsecs_t compositeDeadline = 0;
1556 nsecs_t compositeInterval = 0;
1557 nsecs_t compositeToPresentLatency = 0;
1558 mSurface->setNow(initialCompositorTiming.deadline - 1);
1559 int result = native_window_get_compositor_timing(mWindow.get(),
1560 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1561 EXPECT_EQ(NO_ERROR, result);
1562 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1563 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1564 EXPECT_EQ(initialCompositorTiming.presentLatency,
1565 compositeToPresentLatency);
1566
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001567 dequeueAndQueue(0);
1568 addFrameEvents(true, NO_FRAME_INDEX, 0);
1569
1570 // Still get the initial values because the frame events for frame 0
1571 // didn't get a chance to piggyback on a queue or dequeue yet.
1572 result = native_window_get_compositor_timing(mWindow.get(),
1573 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1574 EXPECT_EQ(NO_ERROR, result);
1575 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1576 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1577 EXPECT_EQ(initialCompositorTiming.presentLatency,
1578 compositeToPresentLatency);
1579
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001580 dequeueAndQueue(1);
1581 addFrameEvents(true, 0, 1);
1582
1583 // Now expect the composite values associated with frame 1.
1584 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1585 result = native_window_get_compositor_timing(mWindow.get(),
1586 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1587 EXPECT_EQ(NO_ERROR, result);
1588 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1589 compositeDeadline);
1590 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1591 compositeInterval);
1592 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1593 compositeToPresentLatency);
1594
1595 dequeueAndQueue(2);
1596 addFrameEvents(true, 1, 2);
1597
1598 // Now expect the composite values associated with frame 2.
1599 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1600 result = native_window_get_compositor_timing(mWindow.get(),
1601 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1602 EXPECT_EQ(NO_ERROR, result);
1603 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1604 compositeDeadline);
1605 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1606 compositeInterval);
1607 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1608 compositeToPresentLatency);
1609
1610 // Re-enabling frame timestamps should get the latest values.
1611 disableFrameTimestamps();
1612 enableFrameTimestamps();
1613
1614 // Now expect the composite values associated with frame 3.
1615 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1616 result = native_window_get_compositor_timing(mWindow.get(),
1617 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1618 EXPECT_EQ(NO_ERROR, result);
1619 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1620 compositeDeadline);
1621 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1622 compositeInterval);
1623 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1624 compositeToPresentLatency);
1625}
1626
1627// This verifies the compositor deadline properly snaps to the the next
1628// deadline based on the current time.
1629TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001630 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001631 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1632
1633 enableFrameTimestamps();
1634
1635 nsecs_t compositeDeadline = 0;
1636 nsecs_t compositeInterval = 0;
1637 nsecs_t compositeToPresentLatency = 0;
1638
1639 // A "now" just before the deadline snaps to the deadline.
1640 mSurface->setNow(initialCompositorTiming.deadline - 1);
1641 int result = native_window_get_compositor_timing(mWindow.get(),
1642 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1643 EXPECT_EQ(NO_ERROR, result);
1644 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1645 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1646 EXPECT_EQ(expectedDeadline, compositeDeadline);
1647
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001648 dequeueAndQueue(0);
1649 addFrameEvents(true, NO_FRAME_INDEX, 0);
1650
1651 // A "now" just after the deadline snaps properly.
1652 mSurface->setNow(initialCompositorTiming.deadline + 1);
1653 result = native_window_get_compositor_timing(mWindow.get(),
1654 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1655 EXPECT_EQ(NO_ERROR, result);
1656 expectedDeadline =
1657 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1658 EXPECT_EQ(expectedDeadline, compositeDeadline);
1659
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001660 dequeueAndQueue(1);
1661 addFrameEvents(true, 0, 1);
1662
1663 // A "now" just after the next interval snaps properly.
1664 mSurface->setNow(
1665 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1666 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1667 result = native_window_get_compositor_timing(mWindow.get(),
1668 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1669 EXPECT_EQ(NO_ERROR, result);
1670 expectedDeadline =
1671 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1672 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1673 EXPECT_EQ(expectedDeadline, compositeDeadline);
1674
1675 dequeueAndQueue(2);
1676 addFrameEvents(true, 1, 2);
1677
1678 // A "now" over 1 interval before the deadline snaps properly.
1679 mSurface->setNow(
1680 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1681 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1682 result = native_window_get_compositor_timing(mWindow.get(),
1683 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1684 EXPECT_EQ(NO_ERROR, result);
1685 expectedDeadline =
1686 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1687 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1688 EXPECT_EQ(expectedDeadline, compositeDeadline);
1689
1690 // Re-enabling frame timestamps should get the latest values.
1691 disableFrameTimestamps();
1692 enableFrameTimestamps();
1693
1694 // A "now" over 2 intervals before the deadline snaps properly.
1695 mSurface->setNow(
1696 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1697 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1698 result = native_window_get_compositor_timing(mWindow.get(),
1699 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1700 EXPECT_EQ(NO_ERROR, result);
1701 expectedDeadline =
1702 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1703 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1704 EXPECT_EQ(expectedDeadline, compositeDeadline);
1705}
1706
Brian Anderson1049d1d2016-12-16 17:25:57 -08001707// This verifies the timestamps recorded in the consumer's
1708// FrameTimestampsHistory are properly retrieved by the producer for the
1709// correct frames.
Brian Anderson3da8d272016-07-28 16:20:47 -07001710TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1711 enableFrameTimestamps();
1712
Brian Anderson1049d1d2016-12-16 17:25:57 -08001713 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001714 dequeueAndQueue(0);
1715 mFrames[0].signalQueueFences();
1716
Brian Anderson1049d1d2016-12-16 17:25:57 -08001717 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001718 dequeueAndQueue(1);
1719 mFrames[1].signalQueueFences();
1720
1721 addFrameEvents(true, NO_FRAME_INDEX, 0);
1722 mFrames[0].signalRefreshFences();
1723 addFrameEvents(true, 0, 1);
1724 mFrames[0].signalReleaseFences();
1725 mFrames[1].signalRefreshFences();
1726
1727 // Verify timestamps are correct for frame 1.
Brian Anderson3da8d272016-07-28 16:20:47 -07001728 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001729 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001730 EXPECT_EQ(NO_ERROR, result);
1731 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1732 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001733 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1734 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1735 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001736 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1737 outGpuCompositionDoneTime);
1738 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001739 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001740 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1741
1742 // Verify timestamps are correct for frame 2.
Brian Anderson3da8d272016-07-28 16:20:47 -07001743 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001744 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07001745 EXPECT_EQ(NO_ERROR, result);
1746 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1747 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001748 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1749 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1750 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001751 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1752 outGpuCompositionDoneTime);
1753 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001754 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1755 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001756}
1757
1758// This test verifies the acquire fence recorded by the consumer is not sent
1759// back to the producer and the producer saves its own fence.
1760TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1761 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001762
Brian Anderson3da8d272016-07-28 16:20:47 -07001763 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001764 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001765 dequeueAndQueue(0);
1766
1767 // Verify queue-related timestamps for f1 are available immediately in the
1768 // producer without asking the consumer again, even before signaling the
1769 // acquire fence.
1770 resetTimestamps();
1771 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001772 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001773 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001774 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001775 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1776 EXPECT_EQ(NO_ERROR, result);
1777 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001778 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001779
1780 // Signal acquire fences. Verify a sync call still isn't necessary.
1781 mFrames[0].signalQueueFences();
1782
1783 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001784 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001785 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001786 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001787 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1788 EXPECT_EQ(NO_ERROR, result);
1789 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1790 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1791
1792 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001793 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001794 dequeueAndQueue(1);
1795
1796 // Verify queue-related timestamps for f2 are available immediately in the
1797 // producer without asking the consumer again, even before signaling the
1798 // acquire fence.
1799 resetTimestamps();
1800 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001801 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001802 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001803 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001804 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1805 EXPECT_EQ(NO_ERROR, result);
1806 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001807 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001808
1809 // Signal acquire fences. Verify a sync call still isn't necessary.
1810 mFrames[1].signalQueueFences();
1811
1812 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001813 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001814 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001815 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001816 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1817 EXPECT_EQ(NO_ERROR, result);
1818 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1819 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1820}
1821
1822TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1823 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001824
1825 // Dequeue and queue frame 1.
1826 dequeueAndQueue(0);
1827 mFrames[0].signalQueueFences();
1828
1829 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001830 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001831 dequeueAndQueue(1);
1832 mFrames[1].signalQueueFences();
1833
1834 addFrameEvents(true, NO_FRAME_INDEX, 0);
1835 mFrames[0].signalRefreshFences();
1836 addFrameEvents(true, 0, 1);
1837 mFrames[0].signalReleaseFences();
1838 mFrames[1].signalRefreshFences();
1839
1840 // Verify a request for no timestamps doesn't result in a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001841 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001842 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson6b376712017-04-04 10:51:39 -07001843 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1844 nullptr, nullptr);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001845 EXPECT_EQ(NO_ERROR, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001846 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1847}
1848
1849// This test verifies that fences can signal and update timestamps producer
1850// side without an additional sync call to the consumer.
1851TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1852 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001853
1854 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001855 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001856 dequeueAndQueue(0);
1857 mFrames[0].signalQueueFences();
1858
1859 // Dequeue and queue frame 2.
1860 dequeueAndQueue(1);
1861 mFrames[1].signalQueueFences();
1862
1863 addFrameEvents(true, NO_FRAME_INDEX, 0);
1864 addFrameEvents(true, 0, 1);
1865
1866 // Verify available timestamps are correct for frame 1, before any
1867 // fence has been signaled.
1868 // Note: A sync call is necessary here since the events triggered by
1869 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07001870 resetTimestamps();
1871 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001872 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001873 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1874 EXPECT_EQ(NO_ERROR, result);
1875 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1876 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001877 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1878 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1879 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001880 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1881 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001882 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001883 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001884
1885 // Verify available timestamps are correct for frame 1 again, before any
1886 // fence has been signaled.
1887 // This time a sync call should not be necessary.
Brian Anderson3da8d272016-07-28 16:20:47 -07001888 resetTimestamps();
1889 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001890 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001891 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1892 EXPECT_EQ(NO_ERROR, result);
1893 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1894 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001895 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1896 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1897 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001898 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1899 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001900 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001901 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001902
1903 // Signal the fences for frame 1.
1904 mFrames[0].signalRefreshFences();
1905 mFrames[0].signalReleaseFences();
1906
1907 // Verify all timestamps are available without a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001908 resetTimestamps();
1909 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001910 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001911 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1912 EXPECT_EQ(NO_ERROR, result);
1913 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1914 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001915 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1916 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1917 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001918 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1919 outGpuCompositionDoneTime);
1920 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001921 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001922 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1923}
1924
1925// This test verifies that if the frame wasn't GPU composited but has a refresh
1926// event a sync call isn't made to get the GPU composite done time since it will
1927// never exist.
1928TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1929 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001930
Brian Anderson3da8d272016-07-28 16:20:47 -07001931 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001932 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001933 dequeueAndQueue(0);
1934 mFrames[0].signalQueueFences();
1935
1936 // Dequeue and queue frame 2.
1937 dequeueAndQueue(1);
1938 mFrames[1].signalQueueFences();
1939
1940 addFrameEvents(false, NO_FRAME_INDEX, 0);
1941 addFrameEvents(false, 0, 1);
1942
1943 // Verify available timestamps are correct for frame 1, before any
1944 // fence has been signaled.
1945 // Note: A sync call is necessary here since the events triggered by
1946 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1947 resetTimestamps();
1948 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001949 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001950 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1951 EXPECT_EQ(NO_ERROR, result);
1952 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1953 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001954 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1955 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1956 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001957 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1958 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001959 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001960 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001961
1962 // Signal the fences for frame 1.
1963 mFrames[0].signalRefreshFences();
1964 mFrames[0].signalReleaseFences();
1965
1966 // Verify all timestamps, except GPU composition, are available without a
1967 // sync call.
1968 resetTimestamps();
1969 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001970 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001971 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1972 EXPECT_EQ(NO_ERROR, result);
1973 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1974 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001975 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1976 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1977 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001978 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001979 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001980 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001981 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1982}
1983
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001984// This test verifies that if the certain timestamps can't possibly exist for
1985// the most recent frame, then a sync call is not done.
Brian Anderson6b376712017-04-04 10:51:39 -07001986TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001987 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001988
1989 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001990 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001991 dequeueAndQueue(0);
1992 mFrames[0].signalQueueFences();
1993
1994 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001995 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001996 dequeueAndQueue(1);
1997 mFrames[1].signalQueueFences();
1998
1999 addFrameEvents(false, NO_FRAME_INDEX, 0);
2000 addFrameEvents(false, 0, 1);
2001
2002 // Verify available timestamps are correct for frame 1, before any
2003 // fence has been signaled.
2004 // Note: A sync call is necessary here since the events triggered by
2005 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07002006 resetTimestamps();
2007 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08002008 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07002009 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
2010 EXPECT_EQ(NO_ERROR, result);
2011 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
2012 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002013 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
2014 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2015 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002016 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
2017 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002018 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002019 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002020
2021 mFrames[0].signalRefreshFences();
2022 mFrames[0].signalReleaseFences();
2023 mFrames[1].signalRefreshFences();
2024
Brian Anderson1049d1d2016-12-16 17:25:57 -08002025 // Verify querying for all timestmaps of f2 does not do a sync call. Even
Brian Anderson4e606e32017-03-16 15:34:57 -07002026 // though the lastRefresh, dequeueReady, and release times aren't
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002027 // available, a sync call should not occur because it's not possible for f2
2028 // to encounter the final value for those events until another frame is
2029 // queued.
Brian Anderson3da8d272016-07-28 16:20:47 -07002030 resetTimestamps();
2031 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08002032 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07002033 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2034 EXPECT_EQ(NO_ERROR, result);
2035 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
2036 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002037 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
2038 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2039 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002040 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002041 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002042 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
2043 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002044}
2045
Brian Anderson6b376712017-04-04 10:51:39 -07002046// This test verifies there are no sync calls for present times
2047// when they aren't supported and that an error is returned.
2048
2049TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
2050 enableFrameTimestamps();
2051 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
Huihong Luo0a81aa32022-02-22 16:02:36 -08002052 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(false);
Brian Anderson6b376712017-04-04 10:51:39 -07002053
2054 // Dequeue and queue frame 1.
2055 const uint64_t fId1 = getNextFrameId();
2056 dequeueAndQueue(0);
2057
2058 // Verify a query for the Present times do not trigger a sync call if they
2059 // are not supported.
2060 resetTimestamps();
2061 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2062 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
2063 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
2064 &outDisplayPresentTime, nullptr, nullptr);
2065 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2066 EXPECT_EQ(BAD_VALUE, result);
2067 EXPECT_EQ(-1, outDisplayPresentTime);
2068}
2069
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002070TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
2071 sp<IGraphicBufferProducer> producer;
2072 sp<IGraphicBufferConsumer> consumer;
2073 BufferQueue::createBufferQueue(&producer, &consumer);
2074
Peiyong Lind8460c82020-07-28 16:04:22 -07002075 sp<MockConsumer> mockConsumer(new MockConsumer);
2076 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002077 consumer->setDefaultBufferSize(10, 10);
2078
2079 sp<Surface> surface = new Surface(producer);
2080 sp<ANativeWindow> window(surface);
Nolan Scobie9c427942023-05-01 16:41:28 -04002081 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2082 ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(window.get(), 0, 0));
2083 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002084
2085 int fence;
2086 ANativeWindowBuffer* buffer;
2087
2088 // Buffer size is driven by the consumer
2089 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2090 EXPECT_EQ(10, buffer->width);
2091 EXPECT_EQ(10, buffer->height);
2092 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2093
2094 // Buffer size is driven by the consumer
2095 consumer->setDefaultBufferSize(10, 20);
2096 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2097 EXPECT_EQ(10, buffer->width);
2098 EXPECT_EQ(20, buffer->height);
2099 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2100
2101 // Transform hint isn't synced to producer before queueBuffer or connect
2102 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2103 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2104 EXPECT_EQ(10, buffer->width);
2105 EXPECT_EQ(20, buffer->height);
2106 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2107
2108 // Transform hint is synced to producer but no auto prerotation
2109 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2110 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2111 EXPECT_EQ(10, buffer->width);
2112 EXPECT_EQ(20, buffer->height);
2113 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2114
2115 // Prerotation is driven by the consumer with the transform hint used by producer
2116 native_window_set_auto_prerotation(window.get(), true);
2117 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2118 EXPECT_EQ(20, buffer->width);
2119 EXPECT_EQ(10, buffer->height);
2120 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2121
2122 // Turn off auto prerotaton
2123 native_window_set_auto_prerotation(window.get(), false);
2124 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2125 EXPECT_EQ(10, buffer->width);
2126 EXPECT_EQ(20, buffer->height);
2127 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2128
2129 // Test auto prerotation bit is disabled after disconnect
2130 native_window_set_auto_prerotation(window.get(), true);
2131 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2132 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2133 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2134 native_window_set_buffers_dimensions(window.get(), 0, 0);
Nolan Scobie9c427942023-05-01 16:41:28 -04002135 native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS);
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002136 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2137 EXPECT_EQ(10, buffer->width);
2138 EXPECT_EQ(20, buffer->height);
2139 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2140}
2141
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002142TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2143 sp<IGraphicBufferProducer> producer;
2144 sp<IGraphicBufferConsumer> consumer;
2145 BufferQueue::createBufferQueue(&producer, &consumer);
2146
Peiyong Lind8460c82020-07-28 16:04:22 -07002147 sp<MockConsumer> mockConsumer(new MockConsumer);
2148 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002149
2150 sp<Surface> surface = new Surface(producer);
2151 sp<ANativeWindow> window(surface);
2152
2153 int count = -1;
2154 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2155 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2156
2157 consumer->setMaxBufferCount(10);
2158 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2159 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2160 EXPECT_EQ(10, count);
2161
2162 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2163 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2164 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2165}
2166
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002167TEST_F(SurfaceTest, BatchOperations) {
2168 const int BUFFER_COUNT = 16;
2169 const int BATCH_SIZE = 8;
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002170
Jim Shargod30823a2024-07-27 02:49:39 +00002171 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
2172 sp<Surface> surface = cpuConsumer->getSurface();
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002173 sp<ANativeWindow> window(surface);
Carlos Martinez Romeroab8443c2024-07-03 13:50:10 -07002174 sp<StubSurfaceListener> listener = new StubSurfaceListener();
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002175
2176 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2177 /*reportBufferRemoval*/false));
2178
2179 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2180
2181 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2182
2183 // Batch dequeued buffers can be queued individually
2184 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2185 for (size_t i = 0; i < BATCH_SIZE; i++) {
2186 ANativeWindowBuffer* buffer = buffers[i].buffer;
2187 int fence = buffers[i].fenceFd;
2188 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2189 }
2190
2191 // Batch dequeued buffers can be canceled individually
2192 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2193 for (size_t i = 0; i < BATCH_SIZE; i++) {
2194 ANativeWindowBuffer* buffer = buffers[i].buffer;
2195 int fence = buffers[i].fenceFd;
2196 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2197 }
2198
2199 // Batch dequeued buffers can be batch cancelled
2200 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2201 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2202
2203 // Batch dequeued buffers can be batch queued
2204 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2205 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2206 for (size_t i = 0; i < BATCH_SIZE; i++) {
2207 queuedBuffers[i].buffer = buffers[i].buffer;
2208 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2209 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2210 }
2211 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2212
2213 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2214}
2215
2216TEST_F(SurfaceTest, BatchIllegalOperations) {
2217 const int BUFFER_COUNT = 16;
2218 const int BATCH_SIZE = 8;
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002219
Jim Shargod30823a2024-07-27 02:49:39 +00002220 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
2221 sp<Surface> surface = cpuConsumer->getSurface();
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002222 sp<ANativeWindow> window(surface);
Carlos Martinez Romeroab8443c2024-07-03 13:50:10 -07002223 sp<StubSurfaceListener> listener = new StubSurfaceListener();
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002224
2225 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2226 /*reportBufferRemoval*/false));
2227
2228 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2229
2230 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2231 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2232
2233 // Batch operations are invalid in shared buffer mode
2234 surface->setSharedBufferMode(true);
2235 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2236 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2237 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2238 surface->setSharedBufferMode(false);
2239
2240 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2241}
2242
Jim Shargo00886392024-07-12 22:12:20 +00002243#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
2244
2245TEST_F(SurfaceTest, PlatformBufferMethods) {
Jim Shargod30823a2024-07-27 02:49:39 +00002246 sp<CpuConsumer> cpuConsumer = sp<CpuConsumer>::make(1);
2247 sp<Surface> surface = cpuConsumer->getSurface();
Jim Shargo00886392024-07-12 22:12:20 +00002248 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2249 sp<GraphicBuffer> buffer;
2250 sp<Fence> fence;
2251
2252 EXPECT_EQ(OK,
2253 surface->connect(NATIVE_WINDOW_API_CPU, listener, /* reportBufferRemoval */ false));
2254
2255 //
2256 // Verify nullptrs are handled safely:
2257 //
2258
2259 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer((sp<GraphicBuffer>*)nullptr, nullptr));
2260 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer((sp<GraphicBuffer>*)nullptr, &fence));
2261 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer(&buffer, nullptr));
2262 EXPECT_EQ(BAD_VALUE, surface->queueBuffer(nullptr, nullptr));
2263 EXPECT_EQ(BAD_VALUE, surface->detachBuffer(nullptr));
2264
2265 //
2266 // Verify dequeue/queue:
2267 //
2268
2269 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2270 EXPECT_NE(nullptr, buffer);
2271 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2272
2273 //
2274 // Verify dequeue/detach:
2275 //
2276
2277 wp<GraphicBuffer> weakBuffer;
2278 {
2279 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2280
2281 EXPECT_EQ(OK, surface->detachBuffer(buffer));
2282
2283 weakBuffer = buffer;
2284 buffer = nullptr;
2285 }
2286 EXPECT_EQ(nullptr, weakBuffer.promote()) << "Weak buffer still held by Surface.";
2287
2288 //
2289 // Verify detach without borrowing the buffer does not work:
2290 //
2291
2292 sp<GraphicBuffer> heldTooLongBuffer;
2293 EXPECT_EQ(OK, surface->dequeueBuffer(&heldTooLongBuffer, &fence));
2294 EXPECT_EQ(OK, surface->queueBuffer(heldTooLongBuffer));
2295 EXPECT_EQ(BAD_VALUE, surface->detachBuffer(heldTooLongBuffer));
2296}
Jim Shargoe77d47e2024-07-17 21:29:08 +00002297
2298TEST_F(SurfaceTest, AllowAllocation) {
Jim Shargoe77d47e2024-07-17 21:29:08 +00002299 // controlledByApp must be true to disable blocking
Jim Shargod30823a2024-07-27 02:49:39 +00002300 sp<CpuConsumer> cpuConsumer = sp<CpuConsumer>::make(1, /*controlledByApp*/ true);
2301 sp<Surface> surface = cpuConsumer->getSurface();
Jim Shargoe77d47e2024-07-17 21:29:08 +00002302 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2303 sp<GraphicBuffer> buffer;
2304 sp<Fence> fence;
2305
2306 EXPECT_EQ(OK,
2307 surface->connect(NATIVE_WINDOW_API_CPU, listener, /* reportBufferRemoval */ false));
2308 EXPECT_EQ(OK, surface->allowAllocation(false));
2309
2310 EXPECT_EQ(OK, surface->setDequeueTimeout(-1));
2311 EXPECT_EQ(WOULD_BLOCK, surface->dequeueBuffer(&buffer, &fence));
2312
2313 EXPECT_EQ(OK, surface->setDequeueTimeout(10));
2314 EXPECT_EQ(TIMED_OUT, surface->dequeueBuffer(&buffer, &fence));
2315
2316 EXPECT_EQ(OK, surface->allowAllocation(true));
2317 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2318}
Jim Shargoc6049932024-07-08 22:40:59 +00002319
2320TEST_F(SurfaceTest, QueueAcquireReleaseDequeue_CalledInStack_DoesNotDeadlock) {
2321 class DequeuingSurfaceListener : public SurfaceListener {
2322 public:
2323 DequeuingSurfaceListener(const wp<Surface>& surface) : mSurface(surface) {}
2324
2325 virtual void onBufferReleased() override {
2326 sp<Surface> surface = mSurface.promote();
2327 ASSERT_NE(nullptr, surface);
2328 EXPECT_EQ(OK, surface->dequeueBuffer(&mBuffer, &mFence));
2329 }
2330
2331 virtual bool needsReleaseNotify() override { return true; }
2332 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>&) override {}
2333 virtual void onBufferDetached(int) override {}
2334
2335 sp<GraphicBuffer> mBuffer;
2336 sp<Fence> mFence;
2337
2338 private:
2339 wp<Surface> mSurface;
2340 };
2341
2342 class ImmediateReleaseConsumerListener : public BufferItemConsumer::FrameAvailableListener {
2343 public:
2344 ImmediateReleaseConsumerListener(const wp<BufferItemConsumer>& consumer)
2345 : mConsumer(consumer) {}
2346
2347 virtual void onFrameAvailable(const BufferItem&) override {
2348 sp<BufferItemConsumer> consumer = mConsumer.promote();
2349 ASSERT_NE(nullptr, consumer);
2350
2351 mCalls += 1;
2352
2353 BufferItem buffer;
2354 EXPECT_EQ(OK, consumer->acquireBuffer(&buffer, 0));
2355 EXPECT_EQ(OK, consumer->releaseBuffer(buffer));
2356 }
2357
2358 size_t mCalls = 0;
2359
2360 private:
2361 wp<BufferItemConsumer> mConsumer;
2362 };
2363
2364 sp<IGraphicBufferProducer> bqProducer;
2365 sp<IGraphicBufferConsumer> bqConsumer;
2366 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
2367
2368 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(bqConsumer, 3);
2369 sp<Surface> surface = sp<Surface>::make(bqProducer);
2370 sp<ImmediateReleaseConsumerListener> consumerListener =
2371 sp<ImmediateReleaseConsumerListener>::make(consumer);
2372 consumer->setFrameAvailableListener(consumerListener);
2373
2374 sp<DequeuingSurfaceListener> surfaceListener = sp<DequeuingSurfaceListener>::make(surface);
Carlos Martinez Romero6a5fdc12024-07-22 09:40:33 -07002375 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, surfaceListener, false));
Jim Shargoc6049932024-07-08 22:40:59 +00002376
2377 EXPECT_EQ(OK, surface->setMaxDequeuedBufferCount(2));
2378
2379 sp<GraphicBuffer> buffer;
2380 sp<Fence> fence;
2381 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2382 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2383
2384 EXPECT_EQ(1u, consumerListener->mCalls);
2385 EXPECT_NE(nullptr, surfaceListener->mBuffer);
2386
2387 EXPECT_EQ(OK, surface->disconnect(NATIVE_WINDOW_API_CPU));
2388}
Jim Shargo785d2e22024-07-29 23:21:08 +00002389
2390TEST_F(SurfaceTest, ViewSurface_toString) {
2391 view::Surface surface{};
2392 EXPECT_EQ("", surface.toString());
2393
2394 surface.name = String16("name");
2395 EXPECT_EQ("name", surface.toString());
2396}
Jim Shargoa3da3022024-07-10 23:39:10 +00002397
2398TEST_F(SurfaceTest, TestRemoteSurfaceDied_CallbackCalled) {
2399 sp<TestServerClient> testServer = TestServerClient::Create();
2400 sp<IGraphicBufferProducer> producer = testServer->CreateProducer();
2401 EXPECT_NE(nullptr, producer);
2402
2403 sp<Surface> surface = sp<Surface>::make(producer);
2404 sp<DeathWatcherListener> deathWatcher = sp<DeathWatcherListener>::make();
2405 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, deathWatcher));
2406
2407 auto diedFuture = deathWatcher->getDiedFuture();
2408 EXPECT_EQ(OK, testServer->Kill());
2409
2410 diedFuture.wait();
2411 EXPECT_TRUE(diedFuture.get());
2412}
2413
2414TEST_F(SurfaceTest, TestRemoteSurfaceDied_Disconnect_CallbackNotCalled) {
2415 sp<TestServerClient> testServer = TestServerClient::Create();
2416 sp<IGraphicBufferProducer> producer = testServer->CreateProducer();
2417 EXPECT_NE(nullptr, producer);
2418
2419 sp<Surface> surface = sp<Surface>::make(producer);
2420 sp<DeathWatcherListener> deathWatcher = sp<DeathWatcherListener>::make();
2421 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, deathWatcher));
2422 EXPECT_EQ(OK, surface->disconnect(NATIVE_WINDOW_API_CPU));
2423
2424 auto watcherDiedFuture = deathWatcher->getDiedFuture();
2425 EXPECT_EQ(OK, testServer->Kill());
2426
2427 std::future_status status = watcherDiedFuture.wait_for(std::chrono::seconds(1));
2428 EXPECT_EQ(std::future_status::timeout, status);
2429}
Jim Shargobad6c062024-07-10 23:39:10 +00002430
2431TEST_F(SurfaceTest, QueueBufferOutput_TracksReplacements) {
2432 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(GRALLOC_USAGE_SW_READ_OFTEN);
2433 ASSERT_EQ(OK, consumer->setMaxBufferCount(3));
2434 ASSERT_EQ(OK, consumer->setMaxAcquiredBufferCount(1));
2435
2436 sp<Surface> surface = consumer->getSurface();
2437 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2438
2439 // Async mode sets up an extra buffer so the surface can queue it without waiting.
2440 ASSERT_EQ(OK, surface->setMaxDequeuedBufferCount(1));
2441 ASSERT_EQ(OK, surface->setAsyncMode(true));
2442 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, listener));
2443
2444 sp<GraphicBuffer> buffer;
2445 sp<Fence> fence;
2446 SurfaceQueueBufferOutput output;
2447 BufferItem item;
2448
2449 // We can queue directly, without an output arg.
2450 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2451 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2452 EXPECT_EQ(OK, consumer->acquireBuffer(&item, 0));
2453 EXPECT_EQ(OK, consumer->releaseBuffer(item));
2454
2455 // We can queue with an output arg, and that we don't expect to see a replacement.
2456 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2457 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence, &output));
2458 EXPECT_FALSE(output.bufferReplaced);
2459
2460 // We expect see a replacement when we queue a second buffer in async mode, and the consumer
2461 // hasn't acquired the first one yet.
2462 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2463 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence, &output));
2464 EXPECT_TRUE(output.bufferReplaced);
2465}
2466
2467TEST_F(SurfaceTest, QueueBufferOutput_TracksReplacements_Plural) {
2468 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(GRALLOC_USAGE_SW_READ_OFTEN);
2469 ASSERT_EQ(OK, consumer->setMaxBufferCount(4));
2470 ASSERT_EQ(OK, consumer->setMaxAcquiredBufferCount(1));
2471
2472 sp<Surface> surface = consumer->getSurface();
2473 consumer->setName(String8("TRPTest"));
2474 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2475
2476 // Async mode sets up an extra buffer so the surface can queue it without waiting.
2477 ASSERT_EQ(OK, surface->setMaxDequeuedBufferCount(2));
2478 ASSERT_EQ(OK, surface->setAsyncMode(true));
2479 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, listener));
2480
2481 // dequeueBuffers requires a vector of a certain size:
2482 std::vector<Surface::BatchBuffer> buffers(2);
2483 std::vector<Surface::BatchQueuedBuffer> queuedBuffers;
2484 std::vector<SurfaceQueueBufferOutput> outputs;
2485 BufferItem item;
2486
2487 auto moveBuffersToQueuedBuffers = [&]() {
2488 EXPECT_EQ(2u, buffers.size());
2489 EXPECT_NE(nullptr, buffers[0].buffer);
2490 EXPECT_NE(nullptr, buffers[1].buffer);
2491
2492 queuedBuffers.clear();
2493 for (auto& buffer : buffers) {
2494 auto& queuedBuffer = queuedBuffers.emplace_back();
2495 queuedBuffer.buffer = buffer.buffer;
2496 queuedBuffer.fenceFd = buffer.fenceFd;
2497 queuedBuffer.timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2498 }
2499 buffers = {{}, {}};
2500 };
2501
2502 // We can queue directly, without an output arg.
2503 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2504 moveBuffersToQueuedBuffers();
2505 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers));
2506 EXPECT_EQ(OK, consumer->acquireBuffer(&item, 0));
2507 EXPECT_EQ(OK, consumer->releaseBuffer(item));
2508
2509 // We can queue with an output arg. Only the second one should be replaced.
2510 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2511 moveBuffersToQueuedBuffers();
2512 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers, &outputs));
2513 EXPECT_EQ(2u, outputs.size());
2514 EXPECT_FALSE(outputs[0].bufferReplaced);
2515 EXPECT_TRUE(outputs[1].bufferReplaced);
2516
2517 // Since we haven't acquired anything, both queued buffers will replace the original one.
2518 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2519 moveBuffersToQueuedBuffers();
2520 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers, &outputs));
2521 EXPECT_EQ(2u, outputs.size());
2522 EXPECT_TRUE(outputs[0].bufferReplaced);
2523 EXPECT_TRUE(outputs[1].bufferReplaced);
2524}
Jim Shargo00886392024-07-12 22:12:20 +00002525#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
2526
Dan Stoza932f0082017-05-31 13:50:16 -07002527} // namespace android