blob: 096a43cd952c8834fb173e11b7ebdb4cf8256023 [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
Peiyong Lind8460c82020-07-28 16:04:22 -070017#include "MockConsumer.h"
Dan Stozac6f30bd2015-06-08 09:32:50 -070018
Jamie Gennis134f0422011-03-08 12:18:54 -080019#include <gtest/gtest.h>
Jamie Gennis7a4d0df2011-03-09 17:05:02 -080020
Sundong Ahnf33c9f12020-04-23 21:31:20 +090021#include <SurfaceFlingerProperties.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080022#include <android/gui/IDisplayEventConnection.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080023#include <android/gui/ISurfaceComposer.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060024#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070025#include <binder/ProcessState.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060026#include <configstore/Utils.h>
Huihong Luo3bdef862022-03-03 11:57:19 -080027#include <gui/AidlStatusUtil.h>
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -070028#include <gui/BufferItemConsumer.h>
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -070029#include <gui/IProducerListener.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080030#include <gui/ISurfaceComposer.h>
31#include <gui/Surface.h>
32#include <gui/SurfaceComposerClient.h>
chaviwe7b9f272020-08-18 16:08:59 -070033#include <gui/SyncScreenCaptureListener.h>
Sundong Ahnf33c9f12020-04-23 21:31:20 +090034#include <inttypes.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070035#include <private/gui/ComposerService.h>
Huihong Luof5029222021-12-16 14:33:46 -080036#include <private/gui/ComposerServiceAIDL.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080037#include <sys/types.h>
Yiwei Zhang74c9cc32020-06-20 03:35:17 -070038#include <ui/BufferQueueDefs.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010039#include <ui/DisplayMode.h>
Dan Stozac1879002014-05-22 15:59:05 -070040#include <ui/Rect.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080041#include <utils/Errors.h>
Jamie Gennis134f0422011-03-08 12:18:54 -080042#include <utils/String8.h>
43
Brian Anderson3da8d272016-07-28 16:20:47 -070044#include <limits>
Kalle Raita643f0942016-12-07 09:20:14 -080045#include <thread>
46
Jamie Gennis134f0422011-03-08 12:18:54 -080047namespace android {
48
Kalle Raita643f0942016-12-07 09:20:14 -080049using namespace std::chrono_literals;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060050// retrieve wide-color and hdr settings from configstore
51using namespace android::hardware::configstore;
52using namespace android::hardware::configstore::V1_0;
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050053using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
Huihong Luo6fac5232021-11-22 16:05:23 -080054using gui::IDisplayEventConnection;
Huihong Luoecc1f902021-11-20 11:55:05 -080055using gui::IRegionSamplingListener;
Peiyong Lin9f034472018-03-28 15:29:00 -070056using ui::ColorMode;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060057
Robert Carr4cdc58f2017-08-23 14:22:20 -070058using Transaction = SurfaceComposerClient::Transaction;
59
Sundong Ahnf33c9f12020-04-23 21:31:20 +090060static bool hasWideColorDisplay = android::sysprop::has_wide_color_display(false);
Kalle Raita643f0942016-12-07 09:20:14 -080061
Sundong Ahnf33c9f12020-04-23 21:31:20 +090062static bool hasHdrDisplay = android::sysprop::has_HDR_display(false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -070063
Brian Anderson3da8d272016-07-28 16:20:47 -070064class FakeSurfaceComposer;
65class FakeProducerFrameEventHistory;
66
67static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
68
Peiyong Lind8460c82020-07-28 16:04:22 -070069class FakeSurfaceListener : public SurfaceListener {
Shuzhen Wang067fcd32019-08-14 10:41:12 -070070public:
Peiyong Lind8460c82020-07-28 16:04:22 -070071 FakeSurfaceListener(bool enableReleasedCb = false)
72 : mEnableReleaseCb(enableReleasedCb), mBuffersReleased(0) {}
73 virtual ~FakeSurfaceListener() = default;
Shuzhen Wang067fcd32019-08-14 10:41:12 -070074
75 virtual void onBufferReleased() {
76 mBuffersReleased++;
77 }
78 virtual bool needsReleaseNotify() {
79 return mEnableReleaseCb;
80 }
81 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers) {
82 mDiscardedBuffers.insert(mDiscardedBuffers.end(), buffers.begin(), buffers.end());
83 }
84
85 int getReleaseNotifyCount() const {
86 return mBuffersReleased;
87 }
88 const std::vector<sp<GraphicBuffer>>& getDiscardedBuffers() const {
89 return mDiscardedBuffers;
90 }
91private:
92 // No need to use lock given the test triggers the listener in the same
93 // thread context.
94 bool mEnableReleaseCb;
95 int32_t mBuffersReleased;
96 std::vector<sp<GraphicBuffer>> mDiscardedBuffers;
97};
98
Jamie Gennis134f0422011-03-08 12:18:54 -080099class SurfaceTest : public ::testing::Test {
100protected:
Mathias Agopian7c1a4872013-03-20 15:56:04 -0700101 SurfaceTest() {
102 ProcessState::self()->startThreadPool();
103 }
104
Jamie Gennis134f0422011-03-08 12:18:54 -0800105 virtual void SetUp() {
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800106 mComposerClient = new SurfaceComposerClient;
Jamie Gennis134f0422011-03-08 12:18:54 -0800107 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
108
Brian Andersond0010582017-03-07 13:20:31 -0800109 // TODO(brianderson): The following sometimes fails and is a source of
110 // test flakiness.
Jamie Gennisfc850122011-04-25 16:40:05 -0700111 mSurfaceControl = mComposerClient->createSurface(
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700112 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
arthurhungdba591c2021-02-08 17:28:49 +0800113 SurfaceComposerClient::Transaction().apply(true);
Jamie Gennis134f0422011-03-08 12:18:54 -0800114
Yi Konga03e0442018-07-17 11:16:57 -0700115 ASSERT_TRUE(mSurfaceControl != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800116 ASSERT_TRUE(mSurfaceControl->isValid());
117
Robert Carr4cdc58f2017-08-23 14:22:20 -0700118 Transaction t;
arthurhungdba591c2021-02-08 17:28:49 +0800119 ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff).show(mSurfaceControl).apply());
Jamie Gennis134f0422011-03-08 12:18:54 -0800120
121 mSurface = mSurfaceControl->getSurface();
Yi Konga03e0442018-07-17 11:16:57 -0700122 ASSERT_TRUE(mSurface != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800123 }
124
125 virtual void TearDown() {
126 mComposerClient->dispose();
127 }
128
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700129 void testSurfaceListener(bool hasSurfaceListener, bool enableReleasedCb,
130 int32_t extraDiscardedBuffers) {
131 sp<IGraphicBufferProducer> producer;
132 sp<IGraphicBufferConsumer> consumer;
133 BufferQueue::createBufferQueue(&producer, &consumer);
134
Peiyong Lind8460c82020-07-28 16:04:22 -0700135 sp<MockConsumer> mockConsumer(new MockConsumer);
136 consumer->consumerConnect(mockConsumer, false);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700137 consumer->setConsumerName(String8("TestConsumer"));
138
139 sp<Surface> surface = new Surface(producer);
140 sp<ANativeWindow> window(surface);
Peiyong Lind8460c82020-07-28 16:04:22 -0700141 sp<FakeSurfaceListener> listener;
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700142 if (hasSurfaceListener) {
Peiyong Lind8460c82020-07-28 16:04:22 -0700143 listener = new FakeSurfaceListener(enableReleasedCb);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700144 }
145 ASSERT_EQ(OK, surface->connect(
146 NATIVE_WINDOW_API_CPU,
147 /*reportBufferRemoval*/true,
148 /*listener*/listener));
149 const int BUFFER_COUNT = 4 + extraDiscardedBuffers;
150 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
151
152 ANativeWindowBuffer* buffers[BUFFER_COUNT];
153 // Dequeue first to allocate a number of buffers
154 for (int i = 0; i < BUFFER_COUNT; i++) {
155 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffers[i]));
156 }
157 for (int i = 0; i < BUFFER_COUNT; i++) {
158 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], -1));
159 }
160
161 ANativeWindowBuffer* buffer;
162 // Fill BUFFER_COUNT-1 buffers
163 for (int i = 0; i < BUFFER_COUNT-1; i++) {
164 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
165 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, -1));
166 }
167
168 // Dequeue 1 buffer
169 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
170
171 // Acquire and free 1+extraDiscardedBuffers buffer, check onBufferReleased is called.
172 std::vector<BufferItem> releasedItems;
173 releasedItems.resize(1+extraDiscardedBuffers);
174 for (int i = 0; i < releasedItems.size(); i++) {
175 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&releasedItems[i], 0));
176 ASSERT_EQ(NO_ERROR, consumer->releaseBuffer(releasedItems[i].mSlot,
177 releasedItems[i].mFrameNumber, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
178 Fence::NO_FENCE));
179 }
180 int32_t expectedReleaseCb = (enableReleasedCb ? releasedItems.size() : 0);
181 if (hasSurfaceListener) {
182 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
183 }
184
185 // Acquire 1 buffer, leaving 1+extraDiscardedBuffers filled buffer in queue
186 BufferItem item;
187 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&item, 0));
188
189 // Discard free buffers
190 ASSERT_EQ(NO_ERROR, consumer->discardFreeBuffers());
191
192 if (hasSurfaceListener) {
193 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
194
195 // Check onBufferDiscarded is called with correct buffer
196 auto discardedBuffers = listener->getDiscardedBuffers();
197 ASSERT_EQ(discardedBuffers.size(), releasedItems.size());
198 for (int i = 0; i < releasedItems.size(); i++) {
199 ASSERT_EQ(discardedBuffers[i], releasedItems[i].mGraphicBuffer);
200 }
201
202 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
203 }
204
205 // Disconnect the surface
206 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
207 }
208
chaviw8ffc7b82020-08-18 11:25:37 -0700209 static status_t captureDisplay(DisplayCaptureArgs& captureArgs,
210 ScreenCaptureResults& captureResults) {
Huihong Luof5029222021-12-16 14:33:46 -0800211 const auto sf = ComposerServiceAIDL::getComposerService();
chaviw8ffc7b82020-08-18 11:25:37 -0700212 SurfaceComposerClient::Transaction().apply(true);
213
214 const sp<SyncScreenCaptureListener> captureListener = new SyncScreenCaptureListener();
Huihong Luof5029222021-12-16 14:33:46 -0800215 binder::Status status = sf->captureDisplay(captureArgs, captureListener);
Huihong Luo3bdef862022-03-03 11:57:19 -0800216 status_t err = gui::aidl_utils::statusTFromBinderStatus(status);
217 if (err != NO_ERROR) {
218 return err;
chaviw8ffc7b82020-08-18 11:25:37 -0700219 }
220 captureResults = captureListener->waitForResults();
Patrick Williamsfdb57bb2022-08-09 22:48:18 +0000221 return fenceStatus(captureResults.fenceResult);
chaviw8ffc7b82020-08-18 11:25:37 -0700222 }
223
Jamie Gennis134f0422011-03-08 12:18:54 -0800224 sp<Surface> mSurface;
225 sp<SurfaceComposerClient> mComposerClient;
226 sp<SurfaceControl> mSurfaceControl;
227};
228
Robert Carr740eaf02018-03-27 12:59:18 -0700229TEST_F(SurfaceTest, CreateSurfaceReturnsErrorBadClient) {
230 mComposerClient->dispose();
231 ASSERT_EQ(NO_INIT, mComposerClient->initCheck());
232
233 sp<SurfaceControl> sc;
234 status_t err = mComposerClient->createSurfaceChecked(
235 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, &sc, 0);
236 ASSERT_EQ(NO_INIT, err);
237}
238
Jamie Gennis134f0422011-03-08 12:18:54 -0800239TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
240 sp<ANativeWindow> anw(mSurface);
241 int result = -123;
242 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
243 &result);
244 EXPECT_EQ(NO_ERROR, err);
245 EXPECT_EQ(1, result);
246}
247
248TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
249 mSurfaceControl.clear();
Kalle Raita643f0942016-12-07 09:20:14 -0800250 // Wait for the async clean-up to complete.
251 std::this_thread::sleep_for(50ms);
Jamie Gennis134f0422011-03-08 12:18:54 -0800252
253 sp<ANativeWindow> anw(mSurface);
254 int result = -123;
255 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
256 &result);
257 EXPECT_EQ(NO_ERROR, err);
258 EXPECT_EQ(1, result);
259}
260
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800261// This test probably doesn't belong here.
Robert Carr108b2c72019-04-02 16:32:58 -0700262TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersDontSucceed) {
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800263 sp<ANativeWindow> anw(mSurface);
264
265 // Verify the screenshot works with no protected buffers.
Huihong Luo31b5ac22022-08-15 20:38:10 -0700266 const auto ids = SurfaceComposerClient::getPhysicalDisplayIds();
267 ASSERT_FALSE(ids.empty());
268 // display 0 is picked for now, can extend to support all displays if needed
269 const sp<IBinder> display = SurfaceComposerClient::getPhysicalDisplayToken(ids.front());
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800270 ASSERT_FALSE(display == nullptr);
271
chaviwd2432892020-07-24 17:42:39 -0700272 DisplayCaptureArgs captureArgs;
273 captureArgs.displayToken = display;
274 captureArgs.width = 64;
275 captureArgs.height = 64;
276
277 ScreenCaptureResults captureResults;
chaviw8ffc7b82020-08-18 11:25:37 -0700278 ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800279
Pablo Ceballos583b1b32015-09-03 18:23:52 -0700280 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
281 NATIVE_WINDOW_API_CPU));
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800282 // Set the PROTECTED usage bit and verify that the screenshot fails. Note
283 // that we need to dequeue a buffer in order for it to actually get
284 // allocated in SurfaceFlinger.
285 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
286 GRALLOC_USAGE_PROTECTED));
287 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
Yi Konga03e0442018-07-17 11:16:57 -0700288 ANativeWindowBuffer* buf = nullptr;
Mathias Agopian9303eee2011-07-01 15:27:27 -0700289
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700290 status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
Mathias Agopian9303eee2011-07-01 15:27:27 -0700291 if (err) {
292 // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
293 // that's okay as long as this is the reason for the failure.
294 // try again without the GRALLOC_USAGE_PROTECTED bit.
295 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700296 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
297 &buf));
Mathias Agopian9303eee2011-07-01 15:27:27 -0700298 return;
299 }
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700300 ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
Mathias Agopian9303eee2011-07-01 15:27:27 -0700301
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800302 for (int i = 0; i < 4; i++) {
303 // Loop to make sure SurfaceFlinger has retired a protected buffer.
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700304 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
305 &buf));
306 ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800307 }
chaviw8ffc7b82020-08-18 11:25:37 -0700308 ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800309}
310
Jamie Gennis391bbe22011-03-14 15:00:06 -0700311TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
312 sp<ANativeWindow> anw(mSurface);
313 int result = -123;
314 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
315 EXPECT_EQ(NO_ERROR, err);
316 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
317}
318
Craig Donner6ebc46a2016-10-21 15:23:44 -0700319TEST_F(SurfaceTest, LayerCountIsOne) {
320 sp<ANativeWindow> anw(mSurface);
321 int result = -123;
322 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
323 EXPECT_EQ(NO_ERROR, err);
324 EXPECT_EQ(1, result);
325}
326
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700327TEST_F(SurfaceTest, QueryConsumerUsage) {
328 const int TEST_USAGE_FLAGS =
329 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
Dan Stoza5603a2f2014-04-07 13:41:37 -0700330 sp<IGraphicBufferProducer> producer;
331 sp<IGraphicBufferConsumer> consumer;
332 BufferQueue::createBufferQueue(&producer, &consumer);
333 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700334 TEST_USAGE_FLAGS);
Dan Stoza5603a2f2014-04-07 13:41:37 -0700335 sp<Surface> s = new Surface(producer);
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700336
337 sp<ANativeWindow> anw(s);
338
339 int flags = -1;
340 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
341
342 ASSERT_EQ(NO_ERROR, err);
343 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
344}
345
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800346TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
Peiyong Lin14724e62018-12-05 07:27:30 -0800347 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_V0_SRGB;
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800348 sp<IGraphicBufferProducer> producer;
349 sp<IGraphicBufferConsumer> consumer;
350 BufferQueue::createBufferQueue(&producer, &consumer);
351 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
352
353 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
354
355 sp<Surface> s = new Surface(producer);
356
357 sp<ANativeWindow> anw(s);
358
359 android_dataspace dataSpace;
360
361 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
362 reinterpret_cast<int*>(&dataSpace));
363
364 ASSERT_EQ(NO_ERROR, err);
365 ASSERT_EQ(TEST_DATASPACE, dataSpace);
366}
367
Dan Stoza812ed062015-06-02 15:45:22 -0700368TEST_F(SurfaceTest, SettingGenerationNumber) {
369 sp<IGraphicBufferProducer> producer;
370 sp<IGraphicBufferConsumer> consumer;
371 BufferQueue::createBufferQueue(&producer, &consumer);
372 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
373 sp<Surface> surface = new Surface(producer);
374 sp<ANativeWindow> window(surface);
375
376 // Allocate a buffer with a generation number of 0
377 ANativeWindowBuffer* buffer;
378 int fenceFd;
Pablo Ceballos583b1b32015-09-03 18:23:52 -0700379 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
380 NATIVE_WINDOW_API_CPU));
Dan Stoza812ed062015-06-02 15:45:22 -0700381 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
382 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
383
384 // Detach the buffer and check its generation number
385 sp<GraphicBuffer> graphicBuffer;
386 sp<Fence> fence;
387 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
388 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
389
390 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
391 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
392
393 // This should change the generation number of the GraphicBuffer
394 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
395
396 // Check that the new generation number sticks with the buffer
397 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
398 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
399 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
400 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
401}
402
Dan Stozac6f30bd2015-06-08 09:32:50 -0700403TEST_F(SurfaceTest, GetConsumerName) {
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);
Dan Stozac6f30bd2015-06-08 09:32:50 -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 EXPECT_STREQ("TestConsumer", surface->getConsumerName().string());
417}
418
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700419TEST_F(SurfaceTest, GetWideColorSupport) {
420 sp<IGraphicBufferProducer> producer;
421 sp<IGraphicBufferConsumer> consumer;
422 BufferQueue::createBufferQueue(&producer, &consumer);
423
Peiyong Lind8460c82020-07-28 16:04:22 -0700424 sp<MockConsumer> mockConsumer(new MockConsumer);
425 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700426 consumer->setConsumerName(String8("TestConsumer"));
427
428 sp<Surface> surface = new Surface(producer);
429 sp<ANativeWindow> window(surface);
430 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
431
432 bool supported;
433 surface->getWideColorSupport(&supported);
434
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -0600435 // NOTE: This test assumes that device that supports
436 // wide-color (as indicated by BoardConfig) must also
437 // have a wide-color primary display.
438 // That assumption allows this test to cover devices
439 // that advertised a wide-color color mode without
440 // actually supporting wide-color to pass this test
441 // as well as the case of a device that does support
442 // wide-color (via BoardConfig) and has a wide-color
443 // primary display.
444 // NOT covered at this time is a device that supports
445 // wide color in the BoardConfig but does not support
446 // a wide-color color mode on the primary display.
447 ASSERT_EQ(hasWideColorDisplay, supported);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700448}
449
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700450TEST_F(SurfaceTest, GetHdrSupport) {
451 sp<IGraphicBufferProducer> producer;
452 sp<IGraphicBufferConsumer> consumer;
453 BufferQueue::createBufferQueue(&producer, &consumer);
454
Peiyong Lind8460c82020-07-28 16:04:22 -0700455 sp<MockConsumer> mockConsumer(new MockConsumer);
456 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700457 consumer->setConsumerName(String8("TestConsumer"));
458
459 sp<Surface> surface = new Surface(producer);
460 sp<ANativeWindow> window(surface);
461 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
462
463 bool supported;
464 status_t result = surface->getHdrSupport(&supported);
465 ASSERT_EQ(NO_ERROR, result);
466
467 // NOTE: This is not a CTS test.
468 // This test verifies that when the BoardConfig TARGET_HAS_HDR_DISPLAY
469 // is TRUE, getHdrSupport is also true.
470 // TODO: Add check for an HDR color mode on the primary display.
471 ASSERT_EQ(hasHdrDisplay, supported);
472}
473
474TEST_F(SurfaceTest, SetHdrMetadata) {
475 sp<IGraphicBufferProducer> producer;
476 sp<IGraphicBufferConsumer> consumer;
477 BufferQueue::createBufferQueue(&producer, &consumer);
478
Peiyong Lind8460c82020-07-28 16:04:22 -0700479 sp<MockConsumer> mockConsumer(new MockConsumer);
480 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700481 consumer->setConsumerName(String8("TestConsumer"));
482
483 sp<Surface> surface = new Surface(producer);
484 sp<ANativeWindow> window(surface);
485 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
486
487 bool supported;
488 status_t result = surface->getHdrSupport(&supported);
489 ASSERT_EQ(NO_ERROR, result);
490
491 if (!hasHdrDisplay || !supported) {
492 return;
493 }
494 const android_smpte2086_metadata smpte2086 = {
495 {0.680, 0.320},
496 {0.265, 0.690},
497 {0.150, 0.060},
498 {0.3127, 0.3290},
499 100.0,
500 0.1,
501 };
502 const android_cta861_3_metadata cta861_3 = {
503 78.0,
504 62.0,
505 };
Valerie Haua82679d2018-11-21 09:31:43 -0800506
507 std::vector<uint8_t> hdr10plus;
508 hdr10plus.push_back(0xff);
509
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700510 int error = native_window_set_buffers_smpte2086_metadata(window.get(), &smpte2086);
511 ASSERT_EQ(error, NO_ERROR);
512 error = native_window_set_buffers_cta861_3_metadata(window.get(), &cta861_3);
513 ASSERT_EQ(error, NO_ERROR);
Valerie Haua82679d2018-11-21 09:31:43 -0800514 error = native_window_set_buffers_hdr10_plus_metadata(window.get(), hdr10plus.size(),
515 hdr10plus.data());
516 ASSERT_EQ(error, NO_ERROR);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700517}
518
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800519TEST_F(SurfaceTest, DynamicSetBufferCount) {
520 sp<IGraphicBufferProducer> producer;
521 sp<IGraphicBufferConsumer> consumer;
522 BufferQueue::createBufferQueue(&producer, &consumer);
523
Peiyong Lind8460c82020-07-28 16:04:22 -0700524 sp<MockConsumer> mockConsumer(new MockConsumer);
525 consumer->consumerConnect(mockConsumer, false);
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800526 consumer->setConsumerName(String8("TestConsumer"));
527
528 sp<Surface> surface = new Surface(producer);
529 sp<ANativeWindow> window(surface);
530
531 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
532 NATIVE_WINDOW_API_CPU));
533 native_window_set_buffer_count(window.get(), 4);
534
535 int fence;
536 ANativeWindowBuffer* buffer;
537 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
538 native_window_set_buffer_count(window.get(), 3);
539 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
540 native_window_set_buffer_count(window.get(), 2);
541 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
542 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
543}
544
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700545TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
546 sp<IGraphicBufferProducer> producer;
547 sp<IGraphicBufferConsumer> consumer;
548 BufferQueue::createBufferQueue(&producer, &consumer);
549
Peiyong Lind8460c82020-07-28 16:04:22 -0700550 sp<MockConsumer> mockConsumer(new MockConsumer);
551 consumer->consumerConnect(mockConsumer, false);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700552 consumer->setConsumerName(String8("TestConsumer"));
553
554 sp<Surface> surface = new Surface(producer);
555 sp<ANativeWindow> window(surface);
Peiyong Lind8460c82020-07-28 16:04:22 -0700556 sp<StubProducerListener> listener = new StubProducerListener();
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700557 ASSERT_EQ(OK, surface->connect(
558 NATIVE_WINDOW_API_CPU,
559 /*listener*/listener,
560 /*reportBufferRemoval*/true));
561 const int BUFFER_COUNT = 4;
562 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
563
564 sp<GraphicBuffer> detachedBuffer;
565 sp<Fence> outFence;
566 int fences[BUFFER_COUNT];
567 ANativeWindowBuffer* buffers[BUFFER_COUNT];
568 // Allocate buffers because detachNextBuffer requires allocated buffers
569 for (int i = 0; i < BUFFER_COUNT; i++) {
570 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
571 }
572 for (int i = 0; i < BUFFER_COUNT; i++) {
573 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
574 }
575
576 // Test detached buffer is correctly reported
577 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
578 std::vector<sp<GraphicBuffer>> removedBuffers;
579 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
580 ASSERT_EQ(1u, removedBuffers.size());
581 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
582 // Test the list is flushed one getAndFlushRemovedBuffers returns
583 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
584 ASSERT_EQ(0u, removedBuffers.size());
585
586
587 // Test removed buffer list is cleanup after next dequeueBuffer call
588 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
589 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
590 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
591 ASSERT_EQ(0u, removedBuffers.size());
592 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
593
594 // Test removed buffer list is cleanup after next detachNextBuffer call
595 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
596 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
597 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
598 ASSERT_EQ(1u, removedBuffers.size());
599 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
600
601 // Re-allocate buffers since all buffers are detached up to now
602 for (int i = 0; i < BUFFER_COUNT; i++) {
603 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
604 }
605 for (int i = 0; i < BUFFER_COUNT; i++) {
606 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
607 }
608
609 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
610 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
611 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
612 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
613 // get 0 or 1 buffer removed.
614 ASSERT_LE(removedBuffers.size(), 1u);
615}
Brian Anderson3da8d272016-07-28 16:20:47 -0700616
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700617TEST_F(SurfaceTest, SurfaceListenerTest) {
618 // Test discarding 1 free buffers with no listener
619 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/0);
620 // Test discarding 2 free buffers with no listener
621 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/1);
622 // Test discarding 1 free buffers with a listener, disabling onBufferReleased
623 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/0);
624 // Test discarding 2 free buffers with a listener, disabling onBufferReleased
625 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/1);
626 // Test discarding 1 free buffers with a listener, enabling onBufferReleased
627 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/0);
628 // Test discarding 3 free buffers with a listener, enabling onBufferReleased
629 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/2);
630}
631
Dan Stoza932f0082017-05-31 13:50:16 -0700632TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
633 sp<ANativeWindow> anw(mSurface);
634 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
635
636 ANativeWindowBuffer* buffer = nullptr;
637 int32_t fenceFd = -1;
638
639 nsecs_t before = systemTime(CLOCK_MONOTONIC);
640 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
641 nsecs_t after = systemTime(CLOCK_MONOTONIC);
642
Alec Mouria1619662019-08-21 19:30:48 -0700643 nsecs_t lastDequeueTime = ANativeWindow_getLastDequeueStartTime(anw.get());
Dan Stoza932f0082017-05-31 13:50:16 -0700644 ASSERT_LE(before, lastDequeueTime);
645 ASSERT_GE(after, lastDequeueTime);
646}
647
Brian Anderson3da8d272016-07-28 16:20:47 -0700648class FakeConsumer : public BnConsumerListener {
649public:
650 void onFrameAvailable(const BufferItem& /*item*/) override {}
651 void onBuffersReleased() override {}
652 void onSidebandStreamChanged() override {}
653
654 void addAndGetFrameTimestamps(
655 const NewFrameEventsEntry* newTimestamps,
656 FrameEventHistoryDelta* outDelta) override {
657 if (newTimestamps) {
658 if (mGetFrameTimestampsEnabled) {
659 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
660 "Test should set mNewFrameEntryOverride before queuing "
661 "a frame.";
662 EXPECT_EQ(newTimestamps->frameNumber,
663 mNewFrameEntryOverride.frameNumber) <<
664 "Test attempting to add NewFrameEntryOverride with "
665 "incorrect frame number.";
666 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
667 mNewFrameEntryOverride.frameNumber = 0;
668 }
669 mAddFrameTimestampsCount++;
670 mLastAddedFrameNumber = newTimestamps->frameNumber;
671 }
672 if (outDelta) {
673 mFrameEventHistory.getAndResetDelta(outDelta);
674 mGetFrameTimestampsCount++;
675 }
676 mAddAndGetFrameTimestampsCallCount++;
677 }
678
679 bool mGetFrameTimestampsEnabled = false;
680
681 ConsumerFrameEventHistory mFrameEventHistory;
682 int mAddAndGetFrameTimestampsCallCount = 0;
683 int mAddFrameTimestampsCount = 0;
684 int mGetFrameTimestampsCount = 0;
685 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
686
687 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
688};
689
Pablo Gamito6ee484d2020-07-30 14:26:28 +0000690class FakeSurfaceComposer : public ISurfaceComposer {
Brian Anderson3da8d272016-07-28 16:20:47 -0700691public:
692 ~FakeSurfaceComposer() override {}
693
Brian Anderson6b376712017-04-04 10:51:39 -0700694 void setSupportsPresent(bool supportsPresent) {
695 mSupportsPresent = supportsPresent;
696 }
697
Pablo Gamito23780be2023-04-18 08:30:00 +0000698 status_t setTransactionState(
699 const FrameTimelineInfo& /*frameTimelineInfo*/, Vector<ComposerState>& /*state*/,
700 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
701 const sp<IBinder>& /*applyToken*/, InputWindowCommands /*inputWindowCommands*/,
702 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
703 const std::vector<client_cache_t>& /*cachedBuffer*/, bool /*hasListenerCallbacks*/,
704 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/, uint64_t /*transactionId*/,
705 const std::vector<uint64_t>& /*mergedTransactionIds*/) override {
chaviw308ddba2020-08-11 16:23:51 -0700706 return NO_ERROR;
Marissa Wall3dad52d2019-03-22 14:03:19 -0700707 }
Marissa Wall17b4e452018-12-26 16:32:34 -0800708
Brian Anderson3da8d272016-07-28 16:20:47 -0700709protected:
710 IBinder* onAsBinder() override { return nullptr; }
711
712private:
713 bool mSupportsPresent{true};
Brian Anderson3da8d272016-07-28 16:20:47 -0700714};
715
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800716class FakeSurfaceComposerAIDL : public gui::ISurfaceComposer {
717public:
718 ~FakeSurfaceComposerAIDL() override {}
719
720 void setSupportsPresent(bool supportsPresent) { mSupportsPresent = supportsPresent; }
721
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700722 binder::Status bootFinished() override { return binder::Status::ok(); }
723
724 binder::Status createDisplayEventConnection(
725 VsyncSource /*vsyncSource*/, EventRegistration /*eventRegistration*/,
Rachel Lee2248f522023-01-27 16:45:23 -0800726 const sp<IBinder>& /*layerHandle*/,
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700727 sp<gui::IDisplayEventConnection>* outConnection) override {
728 *outConnection = nullptr;
729 return binder::Status::ok();
730 }
731
Huihong Luod3d8f8e2022-03-08 14:48:46 -0800732 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override {
733 *outClient = nullptr;
734 return binder::Status::ok();
735 }
736
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800737 binder::Status createDisplay(const std::string& /*displayName*/, bool /*secure*/,
Huihong Luo1768cb02022-10-11 11:10:34 -0700738 float /*requestedRefreshRate*/,
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800739 sp<IBinder>* /*outDisplay*/) override {
740 return binder::Status::ok();
741 }
742
743 binder::Status destroyDisplay(const sp<IBinder>& /*display*/) override {
744 return binder::Status::ok();
745 }
746
747 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* /*outDisplayIds*/) override {
748 return binder::Status::ok();
749 }
750
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800751 binder::Status getPhysicalDisplayToken(int64_t /*displayId*/,
752 sp<IBinder>* /*outDisplay*/) override {
753 return binder::Status::ok();
754 }
755
756 binder::Status setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {
757 return binder::Status::ok();
758 }
759
Huihong Luo0a81aa32022-02-22 16:02:36 -0800760 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override {
761 *outSupported = {FrameEvent::REQUESTED_PRESENT,
762 FrameEvent::ACQUIRE,
763 FrameEvent::LATCH,
764 FrameEvent::FIRST_REFRESH_START,
765 FrameEvent::LAST_REFRESH_START,
766 FrameEvent::GPU_COMPOSITION_DONE,
767 FrameEvent::DEQUEUE_READY,
768 FrameEvent::RELEASE};
769 if (mSupportsPresent) {
770 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
771 }
772 return binder::Status::ok();
773 }
774
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800775 binder::Status getDisplayStats(const sp<IBinder>& /*display*/,
776 gui::DisplayStatInfo* /*outStatInfo*/) override {
777 return binder::Status::ok();
778 }
779
780 binder::Status getDisplayState(const sp<IBinder>& /*display*/,
781 gui::DisplayState* /*outState*/) override {
782 return binder::Status::ok();
783 }
784
Sally Qi6bb12822022-10-05 11:42:30 -0700785 binder::Status getStaticDisplayInfo(int64_t /*displayId*/,
Huihong Luoa79ddf42022-02-17 00:01:38 -0800786 gui::StaticDisplayInfo* /*outInfo*/) override {
787 return binder::Status::ok();
788 }
789
Sally Qi6bb12822022-10-05 11:42:30 -0700790 binder::Status getDynamicDisplayInfoFromId(int64_t /*displayId*/,
791 gui::DynamicDisplayInfo* /*outInfo*/) override {
792 return binder::Status::ok();
793 }
794
795 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& /*display*/,
796 gui::DynamicDisplayInfo* /*outInfo*/) override {
Huihong Luo38603fd2022-02-21 14:32:54 -0800797 return binder::Status::ok();
798 }
799
Huihong Luoca3d9a42022-02-22 11:07:34 -0800800 binder::Status getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
801 gui::DisplayPrimaries* /*outPrimaries*/) override {
802 return binder::Status::ok();
803 }
804
805 binder::Status setActiveColorMode(const sp<IBinder>& /*display*/, int /*colorMode*/) override {
806 return binder::Status::ok();
807 }
808
809 binder::Status setBootDisplayMode(const sp<IBinder>& /*display*/,
810 int /*displayModeId*/) override {
811 return binder::Status::ok();
812 }
813
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800814 binder::Status clearBootDisplayMode(const sp<IBinder>& /*display*/) override {
815 return binder::Status::ok();
816 }
817
818 binder::Status getBootDisplayModeSupport(bool* /*outMode*/) override {
819 return binder::Status::ok();
820 }
821
Kriti Dang674b9372022-11-18 10:58:44 +0100822 binder::Status getHdrConversionCapabilities(
823 std::vector<gui::HdrConversionCapability>*) override {
824 return binder::Status::ok();
825 }
826
827 binder::Status setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +0100828 const gui::HdrConversionStrategy& /*hdrConversionStrategy*/,
829 int32_t* /*outPreferredHdrOutputType*/) override {
Kriti Dang674b9372022-11-18 10:58:44 +0100830 return binder::Status::ok();
831 }
832
833 binder::Status getHdrOutputConversionSupport(bool* /*outSupport*/) override {
834 return binder::Status::ok();
835 }
836
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800837 binder::Status setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {
838 return binder::Status::ok();
839 }
840
841 binder::Status setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {
842 return binder::Status::ok();
843 }
844
845 binder::Status captureDisplay(const DisplayCaptureArgs&,
846 const sp<IScreenCaptureListener>&) override {
847 return binder::Status::ok();
848 }
849
850 binder::Status captureDisplayById(int64_t, const sp<IScreenCaptureListener>&) override {
851 return binder::Status::ok();
852 }
853
854 binder::Status captureLayers(const LayerCaptureArgs&,
855 const sp<IScreenCaptureListener>&) override {
856 return binder::Status::ok();
857 }
858
Huihong Luo4ed1c912022-02-22 14:30:01 -0800859 binder::Status clearAnimationFrameStats() override { return binder::Status::ok(); }
860
861 binder::Status getAnimationFrameStats(gui::FrameStats* /*outStats*/) override {
862 return binder::Status::ok();
863 }
864
Huihong Luo05539a12022-02-23 10:29:40 -0800865 binder::Status overrideHdrTypes(const sp<IBinder>& /*display*/,
866 const std::vector<int32_t>& /*hdrTypes*/) override {
867 return binder::Status::ok();
868 }
869
870 binder::Status onPullAtom(int32_t /*atomId*/, gui::PullAtomData* /*outPullData*/) override {
871 return binder::Status::ok();
872 }
873
Huihong Luo05539a12022-02-23 10:29:40 -0800874 binder::Status getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* /*outLayers*/) override {
875 return binder::Status::ok();
876 }
877
878 binder::Status getColorManagement(bool* /*outGetColorManagement*/) override {
879 return binder::Status::ok();
880 }
881
882 binder::Status getCompositionPreference(gui::CompositionPreference* /*outPref*/) override {
883 return binder::Status::ok();
884 }
885
886 binder::Status getDisplayedContentSamplingAttributes(
887 const sp<IBinder>& /*display*/, gui::ContentSamplingAttributes* /*outAttrs*/) override {
888 return binder::Status::ok();
889 }
890
891 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
892 int8_t /*componentMask*/,
893 int64_t /*maxFrames*/) override {
894 return binder::Status::ok();
895 }
896
897 binder::Status getProtectedContentSupport(bool* /*outSupporte*/) override {
898 return binder::Status::ok();
899 }
900
Huihong Luo3bdef862022-03-03 11:57:19 -0800901 binder::Status getDisplayedContentSample(const sp<IBinder>& /*display*/, int64_t /*maxFrames*/,
902 int64_t /*timestamp*/,
903 gui::DisplayedFrameStats* /*outStats*/) override {
904 return binder::Status::ok();
905 }
906
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800907 binder::Status isWideColorDisplay(const sp<IBinder>& /*token*/,
908 bool* /*outIsWideColorDisplay*/) override {
909 return binder::Status::ok();
910 }
911
Huihong Luo02186fb2022-02-23 14:21:54 -0800912 binder::Status addRegionSamplingListener(
913 const gui::ARect& /*samplingArea*/, const sp<IBinder>& /*stopLayerHandle*/,
914 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
915 return binder::Status::ok();
916 }
917
918 binder::Status removeRegionSamplingListener(
919 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
920 return binder::Status::ok();
921 }
922
923 binder::Status addFpsListener(int32_t /*taskId*/,
924 const sp<gui::IFpsListener>& /*listener*/) override {
925 return binder::Status::ok();
926 }
927
928 binder::Status removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) override {
929 return binder::Status::ok();
930 }
931
932 binder::Status addTunnelModeEnabledListener(
933 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
934 return binder::Status::ok();
935 }
936
937 binder::Status removeTunnelModeEnabledListener(
938 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
939 return binder::Status::ok();
940 }
941
942 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700943 const gui::DisplayModeSpecs&) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800944 return binder::Status::ok();
945 }
946
947 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700948 gui::DisplayModeSpecs*) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800949 return binder::Status::ok();
950 }
951
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800952 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
953 bool* /*outSupport*/) override {
954 return binder::Status::ok();
955 }
956
957 binder::Status setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
958 const gui::DisplayBrightness& /*brightness*/) override {
959 return binder::Status::ok();
960 }
961
962 binder::Status addHdrLayerInfoListener(
963 const sp<IBinder>& /*displayToken*/,
964 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
965 return binder::Status::ok();
966 }
967
968 binder::Status removeHdrLayerInfoListener(
969 const sp<IBinder>& /*displayToken*/,
970 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
971 return binder::Status::ok();
972 }
973
974 binder::Status notifyPowerBoost(int /*boostId*/) override { return binder::Status::ok(); }
975
Huihong Luo3bdef862022-03-03 11:57:19 -0800976 binder::Status setGlobalShadowSettings(const gui::Color& /*ambientColor*/,
977 const gui::Color& /*spotColor*/, float /*lightPosY*/,
978 float /*lightPosZ*/, float /*lightRadius*/) override {
979 return binder::Status::ok();
980 }
981
982 binder::Status getDisplayDecorationSupport(
983 const sp<IBinder>& /*displayToken*/,
984 std::optional<gui::DisplayDecorationSupport>* /*outSupport*/) override {
985 return binder::Status::ok();
986 }
987
988 binder::Status setOverrideFrameRate(int32_t /*uid*/, float /*frameRate*/) override {
989 return binder::Status::ok();
990 }
991
Huihong Luo02186fb2022-02-23 14:21:54 -0800992 binder::Status getGpuContextPriority(int32_t* /*outPriority*/) override {
993 return binder::Status::ok();
994 }
995
996 binder::Status getMaxAcquiredBufferCount(int32_t* /*buffers*/) override {
997 return binder::Status::ok();
998 }
999
1000 binder::Status addWindowInfosListener(
1001 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
1002 return binder::Status::ok();
1003 }
1004
1005 binder::Status removeWindowInfosListener(
1006 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
1007 return binder::Status::ok();
1008 }
1009
Sally Qi0cbd08b2022-08-17 12:12:28 -07001010 binder::Status getOverlaySupport(gui::OverlayProperties* /*properties*/) override {
1011 return binder::Status::ok();
1012 }
1013
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001014protected:
1015 IBinder* onAsBinder() override { return nullptr; }
1016
1017private:
1018 bool mSupportsPresent{true};
1019};
1020
Brian Anderson3da8d272016-07-28 16:20:47 -07001021class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
1022public:
Chih-Hung Hsiehaaf62162018-12-20 15:45:04 -08001023 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001024
1025 ~FakeProducerFrameEventHistory() {}
1026
1027 void updateAcquireFence(uint64_t frameNumber,
1028 std::shared_ptr<FenceTime>&& acquire) override {
1029 // Verify the acquire fence being added isn't the one from the consumer.
1030 EXPECT_NE(mConsumerAcquireFence, acquire);
1031 // Override the fence, so we can verify this was called by the
1032 // producer after the frame is queued.
1033 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
1034 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
1035 }
1036
1037 void setAcquireFenceOverride(
1038 const std::shared_ptr<FenceTime>& acquireFenceOverride,
1039 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
1040 mAcquireFenceOverride = acquireFenceOverride;
1041 mConsumerAcquireFence = consumerAcquireFence;
1042 }
1043
1044protected:
1045 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
1046 const override {
1047 return mFenceMap->createFenceTimeForTest(fence);
1048 }
1049
1050 FenceToFenceTimeMap* mFenceMap{nullptr};
1051
1052 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
1053 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
1054};
1055
1056
1057class TestSurface : public Surface {
1058public:
Huihong Luo0a81aa32022-02-22 16:02:36 -08001059 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer, FenceToFenceTimeMap* fenceMap)
1060 : Surface(bufferProducer),
1061 mFakeSurfaceComposer(new FakeSurfaceComposer),
1062 mFakeSurfaceComposerAIDL(new FakeSurfaceComposerAIDL) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001063 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
1064 mFrameEventHistory.reset(mFakeFrameEventHistory);
1065 }
1066
1067 ~TestSurface() override {}
1068
1069 sp<ISurfaceComposer> composerService() const override {
1070 return mFakeSurfaceComposer;
1071 }
1072
Huihong Luo0a81aa32022-02-22 16:02:36 -08001073 sp<gui::ISurfaceComposer> composerServiceAIDL() const override {
1074 return mFakeSurfaceComposerAIDL;
1075 }
1076
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001077 nsecs_t now() const override {
1078 return mNow;
1079 }
1080
1081 void setNow(nsecs_t now) {
1082 mNow = now;
1083 }
1084
Brian Anderson3da8d272016-07-28 16:20:47 -07001085public:
1086 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001087 sp<FakeSurfaceComposerAIDL> mFakeSurfaceComposerAIDL;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001088 nsecs_t mNow = 0;
Brian Anderson3da8d272016-07-28 16:20:47 -07001089
1090 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
1091 // but this raw pointer gives access to test functionality.
1092 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
1093};
1094
1095
Brian Andersond0010582017-03-07 13:20:31 -08001096class GetFrameTimestampsTest : public ::testing::Test {
Brian Anderson3da8d272016-07-28 16:20:47 -07001097protected:
1098 struct FenceAndFenceTime {
1099 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001100 : mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
1101
1102 sp<Fence> mFence = sp<Fence>::make();
1103 std::shared_ptr<FenceTime> mFenceTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001104 };
1105
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001106 static CompositorTiming makeCompositorTiming(nsecs_t deadline = 1'000'000'000,
1107 nsecs_t interval = 16'666'667,
1108 nsecs_t presentLatency = 50'000'000) {
1109 CompositorTiming timing;
1110 timing.deadline = deadline;
1111 timing.interval = interval;
1112 timing.presentLatency = presentLatency;
1113 return timing;
1114 }
1115
Brian Anderson3da8d272016-07-28 16:20:47 -07001116 struct RefreshEvents {
1117 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001118 : mFenceMap(fenceMap),
1119 kCompositorTiming(
1120 makeCompositorTiming(refreshStart, refreshStart + 1, refreshStart + 2)),
1121 kStartTime(refreshStart + 3),
1122 kGpuCompositionDoneTime(refreshStart + 4),
1123 kPresentTime(refreshStart + 5) {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001124
1125 void signalPostCompositeFences() {
1126 mFenceMap.signalAllForTest(
1127 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1128 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1129 }
1130
1131 FenceToFenceTimeMap& mFenceMap;
1132
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001133 FenceAndFenceTime mGpuCompositionDone{mFenceMap};
1134 FenceAndFenceTime mPresent{mFenceMap};
Brian Anderson3da8d272016-07-28 16:20:47 -07001135
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001136 const CompositorTiming kCompositorTiming;
1137
Brian Anderson3da8d272016-07-28 16:20:47 -07001138 const nsecs_t kStartTime;
1139 const nsecs_t kGpuCompositionDoneTime;
1140 const nsecs_t kPresentTime;
1141 };
1142
1143 struct FrameEvents {
1144 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1145 : mFenceMap(fenceMap),
1146 kPostedTime(frameStartTime + 100),
1147 kRequestedPresentTime(frameStartTime + 200),
1148 kProducerAcquireTime(frameStartTime + 300),
1149 kConsumerAcquireTime(frameStartTime + 301),
1150 kLatchTime(frameStartTime + 500),
Brian Andersonf6386862016-10-31 16:34:13 -07001151 kDequeueReadyTime(frameStartTime + 600),
Brian Anderson4e606e32017-03-16 15:34:57 -07001152 kReleaseTime(frameStartTime + 700),
Brian Anderson3da8d272016-07-28 16:20:47 -07001153 mRefreshes {
1154 { mFenceMap, frameStartTime + 410 },
1155 { mFenceMap, frameStartTime + 420 },
1156 { mFenceMap, frameStartTime + 430 } } {}
1157
1158 void signalQueueFences() {
1159 mFenceMap.signalAllForTest(
1160 mAcquireConsumer.mFence, kConsumerAcquireTime);
1161 mFenceMap.signalAllForTest(
1162 mAcquireProducer.mFence, kProducerAcquireTime);
1163 }
1164
1165 void signalRefreshFences() {
1166 for (auto& re : mRefreshes) {
1167 re.signalPostCompositeFences();
1168 }
1169 }
1170
1171 void signalReleaseFences() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001172 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1173 }
1174
1175 FenceToFenceTimeMap& mFenceMap;
1176
1177 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1178 FenceAndFenceTime mAcquireProducer { mFenceMap };
Brian Anderson3da8d272016-07-28 16:20:47 -07001179 FenceAndFenceTime mRelease { mFenceMap };
1180
1181 const nsecs_t kPostedTime;
1182 const nsecs_t kRequestedPresentTime;
1183 const nsecs_t kProducerAcquireTime;
1184 const nsecs_t kConsumerAcquireTime;
1185 const nsecs_t kLatchTime;
Brian Andersonf6386862016-10-31 16:34:13 -07001186 const nsecs_t kDequeueReadyTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001187 const nsecs_t kReleaseTime;
1188
1189 RefreshEvents mRefreshes[3];
1190 };
1191
Brian Andersond0010582017-03-07 13:20:31 -08001192 GetFrameTimestampsTest() {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001193
1194 virtual void SetUp() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001195 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1196 mFakeConsumer = new FakeConsumer;
1197 mCfeh = &mFakeConsumer->mFrameEventHistory;
1198 mConsumer->consumerConnect(mFakeConsumer, false);
1199 mConsumer->setConsumerName(String8("TestConsumer"));
1200 mSurface = new TestSurface(mProducer, &mFenceMap);
1201 mWindow = mSurface;
1202
1203 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1204 NATIVE_WINDOW_API_CPU));
1205 native_window_set_buffer_count(mWindow.get(), 4);
1206 }
1207
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001208 void disableFrameTimestamps() {
1209 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1210 native_window_enable_frame_timestamps(mWindow.get(), 0);
1211 mFrameTimestampsEnabled = false;
1212 }
1213
Brian Anderson3da8d272016-07-28 16:20:47 -07001214 void enableFrameTimestamps() {
1215 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1216 native_window_enable_frame_timestamps(mWindow.get(), 1);
1217 mFrameTimestampsEnabled = true;
1218 }
1219
Brian Anderson1049d1d2016-12-16 17:25:57 -08001220 int getAllFrameTimestamps(uint64_t frameId) {
1221 return native_window_get_frame_timestamps(mWindow.get(), frameId,
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001222 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1223 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1224 &outGpuCompositionDoneTime, &outDisplayPresentTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001225 &outDequeueReadyTime, &outReleaseTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001226 }
1227
Brian Anderson3da8d272016-07-28 16:20:47 -07001228 void resetTimestamps() {
1229 outRequestedPresentTime = -1;
1230 outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001231 outLatchTime = -1;
1232 outFirstRefreshStartTime = -1;
1233 outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001234 outGpuCompositionDoneTime = -1;
1235 outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001236 outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001237 outReleaseTime = -1;
1238 }
1239
Brian Anderson1049d1d2016-12-16 17:25:57 -08001240 uint64_t getNextFrameId() {
1241 uint64_t frameId = -1;
1242 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1243 EXPECT_EQ(status, NO_ERROR);
1244 return frameId;
1245 }
1246
Brian Anderson3da8d272016-07-28 16:20:47 -07001247 void dequeueAndQueue(uint64_t frameIndex) {
1248 int fence = -1;
1249 ANativeWindowBuffer* buffer = nullptr;
1250 ASSERT_EQ(NO_ERROR,
1251 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1252
1253 int oldAddFrameTimestampsCount =
1254 mFakeConsumer->mAddFrameTimestampsCount;
1255
1256 FrameEvents* frame = &mFrames[frameIndex];
1257 uint64_t frameNumber = frameIndex + 1;
1258
1259 NewFrameEventsEntry fe;
1260 fe.frameNumber = frameNumber;
1261 fe.postedTime = frame->kPostedTime;
1262 fe.requestedPresentTime = frame->kRequestedPresentTime;
1263 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1264 mFakeConsumer->mNewFrameEntryOverride = fe;
1265
1266 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1267 frame->mAcquireProducer.mFenceTime,
1268 frame->mAcquireConsumer.mFenceTime);
1269
1270 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1271
1272 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1273
1274 EXPECT_EQ(
1275 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1276 mFakeConsumer->mAddFrameTimestampsCount);
1277 }
1278
1279 void addFrameEvents(
1280 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1281 FrameEvents* oldFrame =
1282 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1283 FrameEvents* newFrame = &mFrames[iNewFrame];
1284
Courtney Goeltzenleuchter5e921442018-01-19 13:43:43 -08001285 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001286 uint64_t nNewFrame = iNewFrame + 1;
1287
Brian Anderson4e606e32017-03-16 15:34:57 -07001288 // Latch, Composite, and Release the frames in a plausible order.
1289 // Note: The timestamps won't necessarily match the order, but
Brian Anderson3da8d272016-07-28 16:20:47 -07001290 // that's okay for the purposes of this test.
1291 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1292
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001293 // Composite the previous frame one more time, which helps verify
1294 // LastRefresh is updated properly.
1295 if (oldFrame != nullptr) {
1296 mCfeh->addPreComposition(nOldFrame,
1297 oldFrame->mRefreshes[2].kStartTime);
1298 gpuDoneFenceTime = gpuComposited ?
1299 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1300 FenceTime::NO_FENCE;
1301 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001302 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1303 oldFrame->mRefreshes[2].kCompositorTiming);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001304 }
1305
1306 // Latch the new frame.
Brian Anderson3da8d272016-07-28 16:20:47 -07001307 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1308
1309 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1310 gpuDoneFenceTime = gpuComposited ?
1311 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1312 FenceTime::NO_FENCE;
1313 // HWC2 releases the previous buffer after a new latch just before
1314 // calling postComposition.
1315 if (oldFrame != nullptr) {
Brian Andersonf6386862016-10-31 16:34:13 -07001316 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
Brian Anderson3da8d272016-07-28 16:20:47 -07001317 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1318 }
1319 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001320 newFrame->mRefreshes[0].mPresent.mFenceTime,
1321 newFrame->mRefreshes[0].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001322
Brian Anderson3da8d272016-07-28 16:20:47 -07001323 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1324 gpuDoneFenceTime = gpuComposited ?
1325 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1326 FenceTime::NO_FENCE;
1327 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001328 newFrame->mRefreshes[1].mPresent.mFenceTime,
1329 newFrame->mRefreshes[1].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001330 }
1331
Brian Anderson3da8d272016-07-28 16:20:47 -07001332 sp<IGraphicBufferProducer> mProducer;
1333 sp<IGraphicBufferConsumer> mConsumer;
1334 sp<FakeConsumer> mFakeConsumer;
1335 ConsumerFrameEventHistory* mCfeh;
1336 sp<TestSurface> mSurface;
1337 sp<ANativeWindow> mWindow;
1338
1339 FenceToFenceTimeMap mFenceMap;
1340
1341 bool mFrameTimestampsEnabled = false;
1342
1343 int64_t outRequestedPresentTime = -1;
1344 int64_t outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001345 int64_t outLatchTime = -1;
1346 int64_t outFirstRefreshStartTime = -1;
1347 int64_t outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001348 int64_t outGpuCompositionDoneTime = -1;
1349 int64_t outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001350 int64_t outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001351 int64_t outReleaseTime = -1;
1352
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001353 FrameEvents mFrames[3] {
1354 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
Brian Anderson3da8d272016-07-28 16:20:47 -07001355};
1356
1357
1358// This test verifies that the frame timestamps are not retrieved when not
1359// explicitly enabled via native_window_enable_frame_timestamps.
1360// We want to check this to make sure there's no overhead for users
1361// that don't need the timestamp information.
1362TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1363 int fence;
1364 ANativeWindowBuffer* buffer;
1365
1366 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1367 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1368
Brian Anderson1049d1d2016-12-16 17:25:57 -08001369 const uint64_t fId = getNextFrameId();
1370
Brian Anderson3da8d272016-07-28 16:20:47 -07001371 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1372 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1373 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1374 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1375
1376 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1377 // It is okay that frame timestamps are added in the consumer since it is
1378 // still needed for SurfaceFlinger dumps.
1379 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1380 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1381 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1382
1383 // Verify attempts to get frame timestamps fail.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001384 int result = getAllFrameTimestamps(fId);
Brian Anderson3da8d272016-07-28 16:20:47 -07001385 EXPECT_EQ(INVALID_OPERATION, result);
1386 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001387
1388 // Verify compositor timing query fails.
1389 nsecs_t compositeDeadline = 0;
1390 nsecs_t compositeInterval = 0;
1391 nsecs_t compositeToPresentLatency = 0;
1392 result = native_window_get_compositor_timing(mWindow.get(),
1393 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1394 EXPECT_EQ(INVALID_OPERATION, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001395}
1396
1397// This test verifies that the frame timestamps are retrieved if explicitly
1398// enabled via native_window_enable_frame_timestamps.
1399TEST_F(GetFrameTimestampsTest, EnabledSimple) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001400 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001401 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1402
Brian Anderson3da8d272016-07-28 16:20:47 -07001403 enableFrameTimestamps();
1404
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001405 // Verify the compositor timing query gets the initial compositor values
1406 // after timststamps are enabled; even before the first frame is queued
1407 // or dequeued.
1408 nsecs_t compositeDeadline = 0;
1409 nsecs_t compositeInterval = 0;
1410 nsecs_t compositeToPresentLatency = 0;
1411 mSurface->setNow(initialCompositorTiming.deadline - 1);
1412 int result = native_window_get_compositor_timing(mWindow.get(),
1413 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1414 EXPECT_EQ(NO_ERROR, result);
1415 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1416 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1417 EXPECT_EQ(initialCompositorTiming.presentLatency,
1418 compositeToPresentLatency);
1419
Brian Anderson3da8d272016-07-28 16:20:47 -07001420 int fence;
1421 ANativeWindowBuffer* buffer;
1422
1423 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001424 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001425
Brian Anderson1049d1d2016-12-16 17:25:57 -08001426 const uint64_t fId1 = getNextFrameId();
1427
Brian Anderson3da8d272016-07-28 16:20:47 -07001428 // Verify getFrameTimestamps is piggybacked on dequeue.
1429 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1430 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001431 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001432
1433 NewFrameEventsEntry f1;
1434 f1.frameNumber = 1;
1435 f1.postedTime = mFrames[0].kPostedTime;
1436 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1437 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1438 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1439 mFrames[0].mAcquireProducer.mFenceTime,
1440 mFrames[0].mAcquireConsumer.mFenceTime);
1441 mFakeConsumer->mNewFrameEntryOverride = f1;
1442 mFrames[0].signalQueueFences();
1443
1444 // Verify getFrameTimestamps is piggybacked on queue.
1445 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1446 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1447 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001448 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001449
1450 // Verify queries for timestamps that the producer doesn't know about
1451 // triggers a call to see if the consumer has any new timestamps.
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001452 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001453 EXPECT_EQ(NO_ERROR, result);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001454 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001455}
1456
Brian Anderson6b376712017-04-04 10:51:39 -07001457TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1458 bool displayPresentSupported = true;
1459 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001460 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001461
1462 // Verify supported bits are forwarded.
1463 int supportsPresent = -1;
1464 mWindow.get()->query(mWindow.get(),
1465 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1466 EXPECT_EQ(displayPresentSupported, supportsPresent);
1467}
1468
1469TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1470 bool displayPresentSupported = false;
1471 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001472 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001473
1474 // Verify supported bits are forwarded.
1475 int supportsPresent = -1;
1476 mWindow.get()->query(mWindow.get(),
1477 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1478 EXPECT_EQ(displayPresentSupported, supportsPresent);
1479}
1480
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001481TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1482 nsecs_t phase = 4000;
1483 nsecs_t interval = 1000;
1484
1485 // Timestamp in previous interval.
1486 nsecs_t timestamp = 3500;
1487 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1488 timestamp, phase, interval));
1489
1490 // Timestamp in next interval.
1491 timestamp = 4500;
1492 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1493 timestamp, phase, interval));
1494
1495 // Timestamp multiple intervals before.
1496 timestamp = 2500;
1497 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1498 timestamp, phase, interval));
1499
1500 // Timestamp multiple intervals after.
1501 timestamp = 6500;
1502 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1503 timestamp, phase, interval));
1504
1505 // Timestamp on previous interval.
1506 timestamp = 3000;
1507 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1508 timestamp, phase, interval));
1509
1510 // Timestamp on next interval.
1511 timestamp = 5000;
1512 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1513 timestamp, phase, interval));
1514
1515 // Timestamp equal to phase.
1516 timestamp = 4000;
1517 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1518 timestamp, phase, interval));
1519}
1520
1521// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1522// if the number of intervals elapsed is internally stored in an int.
1523TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1524 nsecs_t phase = 0;
1525 nsecs_t interval = 4000;
1526 nsecs_t big_timestamp = 8635916564000;
1527 int32_t intervals = big_timestamp / interval;
1528
1529 EXPECT_LT(intervals, 0);
1530 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1531 big_timestamp, phase, interval));
1532 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1533 big_timestamp, big_timestamp, interval));
1534}
1535
1536// This verifies the compositor timing is updated by refresh events
1537// and piggy backed on a queue, dequeue, and enabling of timestamps..
1538TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001539 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001540 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1541
1542 enableFrameTimestamps();
1543
1544 // We get the initial values before any frames are submitted.
1545 nsecs_t compositeDeadline = 0;
1546 nsecs_t compositeInterval = 0;
1547 nsecs_t compositeToPresentLatency = 0;
1548 mSurface->setNow(initialCompositorTiming.deadline - 1);
1549 int result = native_window_get_compositor_timing(mWindow.get(),
1550 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1551 EXPECT_EQ(NO_ERROR, result);
1552 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1553 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1554 EXPECT_EQ(initialCompositorTiming.presentLatency,
1555 compositeToPresentLatency);
1556
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001557 dequeueAndQueue(0);
1558 addFrameEvents(true, NO_FRAME_INDEX, 0);
1559
1560 // Still get the initial values because the frame events for frame 0
1561 // didn't get a chance to piggyback on a queue or dequeue yet.
1562 result = native_window_get_compositor_timing(mWindow.get(),
1563 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1564 EXPECT_EQ(NO_ERROR, result);
1565 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1566 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1567 EXPECT_EQ(initialCompositorTiming.presentLatency,
1568 compositeToPresentLatency);
1569
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001570 dequeueAndQueue(1);
1571 addFrameEvents(true, 0, 1);
1572
1573 // Now expect the composite values associated with frame 1.
1574 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1575 result = native_window_get_compositor_timing(mWindow.get(),
1576 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1577 EXPECT_EQ(NO_ERROR, result);
1578 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1579 compositeDeadline);
1580 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1581 compositeInterval);
1582 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1583 compositeToPresentLatency);
1584
1585 dequeueAndQueue(2);
1586 addFrameEvents(true, 1, 2);
1587
1588 // Now expect the composite values associated with frame 2.
1589 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1590 result = native_window_get_compositor_timing(mWindow.get(),
1591 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1592 EXPECT_EQ(NO_ERROR, result);
1593 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1594 compositeDeadline);
1595 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1596 compositeInterval);
1597 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1598 compositeToPresentLatency);
1599
1600 // Re-enabling frame timestamps should get the latest values.
1601 disableFrameTimestamps();
1602 enableFrameTimestamps();
1603
1604 // Now expect the composite values associated with frame 3.
1605 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1606 result = native_window_get_compositor_timing(mWindow.get(),
1607 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1608 EXPECT_EQ(NO_ERROR, result);
1609 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1610 compositeDeadline);
1611 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1612 compositeInterval);
1613 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1614 compositeToPresentLatency);
1615}
1616
1617// This verifies the compositor deadline properly snaps to the the next
1618// deadline based on the current time.
1619TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001620 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001621 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1622
1623 enableFrameTimestamps();
1624
1625 nsecs_t compositeDeadline = 0;
1626 nsecs_t compositeInterval = 0;
1627 nsecs_t compositeToPresentLatency = 0;
1628
1629 // A "now" just before the deadline snaps to the deadline.
1630 mSurface->setNow(initialCompositorTiming.deadline - 1);
1631 int result = native_window_get_compositor_timing(mWindow.get(),
1632 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1633 EXPECT_EQ(NO_ERROR, result);
1634 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1635 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1636 EXPECT_EQ(expectedDeadline, compositeDeadline);
1637
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001638 dequeueAndQueue(0);
1639 addFrameEvents(true, NO_FRAME_INDEX, 0);
1640
1641 // A "now" just after the deadline snaps properly.
1642 mSurface->setNow(initialCompositorTiming.deadline + 1);
1643 result = native_window_get_compositor_timing(mWindow.get(),
1644 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1645 EXPECT_EQ(NO_ERROR, result);
1646 expectedDeadline =
1647 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1648 EXPECT_EQ(expectedDeadline, compositeDeadline);
1649
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001650 dequeueAndQueue(1);
1651 addFrameEvents(true, 0, 1);
1652
1653 // A "now" just after the next interval snaps properly.
1654 mSurface->setNow(
1655 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1656 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1657 result = native_window_get_compositor_timing(mWindow.get(),
1658 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1659 EXPECT_EQ(NO_ERROR, result);
1660 expectedDeadline =
1661 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1662 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1663 EXPECT_EQ(expectedDeadline, compositeDeadline);
1664
1665 dequeueAndQueue(2);
1666 addFrameEvents(true, 1, 2);
1667
1668 // A "now" over 1 interval before the deadline snaps properly.
1669 mSurface->setNow(
1670 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1671 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1672 result = native_window_get_compositor_timing(mWindow.get(),
1673 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1674 EXPECT_EQ(NO_ERROR, result);
1675 expectedDeadline =
1676 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1677 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1678 EXPECT_EQ(expectedDeadline, compositeDeadline);
1679
1680 // Re-enabling frame timestamps should get the latest values.
1681 disableFrameTimestamps();
1682 enableFrameTimestamps();
1683
1684 // A "now" over 2 intervals before the deadline snaps properly.
1685 mSurface->setNow(
1686 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1687 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1688 result = native_window_get_compositor_timing(mWindow.get(),
1689 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1690 EXPECT_EQ(NO_ERROR, result);
1691 expectedDeadline =
1692 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1693 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1694 EXPECT_EQ(expectedDeadline, compositeDeadline);
1695}
1696
Brian Anderson1049d1d2016-12-16 17:25:57 -08001697// This verifies the timestamps recorded in the consumer's
1698// FrameTimestampsHistory are properly retrieved by the producer for the
1699// correct frames.
Brian Anderson3da8d272016-07-28 16:20:47 -07001700TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1701 enableFrameTimestamps();
1702
Brian Anderson1049d1d2016-12-16 17:25:57 -08001703 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001704 dequeueAndQueue(0);
1705 mFrames[0].signalQueueFences();
1706
Brian Anderson1049d1d2016-12-16 17:25:57 -08001707 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001708 dequeueAndQueue(1);
1709 mFrames[1].signalQueueFences();
1710
1711 addFrameEvents(true, NO_FRAME_INDEX, 0);
1712 mFrames[0].signalRefreshFences();
1713 addFrameEvents(true, 0, 1);
1714 mFrames[0].signalReleaseFences();
1715 mFrames[1].signalRefreshFences();
1716
1717 // Verify timestamps are correct for frame 1.
Brian Anderson3da8d272016-07-28 16:20:47 -07001718 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001719 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001720 EXPECT_EQ(NO_ERROR, result);
1721 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1722 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001723 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1724 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1725 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001726 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1727 outGpuCompositionDoneTime);
1728 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001729 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001730 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1731
1732 // Verify timestamps are correct for frame 2.
Brian Anderson3da8d272016-07-28 16:20:47 -07001733 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001734 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07001735 EXPECT_EQ(NO_ERROR, result);
1736 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1737 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001738 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1739 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1740 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001741 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1742 outGpuCompositionDoneTime);
1743 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001744 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1745 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001746}
1747
1748// This test verifies the acquire fence recorded by the consumer is not sent
1749// back to the producer and the producer saves its own fence.
1750TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1751 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001752
Brian Anderson3da8d272016-07-28 16:20:47 -07001753 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001754 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001755 dequeueAndQueue(0);
1756
1757 // Verify queue-related timestamps for f1 are available immediately in the
1758 // producer without asking the consumer again, even before signaling the
1759 // acquire fence.
1760 resetTimestamps();
1761 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001762 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001763 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001764 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001765 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1766 EXPECT_EQ(NO_ERROR, result);
1767 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001768 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001769
1770 // Signal acquire fences. Verify a sync call still isn't necessary.
1771 mFrames[0].signalQueueFences();
1772
1773 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001774 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001775 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001776 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001777 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1778 EXPECT_EQ(NO_ERROR, result);
1779 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1780 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1781
1782 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001783 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001784 dequeueAndQueue(1);
1785
1786 // Verify queue-related timestamps for f2 are available immediately in the
1787 // producer without asking the consumer again, even before signaling the
1788 // acquire fence.
1789 resetTimestamps();
1790 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001791 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001792 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001793 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001794 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1795 EXPECT_EQ(NO_ERROR, result);
1796 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001797 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001798
1799 // Signal acquire fences. Verify a sync call still isn't necessary.
1800 mFrames[1].signalQueueFences();
1801
1802 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001803 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001804 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001805 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001806 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1807 EXPECT_EQ(NO_ERROR, result);
1808 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1809 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1810}
1811
1812TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1813 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001814
1815 // Dequeue and queue frame 1.
1816 dequeueAndQueue(0);
1817 mFrames[0].signalQueueFences();
1818
1819 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001820 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001821 dequeueAndQueue(1);
1822 mFrames[1].signalQueueFences();
1823
1824 addFrameEvents(true, NO_FRAME_INDEX, 0);
1825 mFrames[0].signalRefreshFences();
1826 addFrameEvents(true, 0, 1);
1827 mFrames[0].signalReleaseFences();
1828 mFrames[1].signalRefreshFences();
1829
1830 // Verify a request for no timestamps doesn't result in a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001831 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001832 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson6b376712017-04-04 10:51:39 -07001833 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1834 nullptr, nullptr);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001835 EXPECT_EQ(NO_ERROR, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001836 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1837}
1838
1839// This test verifies that fences can signal and update timestamps producer
1840// side without an additional sync call to the consumer.
1841TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1842 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001843
1844 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001845 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001846 dequeueAndQueue(0);
1847 mFrames[0].signalQueueFences();
1848
1849 // Dequeue and queue frame 2.
1850 dequeueAndQueue(1);
1851 mFrames[1].signalQueueFences();
1852
1853 addFrameEvents(true, NO_FRAME_INDEX, 0);
1854 addFrameEvents(true, 0, 1);
1855
1856 // Verify available timestamps are correct for frame 1, before any
1857 // fence has been signaled.
1858 // Note: A sync call is necessary here since the events triggered by
1859 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07001860 resetTimestamps();
1861 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001862 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001863 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1864 EXPECT_EQ(NO_ERROR, result);
1865 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1866 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001867 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1868 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1869 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001870 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1871 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001872 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001873 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001874
1875 // Verify available timestamps are correct for frame 1 again, before any
1876 // fence has been signaled.
1877 // This time a sync call should not be necessary.
Brian Anderson3da8d272016-07-28 16:20:47 -07001878 resetTimestamps();
1879 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001880 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001881 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1882 EXPECT_EQ(NO_ERROR, result);
1883 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1884 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001885 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1886 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1887 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001888 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1889 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001890 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001891 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001892
1893 // Signal the fences for frame 1.
1894 mFrames[0].signalRefreshFences();
1895 mFrames[0].signalReleaseFences();
1896
1897 // Verify all timestamps are available without a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001898 resetTimestamps();
1899 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001900 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001901 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1902 EXPECT_EQ(NO_ERROR, result);
1903 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1904 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001905 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1906 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1907 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001908 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1909 outGpuCompositionDoneTime);
1910 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001911 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001912 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1913}
1914
1915// This test verifies that if the frame wasn't GPU composited but has a refresh
1916// event a sync call isn't made to get the GPU composite done time since it will
1917// never exist.
1918TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1919 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001920
Brian Anderson3da8d272016-07-28 16:20:47 -07001921 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001922 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001923 dequeueAndQueue(0);
1924 mFrames[0].signalQueueFences();
1925
1926 // Dequeue and queue frame 2.
1927 dequeueAndQueue(1);
1928 mFrames[1].signalQueueFences();
1929
1930 addFrameEvents(false, NO_FRAME_INDEX, 0);
1931 addFrameEvents(false, 0, 1);
1932
1933 // Verify available timestamps are correct for frame 1, before any
1934 // fence has been signaled.
1935 // Note: A sync call is necessary here since the events triggered by
1936 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1937 resetTimestamps();
1938 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001939 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001940 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1941 EXPECT_EQ(NO_ERROR, result);
1942 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1943 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001944 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1945 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1946 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001947 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1948 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001949 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001950 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001951
1952 // Signal the fences for frame 1.
1953 mFrames[0].signalRefreshFences();
1954 mFrames[0].signalReleaseFences();
1955
1956 // Verify all timestamps, except GPU composition, are available without a
1957 // sync call.
1958 resetTimestamps();
1959 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001960 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001961 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1962 EXPECT_EQ(NO_ERROR, result);
1963 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1964 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001965 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1966 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1967 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001968 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001969 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001970 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001971 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1972}
1973
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001974// This test verifies that if the certain timestamps can't possibly exist for
1975// the most recent frame, then a sync call is not done.
Brian Anderson6b376712017-04-04 10:51:39 -07001976TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001977 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001978
1979 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001980 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001981 dequeueAndQueue(0);
1982 mFrames[0].signalQueueFences();
1983
1984 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001985 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001986 dequeueAndQueue(1);
1987 mFrames[1].signalQueueFences();
1988
1989 addFrameEvents(false, NO_FRAME_INDEX, 0);
1990 addFrameEvents(false, 0, 1);
1991
1992 // Verify available timestamps are correct for frame 1, before any
1993 // fence has been signaled.
1994 // Note: A sync call is necessary here since the events triggered by
1995 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07001996 resetTimestamps();
1997 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001998 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001999 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
2000 EXPECT_EQ(NO_ERROR, result);
2001 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
2002 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002003 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
2004 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2005 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002006 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
2007 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002008 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002009 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002010
2011 mFrames[0].signalRefreshFences();
2012 mFrames[0].signalReleaseFences();
2013 mFrames[1].signalRefreshFences();
2014
Brian Anderson1049d1d2016-12-16 17:25:57 -08002015 // Verify querying for all timestmaps of f2 does not do a sync call. Even
Brian Anderson4e606e32017-03-16 15:34:57 -07002016 // though the lastRefresh, dequeueReady, and release times aren't
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002017 // available, a sync call should not occur because it's not possible for f2
2018 // to encounter the final value for those events until another frame is
2019 // queued.
Brian Anderson3da8d272016-07-28 16:20:47 -07002020 resetTimestamps();
2021 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08002022 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07002023 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2024 EXPECT_EQ(NO_ERROR, result);
2025 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
2026 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07002027 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
2028 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2029 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002030 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002031 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002032 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
2033 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002034}
2035
Brian Anderson6b376712017-04-04 10:51:39 -07002036// This test verifies there are no sync calls for present times
2037// when they aren't supported and that an error is returned.
2038
2039TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
2040 enableFrameTimestamps();
2041 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
Huihong Luo0a81aa32022-02-22 16:02:36 -08002042 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(false);
Brian Anderson6b376712017-04-04 10:51:39 -07002043
2044 // Dequeue and queue frame 1.
2045 const uint64_t fId1 = getNextFrameId();
2046 dequeueAndQueue(0);
2047
2048 // Verify a query for the Present times do not trigger a sync call if they
2049 // are not supported.
2050 resetTimestamps();
2051 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2052 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
2053 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
2054 &outDisplayPresentTime, nullptr, nullptr);
2055 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2056 EXPECT_EQ(BAD_VALUE, result);
2057 EXPECT_EQ(-1, outDisplayPresentTime);
2058}
2059
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002060TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
2061 sp<IGraphicBufferProducer> producer;
2062 sp<IGraphicBufferConsumer> consumer;
2063 BufferQueue::createBufferQueue(&producer, &consumer);
2064
Peiyong Lind8460c82020-07-28 16:04:22 -07002065 sp<MockConsumer> mockConsumer(new MockConsumer);
2066 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002067 consumer->setDefaultBufferSize(10, 10);
2068
2069 sp<Surface> surface = new Surface(producer);
2070 sp<ANativeWindow> window(surface);
2071 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2072 native_window_set_buffers_dimensions(window.get(), 0, 0);
2073
2074 int fence;
2075 ANativeWindowBuffer* buffer;
2076
2077 // Buffer size is driven by the consumer
2078 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2079 EXPECT_EQ(10, buffer->width);
2080 EXPECT_EQ(10, buffer->height);
2081 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2082
2083 // Buffer size is driven by the consumer
2084 consumer->setDefaultBufferSize(10, 20);
2085 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2086 EXPECT_EQ(10, buffer->width);
2087 EXPECT_EQ(20, buffer->height);
2088 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2089
2090 // Transform hint isn't synced to producer before queueBuffer or connect
2091 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2092 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2093 EXPECT_EQ(10, buffer->width);
2094 EXPECT_EQ(20, buffer->height);
2095 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2096
2097 // Transform hint is synced to producer but no auto prerotation
2098 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2099 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2100 EXPECT_EQ(10, buffer->width);
2101 EXPECT_EQ(20, buffer->height);
2102 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2103
2104 // Prerotation is driven by the consumer with the transform hint used by producer
2105 native_window_set_auto_prerotation(window.get(), true);
2106 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2107 EXPECT_EQ(20, buffer->width);
2108 EXPECT_EQ(10, buffer->height);
2109 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2110
2111 // Turn off auto prerotaton
2112 native_window_set_auto_prerotation(window.get(), false);
2113 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2114 EXPECT_EQ(10, buffer->width);
2115 EXPECT_EQ(20, buffer->height);
2116 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2117
2118 // Test auto prerotation bit is disabled after disconnect
2119 native_window_set_auto_prerotation(window.get(), true);
2120 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2121 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2122 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2123 native_window_set_buffers_dimensions(window.get(), 0, 0);
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
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002130TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2131 sp<IGraphicBufferProducer> producer;
2132 sp<IGraphicBufferConsumer> consumer;
2133 BufferQueue::createBufferQueue(&producer, &consumer);
2134
Peiyong Lind8460c82020-07-28 16:04:22 -07002135 sp<MockConsumer> mockConsumer(new MockConsumer);
2136 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002137
2138 sp<Surface> surface = new Surface(producer);
2139 sp<ANativeWindow> window(surface);
2140
2141 int count = -1;
2142 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2143 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2144
2145 consumer->setMaxBufferCount(10);
2146 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2147 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2148 EXPECT_EQ(10, count);
2149
2150 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2151 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2152 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2153}
2154
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002155TEST_F(SurfaceTest, BatchOperations) {
2156 const int BUFFER_COUNT = 16;
2157 const int BATCH_SIZE = 8;
2158 sp<IGraphicBufferProducer> producer;
2159 sp<IGraphicBufferConsumer> consumer;
2160 BufferQueue::createBufferQueue(&producer, &consumer);
2161
2162 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2163 sp<Surface> surface = new Surface(producer);
2164 sp<ANativeWindow> window(surface);
2165 sp<StubProducerListener> listener = new StubProducerListener();
2166
2167 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2168 /*reportBufferRemoval*/false));
2169
2170 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2171
2172 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2173
2174 // Batch dequeued buffers can be queued individually
2175 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2176 for (size_t i = 0; i < BATCH_SIZE; i++) {
2177 ANativeWindowBuffer* buffer = buffers[i].buffer;
2178 int fence = buffers[i].fenceFd;
2179 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2180 }
2181
2182 // Batch dequeued buffers can be canceled individually
2183 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2184 for (size_t i = 0; i < BATCH_SIZE; i++) {
2185 ANativeWindowBuffer* buffer = buffers[i].buffer;
2186 int fence = buffers[i].fenceFd;
2187 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2188 }
2189
2190 // Batch dequeued buffers can be batch cancelled
2191 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2192 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2193
2194 // Batch dequeued buffers can be batch queued
2195 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2196 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2197 for (size_t i = 0; i < BATCH_SIZE; i++) {
2198 queuedBuffers[i].buffer = buffers[i].buffer;
2199 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2200 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2201 }
2202 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2203
2204 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2205}
2206
2207TEST_F(SurfaceTest, BatchIllegalOperations) {
2208 const int BUFFER_COUNT = 16;
2209 const int BATCH_SIZE = 8;
2210 sp<IGraphicBufferProducer> producer;
2211 sp<IGraphicBufferConsumer> consumer;
2212 BufferQueue::createBufferQueue(&producer, &consumer);
2213
2214 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2215 sp<Surface> surface = new Surface(producer);
2216 sp<ANativeWindow> window(surface);
2217 sp<StubProducerListener> listener = new StubProducerListener();
2218
2219 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2220 /*reportBufferRemoval*/false));
2221
2222 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2223
2224 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2225 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2226
2227 // Batch operations are invalid in shared buffer mode
2228 surface->setSharedBufferMode(true);
2229 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2230 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2231 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2232 surface->setSharedBufferMode(false);
2233
2234 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2235}
2236
Dan Stoza932f0082017-05-31 13:50:16 -07002237} // namespace android