blob: 60221aa30a9efe901c7f9f84729839e19bf03600 [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
Nolan Scobie9c427942023-05-01 16:41:28 -040017#include "Constants.h"
Peiyong Lind8460c82020-07-28 16:04:22 -070018#include "MockConsumer.h"
Dan Stozac6f30bd2015-06-08 09:32:50 -070019
Jamie Gennis134f0422011-03-08 12:18:54 -080020#include <gtest/gtest.h>
Jamie Gennis7a4d0df2011-03-09 17:05:02 -080021
Sundong Ahnf33c9f12020-04-23 21:31:20 +090022#include <SurfaceFlingerProperties.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080023#include <android/gui/IDisplayEventConnection.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080024#include <android/gui/ISurfaceComposer.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060025#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070026#include <binder/ProcessState.h>
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060027#include <configstore/Utils.h>
Huihong Luo3bdef862022-03-03 11:57:19 -080028#include <gui/AidlStatusUtil.h>
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -070029#include <gui/BufferItemConsumer.h>
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -070030#include <gui/IProducerListener.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080031#include <gui/ISurfaceComposer.h>
32#include <gui/Surface.h>
33#include <gui/SurfaceComposerClient.h>
chaviwe7b9f272020-08-18 16:08:59 -070034#include <gui/SyncScreenCaptureListener.h>
Sundong Ahnf33c9f12020-04-23 21:31:20 +090035#include <inttypes.h>
Brian Anderson3da8d272016-07-28 16:20:47 -070036#include <private/gui/ComposerService.h>
Huihong Luof5029222021-12-16 14:33:46 -080037#include <private/gui/ComposerServiceAIDL.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080038#include <sys/types.h>
Yiwei Zhang74c9cc32020-06-20 03:35:17 -070039#include <ui/BufferQueueDefs.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010040#include <ui/DisplayMode.h>
Dan Stozac1879002014-05-22 15:59:05 -070041#include <ui/Rect.h>
Andy Yu2ae6b6b2021-11-18 14:51:06 -080042#include <utils/Errors.h>
Jamie Gennis134f0422011-03-08 12:18:54 -080043#include <utils/String8.h>
44
Brian Anderson3da8d272016-07-28 16:20:47 -070045#include <limits>
Kalle Raita643f0942016-12-07 09:20:14 -080046#include <thread>
47
Jamie Gennis134f0422011-03-08 12:18:54 -080048namespace android {
49
Kalle Raita643f0942016-12-07 09:20:14 -080050using namespace std::chrono_literals;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060051// retrieve wide-color and hdr settings from configstore
52using namespace android::hardware::configstore;
53using namespace android::hardware::configstore::V1_0;
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050054using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
Huihong Luo6fac5232021-11-22 16:05:23 -080055using gui::IDisplayEventConnection;
Huihong Luoecc1f902021-11-20 11:55:05 -080056using gui::IRegionSamplingListener;
Peiyong Lin9f034472018-03-28 15:29:00 -070057using ui::ColorMode;
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -060058
Robert Carr4cdc58f2017-08-23 14:22:20 -070059using Transaction = SurfaceComposerClient::Transaction;
60
Sundong Ahnf33c9f12020-04-23 21:31:20 +090061static bool hasWideColorDisplay = android::sysprop::has_wide_color_display(false);
Kalle Raita643f0942016-12-07 09:20:14 -080062
Sundong Ahnf33c9f12020-04-23 21:31:20 +090063static bool hasHdrDisplay = android::sysprop::has_HDR_display(false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -070064
Brian Anderson3da8d272016-07-28 16:20:47 -070065class FakeSurfaceComposer;
66class FakeProducerFrameEventHistory;
67
68static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
69
Peiyong Lind8460c82020-07-28 16:04:22 -070070class FakeSurfaceListener : public SurfaceListener {
Shuzhen Wang067fcd32019-08-14 10:41:12 -070071public:
Peiyong Lind8460c82020-07-28 16:04:22 -070072 FakeSurfaceListener(bool enableReleasedCb = false)
73 : mEnableReleaseCb(enableReleasedCb), mBuffersReleased(0) {}
74 virtual ~FakeSurfaceListener() = default;
Shuzhen Wang067fcd32019-08-14 10:41:12 -070075
76 virtual void onBufferReleased() {
77 mBuffersReleased++;
78 }
79 virtual bool needsReleaseNotify() {
80 return mEnableReleaseCb;
81 }
82 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers) {
83 mDiscardedBuffers.insert(mDiscardedBuffers.end(), buffers.begin(), buffers.end());
84 }
85
86 int getReleaseNotifyCount() const {
87 return mBuffersReleased;
88 }
89 const std::vector<sp<GraphicBuffer>>& getDiscardedBuffers() const {
90 return mDiscardedBuffers;
91 }
92private:
93 // No need to use lock given the test triggers the listener in the same
94 // thread context.
95 bool mEnableReleaseCb;
96 int32_t mBuffersReleased;
97 std::vector<sp<GraphicBuffer>> mDiscardedBuffers;
98};
99
Jamie Gennis134f0422011-03-08 12:18:54 -0800100class SurfaceTest : public ::testing::Test {
101protected:
Mathias Agopian7c1a4872013-03-20 15:56:04 -0700102 SurfaceTest() {
103 ProcessState::self()->startThreadPool();
104 }
105
Jamie Gennis134f0422011-03-08 12:18:54 -0800106 virtual void SetUp() {
Jamie Gennis7a4d0df2011-03-09 17:05:02 -0800107 mComposerClient = new SurfaceComposerClient;
Jamie Gennis134f0422011-03-08 12:18:54 -0800108 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
109
Brian Andersond0010582017-03-07 13:20:31 -0800110 // TODO(brianderson): The following sometimes fails and is a source of
111 // test flakiness.
Jamie Gennisfc850122011-04-25 16:40:05 -0700112 mSurfaceControl = mComposerClient->createSurface(
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700113 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
arthurhungdba591c2021-02-08 17:28:49 +0800114 SurfaceComposerClient::Transaction().apply(true);
Jamie Gennis134f0422011-03-08 12:18:54 -0800115
Yi Konga03e0442018-07-17 11:16:57 -0700116 ASSERT_TRUE(mSurfaceControl != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800117 ASSERT_TRUE(mSurfaceControl->isValid());
118
Robert Carr4cdc58f2017-08-23 14:22:20 -0700119 Transaction t;
arthurhungdba591c2021-02-08 17:28:49 +0800120 ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff).show(mSurfaceControl).apply());
Jamie Gennis134f0422011-03-08 12:18:54 -0800121
122 mSurface = mSurfaceControl->getSurface();
Yi Konga03e0442018-07-17 11:16:57 -0700123 ASSERT_TRUE(mSurface != nullptr);
Jamie Gennis134f0422011-03-08 12:18:54 -0800124 }
125
126 virtual void TearDown() {
127 mComposerClient->dispose();
128 }
129
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700130 void testSurfaceListener(bool hasSurfaceListener, bool enableReleasedCb,
131 int32_t extraDiscardedBuffers) {
132 sp<IGraphicBufferProducer> producer;
133 sp<IGraphicBufferConsumer> consumer;
134 BufferQueue::createBufferQueue(&producer, &consumer);
135
Peiyong Lind8460c82020-07-28 16:04:22 -0700136 sp<MockConsumer> mockConsumer(new MockConsumer);
137 consumer->consumerConnect(mockConsumer, false);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700138 consumer->setConsumerName(String8("TestConsumer"));
139
140 sp<Surface> surface = new Surface(producer);
141 sp<ANativeWindow> window(surface);
Peiyong Lind8460c82020-07-28 16:04:22 -0700142 sp<FakeSurfaceListener> listener;
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700143 if (hasSurfaceListener) {
Peiyong Lind8460c82020-07-28 16:04:22 -0700144 listener = new FakeSurfaceListener(enableReleasedCb);
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700145 }
146 ASSERT_EQ(OK, surface->connect(
147 NATIVE_WINDOW_API_CPU,
148 /*reportBufferRemoval*/true,
149 /*listener*/listener));
150 const int BUFFER_COUNT = 4 + extraDiscardedBuffers;
151 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
Nolan Scobie9c427942023-05-01 16:41:28 -0400152 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700153
154 ANativeWindowBuffer* buffers[BUFFER_COUNT];
155 // Dequeue first to allocate a number of buffers
156 for (int i = 0; i < BUFFER_COUNT; i++) {
157 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffers[i]));
158 }
159 for (int i = 0; i < BUFFER_COUNT; i++) {
160 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], -1));
161 }
162
163 ANativeWindowBuffer* buffer;
164 // Fill BUFFER_COUNT-1 buffers
165 for (int i = 0; i < BUFFER_COUNT-1; i++) {
166 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
167 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, -1));
168 }
169
170 // Dequeue 1 buffer
171 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
172
173 // Acquire and free 1+extraDiscardedBuffers buffer, check onBufferReleased is called.
174 std::vector<BufferItem> releasedItems;
175 releasedItems.resize(1+extraDiscardedBuffers);
176 for (int i = 0; i < releasedItems.size(); i++) {
177 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&releasedItems[i], 0));
178 ASSERT_EQ(NO_ERROR, consumer->releaseBuffer(releasedItems[i].mSlot,
179 releasedItems[i].mFrameNumber, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
180 Fence::NO_FENCE));
181 }
182 int32_t expectedReleaseCb = (enableReleasedCb ? releasedItems.size() : 0);
183 if (hasSurfaceListener) {
184 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
185 }
186
187 // Acquire 1 buffer, leaving 1+extraDiscardedBuffers filled buffer in queue
188 BufferItem item;
189 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&item, 0));
190
191 // Discard free buffers
192 ASSERT_EQ(NO_ERROR, consumer->discardFreeBuffers());
193
194 if (hasSurfaceListener) {
195 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
196
197 // Check onBufferDiscarded is called with correct buffer
198 auto discardedBuffers = listener->getDiscardedBuffers();
199 ASSERT_EQ(discardedBuffers.size(), releasedItems.size());
200 for (int i = 0; i < releasedItems.size(); i++) {
201 ASSERT_EQ(discardedBuffers[i], releasedItems[i].mGraphicBuffer);
202 }
203
204 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
205 }
206
207 // Disconnect the surface
208 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
209 }
210
Jamie Gennis134f0422011-03-08 12:18:54 -0800211 sp<Surface> mSurface;
212 sp<SurfaceComposerClient> mComposerClient;
213 sp<SurfaceControl> mSurfaceControl;
214};
215
Robert Carr740eaf02018-03-27 12:59:18 -0700216TEST_F(SurfaceTest, CreateSurfaceReturnsErrorBadClient) {
217 mComposerClient->dispose();
218 ASSERT_EQ(NO_INIT, mComposerClient->initCheck());
219
220 sp<SurfaceControl> sc;
221 status_t err = mComposerClient->createSurfaceChecked(
222 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, &sc, 0);
223 ASSERT_EQ(NO_INIT, err);
224}
225
Jamie Gennis134f0422011-03-08 12:18:54 -0800226TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
227 sp<ANativeWindow> anw(mSurface);
228 int result = -123;
229 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
230 &result);
231 EXPECT_EQ(NO_ERROR, err);
232 EXPECT_EQ(1, result);
233}
234
235TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
236 mSurfaceControl.clear();
Kalle Raita643f0942016-12-07 09:20:14 -0800237 // Wait for the async clean-up to complete.
238 std::this_thread::sleep_for(50ms);
Jamie Gennis134f0422011-03-08 12:18:54 -0800239
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
Jamie Gennis391bbe22011-03-14 15:00:06 -0700248TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
249 sp<ANativeWindow> anw(mSurface);
250 int result = -123;
251 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
252 EXPECT_EQ(NO_ERROR, err);
253 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
254}
255
Craig Donner6ebc46a2016-10-21 15:23:44 -0700256TEST_F(SurfaceTest, LayerCountIsOne) {
257 sp<ANativeWindow> anw(mSurface);
258 int result = -123;
259 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
260 EXPECT_EQ(NO_ERROR, err);
261 EXPECT_EQ(1, result);
262}
263
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700264TEST_F(SurfaceTest, QueryConsumerUsage) {
265 const int TEST_USAGE_FLAGS =
266 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
Dan Stoza5603a2f2014-04-07 13:41:37 -0700267 sp<IGraphicBufferProducer> producer;
268 sp<IGraphicBufferConsumer> consumer;
269 BufferQueue::createBufferQueue(&producer, &consumer);
270 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700271 TEST_USAGE_FLAGS);
Dan Stoza5603a2f2014-04-07 13:41:37 -0700272 sp<Surface> s = new Surface(producer);
Eino-Ville Talvalaf7c60872013-07-30 14:05:02 -0700273
274 sp<ANativeWindow> anw(s);
275
276 int flags = -1;
277 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
278
279 ASSERT_EQ(NO_ERROR, err);
280 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
281}
282
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800283TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
Peiyong Lin14724e62018-12-05 07:27:30 -0800284 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_V0_SRGB;
Eino-Ville Talvala5b75a512015-02-19 16:10:43 -0800285 sp<IGraphicBufferProducer> producer;
286 sp<IGraphicBufferConsumer> consumer;
287 BufferQueue::createBufferQueue(&producer, &consumer);
288 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
289
290 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
291
292 sp<Surface> s = new Surface(producer);
293
294 sp<ANativeWindow> anw(s);
295
296 android_dataspace dataSpace;
297
298 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
299 reinterpret_cast<int*>(&dataSpace));
300
301 ASSERT_EQ(NO_ERROR, err);
302 ASSERT_EQ(TEST_DATASPACE, dataSpace);
303}
304
Dan Stoza812ed062015-06-02 15:45:22 -0700305TEST_F(SurfaceTest, SettingGenerationNumber) {
306 sp<IGraphicBufferProducer> producer;
307 sp<IGraphicBufferConsumer> consumer;
308 BufferQueue::createBufferQueue(&producer, &consumer);
309 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
310 sp<Surface> surface = new Surface(producer);
311 sp<ANativeWindow> window(surface);
312
313 // Allocate a buffer with a generation number of 0
314 ANativeWindowBuffer* buffer;
315 int fenceFd;
Pablo Ceballos583b1b32015-09-03 18:23:52 -0700316 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
317 NATIVE_WINDOW_API_CPU));
Dan Stoza812ed062015-06-02 15:45:22 -0700318 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
319 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
320
321 // Detach the buffer and check its generation number
322 sp<GraphicBuffer> graphicBuffer;
323 sp<Fence> fence;
324 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
325 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
326
327 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
328 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
329
330 // This should change the generation number of the GraphicBuffer
331 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
332
333 // Check that the new generation number sticks with the buffer
334 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
335 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
336 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
337 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
338}
339
Dan Stozac6f30bd2015-06-08 09:32:50 -0700340TEST_F(SurfaceTest, GetConsumerName) {
341 sp<IGraphicBufferProducer> producer;
342 sp<IGraphicBufferConsumer> consumer;
343 BufferQueue::createBufferQueue(&producer, &consumer);
344
Peiyong Lind8460c82020-07-28 16:04:22 -0700345 sp<MockConsumer> mockConsumer(new MockConsumer);
346 consumer->consumerConnect(mockConsumer, false);
Dan Stozac6f30bd2015-06-08 09:32:50 -0700347 consumer->setConsumerName(String8("TestConsumer"));
348
349 sp<Surface> surface = new Surface(producer);
350 sp<ANativeWindow> window(surface);
351 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
352
Tomasz Wasilczykb19fe0c2023-08-11 00:06:51 +0000353 EXPECT_STREQ("TestConsumer", surface->getConsumerName().c_str());
Dan Stozac6f30bd2015-06-08 09:32:50 -0700354}
355
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700356TEST_F(SurfaceTest, GetWideColorSupport) {
357 sp<IGraphicBufferProducer> producer;
358 sp<IGraphicBufferConsumer> consumer;
359 BufferQueue::createBufferQueue(&producer, &consumer);
360
Peiyong Lind8460c82020-07-28 16:04:22 -0700361 sp<MockConsumer> mockConsumer(new MockConsumer);
362 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700363 consumer->setConsumerName(String8("TestConsumer"));
364
365 sp<Surface> surface = new Surface(producer);
366 sp<ANativeWindow> window(surface);
367 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
368
369 bool supported;
370 surface->getWideColorSupport(&supported);
371
Courtney Goeltzenleuchter6a570b62017-03-13 14:30:00 -0600372 // NOTE: This test assumes that device that supports
373 // wide-color (as indicated by BoardConfig) must also
374 // have a wide-color primary display.
375 // That assumption allows this test to cover devices
376 // that advertised a wide-color color mode without
377 // actually supporting wide-color to pass this test
378 // as well as the case of a device that does support
379 // wide-color (via BoardConfig) and has a wide-color
380 // primary display.
381 // NOT covered at this time is a device that supports
382 // wide color in the BoardConfig but does not support
383 // a wide-color color mode on the primary display.
384 ASSERT_EQ(hasWideColorDisplay, supported);
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700385}
386
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700387TEST_F(SurfaceTest, GetHdrSupport) {
388 sp<IGraphicBufferProducer> producer;
389 sp<IGraphicBufferConsumer> consumer;
390 BufferQueue::createBufferQueue(&producer, &consumer);
391
Peiyong Lind8460c82020-07-28 16:04:22 -0700392 sp<MockConsumer> mockConsumer(new MockConsumer);
393 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700394 consumer->setConsumerName(String8("TestConsumer"));
395
396 sp<Surface> surface = new Surface(producer);
397 sp<ANativeWindow> window(surface);
398 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
399
400 bool supported;
401 status_t result = surface->getHdrSupport(&supported);
402 ASSERT_EQ(NO_ERROR, result);
403
404 // NOTE: This is not a CTS test.
405 // This test verifies that when the BoardConfig TARGET_HAS_HDR_DISPLAY
406 // is TRUE, getHdrSupport is also true.
407 // TODO: Add check for an HDR color mode on the primary display.
408 ASSERT_EQ(hasHdrDisplay, supported);
409}
410
411TEST_F(SurfaceTest, SetHdrMetadata) {
412 sp<IGraphicBufferProducer> producer;
413 sp<IGraphicBufferConsumer> consumer;
414 BufferQueue::createBufferQueue(&producer, &consumer);
415
Peiyong Lind8460c82020-07-28 16:04:22 -0700416 sp<MockConsumer> mockConsumer(new MockConsumer);
417 consumer->consumerConnect(mockConsumer, false);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700418 consumer->setConsumerName(String8("TestConsumer"));
419
420 sp<Surface> surface = new Surface(producer);
421 sp<ANativeWindow> window(surface);
422 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
423
424 bool supported;
425 status_t result = surface->getHdrSupport(&supported);
426 ASSERT_EQ(NO_ERROR, result);
427
428 if (!hasHdrDisplay || !supported) {
429 return;
430 }
431 const android_smpte2086_metadata smpte2086 = {
432 {0.680, 0.320},
433 {0.265, 0.690},
434 {0.150, 0.060},
435 {0.3127, 0.3290},
436 100.0,
437 0.1,
438 };
439 const android_cta861_3_metadata cta861_3 = {
440 78.0,
441 62.0,
442 };
Valerie Haua82679d2018-11-21 09:31:43 -0800443
444 std::vector<uint8_t> hdr10plus;
445 hdr10plus.push_back(0xff);
446
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700447 int error = native_window_set_buffers_smpte2086_metadata(window.get(), &smpte2086);
448 ASSERT_EQ(error, NO_ERROR);
449 error = native_window_set_buffers_cta861_3_metadata(window.get(), &cta861_3);
450 ASSERT_EQ(error, NO_ERROR);
Valerie Haua82679d2018-11-21 09:31:43 -0800451 error = native_window_set_buffers_hdr10_plus_metadata(window.get(), hdr10plus.size(),
452 hdr10plus.data());
453 ASSERT_EQ(error, NO_ERROR);
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700454}
455
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800456TEST_F(SurfaceTest, DynamicSetBufferCount) {
457 sp<IGraphicBufferProducer> producer;
458 sp<IGraphicBufferConsumer> consumer;
459 BufferQueue::createBufferQueue(&producer, &consumer);
460
Peiyong Lind8460c82020-07-28 16:04:22 -0700461 sp<MockConsumer> mockConsumer(new MockConsumer);
462 consumer->consumerConnect(mockConsumer, false);
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800463 consumer->setConsumerName(String8("TestConsumer"));
464
465 sp<Surface> surface = new Surface(producer);
466 sp<ANativeWindow> window(surface);
467
468 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
469 NATIVE_WINDOW_API_CPU));
Nolan Scobie9c427942023-05-01 16:41:28 -0400470 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), 4));
471 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Pablo Ceballos789a0c82016-02-05 13:39:27 -0800472
473 int fence;
474 ANativeWindowBuffer* buffer;
475 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
476 native_window_set_buffer_count(window.get(), 3);
477 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
478 native_window_set_buffer_count(window.get(), 2);
479 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
480 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
481}
482
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700483TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
484 sp<IGraphicBufferProducer> producer;
485 sp<IGraphicBufferConsumer> consumer;
486 BufferQueue::createBufferQueue(&producer, &consumer);
487
Peiyong Lind8460c82020-07-28 16:04:22 -0700488 sp<MockConsumer> mockConsumer(new MockConsumer);
489 consumer->consumerConnect(mockConsumer, false);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700490 consumer->setConsumerName(String8("TestConsumer"));
491
492 sp<Surface> surface = new Surface(producer);
493 sp<ANativeWindow> window(surface);
Peiyong Lind8460c82020-07-28 16:04:22 -0700494 sp<StubProducerListener> listener = new StubProducerListener();
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700495 ASSERT_EQ(OK, surface->connect(
496 NATIVE_WINDOW_API_CPU,
497 /*listener*/listener,
498 /*reportBufferRemoval*/true));
499 const int BUFFER_COUNT = 4;
500 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
Nolan Scobie9c427942023-05-01 16:41:28 -0400501 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700502
503 sp<GraphicBuffer> detachedBuffer;
504 sp<Fence> outFence;
505 int fences[BUFFER_COUNT];
506 ANativeWindowBuffer* buffers[BUFFER_COUNT];
507 // Allocate buffers because detachNextBuffer requires allocated buffers
508 for (int i = 0; i < BUFFER_COUNT; i++) {
509 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
510 }
511 for (int i = 0; i < BUFFER_COUNT; i++) {
512 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
513 }
514
515 // Test detached buffer is correctly reported
516 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
517 std::vector<sp<GraphicBuffer>> removedBuffers;
518 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
519 ASSERT_EQ(1u, removedBuffers.size());
520 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
521 // Test the list is flushed one getAndFlushRemovedBuffers returns
522 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
523 ASSERT_EQ(0u, removedBuffers.size());
524
525
526 // Test removed buffer list is cleanup after next dequeueBuffer call
527 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
528 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
529 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
530 ASSERT_EQ(0u, removedBuffers.size());
531 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
532
533 // Test removed buffer list is cleanup after next detachNextBuffer call
534 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
535 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
536 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
537 ASSERT_EQ(1u, removedBuffers.size());
538 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
539
540 // Re-allocate buffers since all buffers are detached up to now
541 for (int i = 0; i < BUFFER_COUNT; i++) {
542 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
543 }
544 for (int i = 0; i < BUFFER_COUNT; i++) {
545 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
546 }
547
548 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
549 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
550 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
551 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
552 // get 0 or 1 buffer removed.
553 ASSERT_LE(removedBuffers.size(), 1u);
554}
Brian Anderson3da8d272016-07-28 16:20:47 -0700555
Shuzhen Wang067fcd32019-08-14 10:41:12 -0700556TEST_F(SurfaceTest, SurfaceListenerTest) {
557 // Test discarding 1 free buffers with no listener
558 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/0);
559 // Test discarding 2 free buffers with no listener
560 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/1);
561 // Test discarding 1 free buffers with a listener, disabling onBufferReleased
562 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/0);
563 // Test discarding 2 free buffers with a listener, disabling onBufferReleased
564 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/1);
565 // Test discarding 1 free buffers with a listener, enabling onBufferReleased
566 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/0);
567 // Test discarding 3 free buffers with a listener, enabling onBufferReleased
568 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/2);
569}
570
Dan Stoza932f0082017-05-31 13:50:16 -0700571TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
572 sp<ANativeWindow> anw(mSurface);
573 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
574
575 ANativeWindowBuffer* buffer = nullptr;
576 int32_t fenceFd = -1;
577
578 nsecs_t before = systemTime(CLOCK_MONOTONIC);
579 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
580 nsecs_t after = systemTime(CLOCK_MONOTONIC);
581
Alec Mouria1619662019-08-21 19:30:48 -0700582 nsecs_t lastDequeueTime = ANativeWindow_getLastDequeueStartTime(anw.get());
Dan Stoza932f0082017-05-31 13:50:16 -0700583 ASSERT_LE(before, lastDequeueTime);
584 ASSERT_GE(after, lastDequeueTime);
585}
586
Brian Anderson3da8d272016-07-28 16:20:47 -0700587class FakeConsumer : public BnConsumerListener {
588public:
589 void onFrameAvailable(const BufferItem& /*item*/) override {}
590 void onBuffersReleased() override {}
591 void onSidebandStreamChanged() override {}
592
593 void addAndGetFrameTimestamps(
594 const NewFrameEventsEntry* newTimestamps,
595 FrameEventHistoryDelta* outDelta) override {
596 if (newTimestamps) {
597 if (mGetFrameTimestampsEnabled) {
598 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
599 "Test should set mNewFrameEntryOverride before queuing "
600 "a frame.";
601 EXPECT_EQ(newTimestamps->frameNumber,
602 mNewFrameEntryOverride.frameNumber) <<
603 "Test attempting to add NewFrameEntryOverride with "
604 "incorrect frame number.";
605 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
606 mNewFrameEntryOverride.frameNumber = 0;
607 }
608 mAddFrameTimestampsCount++;
609 mLastAddedFrameNumber = newTimestamps->frameNumber;
610 }
611 if (outDelta) {
612 mFrameEventHistory.getAndResetDelta(outDelta);
613 mGetFrameTimestampsCount++;
614 }
615 mAddAndGetFrameTimestampsCallCount++;
616 }
617
618 bool mGetFrameTimestampsEnabled = false;
619
620 ConsumerFrameEventHistory mFrameEventHistory;
621 int mAddAndGetFrameTimestampsCallCount = 0;
622 int mAddFrameTimestampsCount = 0;
623 int mGetFrameTimestampsCount = 0;
624 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
625
626 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
627};
628
Pablo Gamito6ee484d2020-07-30 14:26:28 +0000629class FakeSurfaceComposer : public ISurfaceComposer {
Brian Anderson3da8d272016-07-28 16:20:47 -0700630public:
631 ~FakeSurfaceComposer() override {}
632
Brian Anderson6b376712017-04-04 10:51:39 -0700633 void setSupportsPresent(bool supportsPresent) {
634 mSupportsPresent = supportsPresent;
635 }
636
Pablo Gamito23780be2023-04-18 08:30:00 +0000637 status_t setTransactionState(
638 const FrameTimelineInfo& /*frameTimelineInfo*/, Vector<ComposerState>& /*state*/,
639 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
640 const sp<IBinder>& /*applyToken*/, InputWindowCommands /*inputWindowCommands*/,
641 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
642 const std::vector<client_cache_t>& /*cachedBuffer*/, bool /*hasListenerCallbacks*/,
643 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/, uint64_t /*transactionId*/,
644 const std::vector<uint64_t>& /*mergedTransactionIds*/) override {
chaviw308ddba2020-08-11 16:23:51 -0700645 return NO_ERROR;
Marissa Wall3dad52d2019-03-22 14:03:19 -0700646 }
Marissa Wall17b4e452018-12-26 16:32:34 -0800647
Brian Anderson3da8d272016-07-28 16:20:47 -0700648protected:
649 IBinder* onAsBinder() override { return nullptr; }
650
651private:
652 bool mSupportsPresent{true};
Brian Anderson3da8d272016-07-28 16:20:47 -0700653};
654
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800655class FakeSurfaceComposerAIDL : public gui::ISurfaceComposer {
656public:
657 ~FakeSurfaceComposerAIDL() override {}
658
659 void setSupportsPresent(bool supportsPresent) { mSupportsPresent = supportsPresent; }
660
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700661 binder::Status bootFinished() override { return binder::Status::ok(); }
662
663 binder::Status createDisplayEventConnection(
664 VsyncSource /*vsyncSource*/, EventRegistration /*eventRegistration*/,
Rachel Lee2248f522023-01-27 16:45:23 -0800665 const sp<IBinder>& /*layerHandle*/,
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700666 sp<gui::IDisplayEventConnection>* outConnection) override {
667 *outConnection = nullptr;
668 return binder::Status::ok();
669 }
670
Huihong Luod3d8f8e2022-03-08 14:48:46 -0800671 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override {
672 *outClient = nullptr;
673 return binder::Status::ok();
674 }
675
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800676 binder::Status createDisplay(const std::string& /*displayName*/, bool /*secure*/,
Huihong Luo1768cb02022-10-11 11:10:34 -0700677 float /*requestedRefreshRate*/,
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800678 sp<IBinder>* /*outDisplay*/) override {
679 return binder::Status::ok();
680 }
681
682 binder::Status destroyDisplay(const sp<IBinder>& /*display*/) override {
683 return binder::Status::ok();
684 }
685
686 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* /*outDisplayIds*/) override {
687 return binder::Status::ok();
688 }
689
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800690 binder::Status getPhysicalDisplayToken(int64_t /*displayId*/,
691 sp<IBinder>* /*outDisplay*/) override {
692 return binder::Status::ok();
693 }
694
695 binder::Status setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {
696 return binder::Status::ok();
697 }
698
Huihong Luo0a81aa32022-02-22 16:02:36 -0800699 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override {
700 *outSupported = {FrameEvent::REQUESTED_PRESENT,
701 FrameEvent::ACQUIRE,
702 FrameEvent::LATCH,
703 FrameEvent::FIRST_REFRESH_START,
704 FrameEvent::LAST_REFRESH_START,
705 FrameEvent::GPU_COMPOSITION_DONE,
706 FrameEvent::DEQUEUE_READY,
707 FrameEvent::RELEASE};
708 if (mSupportsPresent) {
709 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
710 }
711 return binder::Status::ok();
712 }
713
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800714 binder::Status getDisplayStats(const sp<IBinder>& /*display*/,
715 gui::DisplayStatInfo* /*outStatInfo*/) override {
716 return binder::Status::ok();
717 }
718
719 binder::Status getDisplayState(const sp<IBinder>& /*display*/,
720 gui::DisplayState* /*outState*/) override {
721 return binder::Status::ok();
722 }
723
Sally Qi6bb12822022-10-05 11:42:30 -0700724 binder::Status getStaticDisplayInfo(int64_t /*displayId*/,
Huihong Luoa79ddf42022-02-17 00:01:38 -0800725 gui::StaticDisplayInfo* /*outInfo*/) override {
726 return binder::Status::ok();
727 }
728
Sally Qi6bb12822022-10-05 11:42:30 -0700729 binder::Status getDynamicDisplayInfoFromId(int64_t /*displayId*/,
730 gui::DynamicDisplayInfo* /*outInfo*/) override {
731 return binder::Status::ok();
732 }
733
734 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& /*display*/,
735 gui::DynamicDisplayInfo* /*outInfo*/) override {
Huihong Luo38603fd2022-02-21 14:32:54 -0800736 return binder::Status::ok();
737 }
738
Huihong Luoca3d9a42022-02-22 11:07:34 -0800739 binder::Status getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
740 gui::DisplayPrimaries* /*outPrimaries*/) override {
741 return binder::Status::ok();
742 }
743
744 binder::Status setActiveColorMode(const sp<IBinder>& /*display*/, int /*colorMode*/) override {
745 return binder::Status::ok();
746 }
747
748 binder::Status setBootDisplayMode(const sp<IBinder>& /*display*/,
749 int /*displayModeId*/) override {
750 return binder::Status::ok();
751 }
752
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800753 binder::Status clearBootDisplayMode(const sp<IBinder>& /*display*/) override {
754 return binder::Status::ok();
755 }
756
757 binder::Status getBootDisplayModeSupport(bool* /*outMode*/) override {
758 return binder::Status::ok();
759 }
760
Kriti Dang674b9372022-11-18 10:58:44 +0100761 binder::Status getHdrConversionCapabilities(
762 std::vector<gui::HdrConversionCapability>*) override {
763 return binder::Status::ok();
764 }
765
766 binder::Status setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +0100767 const gui::HdrConversionStrategy& /*hdrConversionStrategy*/,
768 int32_t* /*outPreferredHdrOutputType*/) override {
Kriti Dang674b9372022-11-18 10:58:44 +0100769 return binder::Status::ok();
770 }
771
772 binder::Status getHdrOutputConversionSupport(bool* /*outSupport*/) override {
773 return binder::Status::ok();
774 }
775
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800776 binder::Status setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {
777 return binder::Status::ok();
778 }
779
780 binder::Status setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {
781 return binder::Status::ok();
782 }
783
784 binder::Status captureDisplay(const DisplayCaptureArgs&,
785 const sp<IScreenCaptureListener>&) override {
786 return binder::Status::ok();
787 }
788
John Reck7e4c4872023-11-14 18:31:03 -0500789 binder::Status captureDisplayById(int64_t, const gui::CaptureArgs&,
790 const sp<IScreenCaptureListener>&) override {
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800791 return binder::Status::ok();
792 }
793
794 binder::Status captureLayers(const LayerCaptureArgs&,
795 const sp<IScreenCaptureListener>&) override {
796 return binder::Status::ok();
797 }
798
Huihong Luo4ed1c912022-02-22 14:30:01 -0800799 binder::Status clearAnimationFrameStats() override { return binder::Status::ok(); }
800
801 binder::Status getAnimationFrameStats(gui::FrameStats* /*outStats*/) override {
802 return binder::Status::ok();
803 }
804
Huihong Luo05539a12022-02-23 10:29:40 -0800805 binder::Status overrideHdrTypes(const sp<IBinder>& /*display*/,
806 const std::vector<int32_t>& /*hdrTypes*/) override {
807 return binder::Status::ok();
808 }
809
810 binder::Status onPullAtom(int32_t /*atomId*/, gui::PullAtomData* /*outPullData*/) override {
811 return binder::Status::ok();
812 }
813
Huihong Luo05539a12022-02-23 10:29:40 -0800814 binder::Status getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* /*outLayers*/) override {
815 return binder::Status::ok();
816 }
817
Huihong Luo05539a12022-02-23 10:29:40 -0800818 binder::Status getCompositionPreference(gui::CompositionPreference* /*outPref*/) override {
819 return binder::Status::ok();
820 }
821
822 binder::Status getDisplayedContentSamplingAttributes(
823 const sp<IBinder>& /*display*/, gui::ContentSamplingAttributes* /*outAttrs*/) override {
824 return binder::Status::ok();
825 }
826
827 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
828 int8_t /*componentMask*/,
829 int64_t /*maxFrames*/) override {
830 return binder::Status::ok();
831 }
832
833 binder::Status getProtectedContentSupport(bool* /*outSupporte*/) override {
834 return binder::Status::ok();
835 }
836
Huihong Luo3bdef862022-03-03 11:57:19 -0800837 binder::Status getDisplayedContentSample(const sp<IBinder>& /*display*/, int64_t /*maxFrames*/,
838 int64_t /*timestamp*/,
839 gui::DisplayedFrameStats* /*outStats*/) override {
840 return binder::Status::ok();
841 }
842
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800843 binder::Status isWideColorDisplay(const sp<IBinder>& /*token*/,
844 bool* /*outIsWideColorDisplay*/) override {
845 return binder::Status::ok();
846 }
847
Huihong Luo02186fb2022-02-23 14:21:54 -0800848 binder::Status addRegionSamplingListener(
849 const gui::ARect& /*samplingArea*/, const sp<IBinder>& /*stopLayerHandle*/,
850 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
851 return binder::Status::ok();
852 }
853
854 binder::Status removeRegionSamplingListener(
855 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
856 return binder::Status::ok();
857 }
858
859 binder::Status addFpsListener(int32_t /*taskId*/,
860 const sp<gui::IFpsListener>& /*listener*/) override {
861 return binder::Status::ok();
862 }
863
864 binder::Status removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) override {
865 return binder::Status::ok();
866 }
867
868 binder::Status addTunnelModeEnabledListener(
869 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
870 return binder::Status::ok();
871 }
872
873 binder::Status removeTunnelModeEnabledListener(
874 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
875 return binder::Status::ok();
876 }
877
878 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700879 const gui::DisplayModeSpecs&) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800880 return binder::Status::ok();
881 }
882
883 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
Ady Abraham285f8c12022-10-11 17:12:14 -0700884 gui::DisplayModeSpecs*) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800885 return binder::Status::ok();
886 }
887
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800888 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
889 bool* /*outSupport*/) override {
890 return binder::Status::ok();
891 }
892
893 binder::Status setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
894 const gui::DisplayBrightness& /*brightness*/) override {
895 return binder::Status::ok();
896 }
897
898 binder::Status addHdrLayerInfoListener(
899 const sp<IBinder>& /*displayToken*/,
900 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
901 return binder::Status::ok();
902 }
903
904 binder::Status removeHdrLayerInfoListener(
905 const sp<IBinder>& /*displayToken*/,
906 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
907 return binder::Status::ok();
908 }
909
910 binder::Status notifyPowerBoost(int /*boostId*/) override { return binder::Status::ok(); }
911
Huihong Luo3bdef862022-03-03 11:57:19 -0800912 binder::Status setGlobalShadowSettings(const gui::Color& /*ambientColor*/,
913 const gui::Color& /*spotColor*/, float /*lightPosY*/,
914 float /*lightPosZ*/, float /*lightRadius*/) override {
915 return binder::Status::ok();
916 }
917
918 binder::Status getDisplayDecorationSupport(
919 const sp<IBinder>& /*displayToken*/,
920 std::optional<gui::DisplayDecorationSupport>* /*outSupport*/) override {
921 return binder::Status::ok();
922 }
923
924 binder::Status setOverrideFrameRate(int32_t /*uid*/, float /*frameRate*/) override {
925 return binder::Status::ok();
926 }
927
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +0000928 binder::Status enableRefreshRateOverlay(bool /*active*/) override {
929 return binder::Status::ok();
930 }
931
932 binder::Status setDebugFlash(int /*delay*/) override { return binder::Status::ok(); }
933
934 binder::Status scheduleComposite() override { return binder::Status::ok(); }
935
936 binder::Status scheduleCommit() override { return binder::Status::ok(); }
937
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +0000938 binder::Status forceClientComposition(bool /*enabled*/) override {
939 return binder::Status::ok();
940 }
941
Tony Huangf3621102023-09-04 17:14:22 +0800942 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& /*appIds*/,
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000943 const std::vector<float>& /*thresholds*/) {
944 return binder::Status::ok();
945 }
946
Tony Huangf3621102023-09-04 17:14:22 +0800947 binder::Status setSmallAreaDetectionThreshold(int32_t /*appId*/, float /*threshold*/) {
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000948 return binder::Status::ok();
949 }
950
Huihong Luo02186fb2022-02-23 14:21:54 -0800951 binder::Status getGpuContextPriority(int32_t* /*outPriority*/) override {
952 return binder::Status::ok();
953 }
954
955 binder::Status getMaxAcquiredBufferCount(int32_t* /*buffers*/) override {
956 return binder::Status::ok();
957 }
958
959 binder::Status addWindowInfosListener(
Patrick Williamsacd22582023-07-12 13:47:28 -0500960 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/,
961 gui::WindowInfosListenerInfo* /*outInfo*/) override {
Huihong Luo02186fb2022-02-23 14:21:54 -0800962 return binder::Status::ok();
963 }
964
965 binder::Status removeWindowInfosListener(
966 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
967 return binder::Status::ok();
968 }
969
Sally Qi0cbd08b2022-08-17 12:12:28 -0700970 binder::Status getOverlaySupport(gui::OverlayProperties* /*properties*/) override {
971 return binder::Status::ok();
972 }
973
Patrick Williams090ad062023-08-08 12:30:10 -0500974 binder::Status getStalledTransactionInfo(
975 int32_t /*pid*/, std::optional<gui::StalledTransactionInfo>* /*result*/) override {
976 return binder::Status::ok();
977 }
978
Ady Abraham07d03c42023-09-27 19:15:08 -0700979 binder::Status getSchedulingPolicy(gui::SchedulingPolicy*) override {
980 return binder::Status::ok();
981 }
982
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800983protected:
984 IBinder* onAsBinder() override { return nullptr; }
985
986private:
987 bool mSupportsPresent{true};
988};
989
Brian Anderson3da8d272016-07-28 16:20:47 -0700990class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
991public:
Chih-Hung Hsiehaaf62162018-12-20 15:45:04 -0800992 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
Brian Anderson3da8d272016-07-28 16:20:47 -0700993
994 ~FakeProducerFrameEventHistory() {}
995
996 void updateAcquireFence(uint64_t frameNumber,
997 std::shared_ptr<FenceTime>&& acquire) override {
998 // Verify the acquire fence being added isn't the one from the consumer.
999 EXPECT_NE(mConsumerAcquireFence, acquire);
1000 // Override the fence, so we can verify this was called by the
1001 // producer after the frame is queued.
1002 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
1003 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
1004 }
1005
1006 void setAcquireFenceOverride(
1007 const std::shared_ptr<FenceTime>& acquireFenceOverride,
1008 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
1009 mAcquireFenceOverride = acquireFenceOverride;
1010 mConsumerAcquireFence = consumerAcquireFence;
1011 }
1012
1013protected:
1014 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
1015 const override {
1016 return mFenceMap->createFenceTimeForTest(fence);
1017 }
1018
1019 FenceToFenceTimeMap* mFenceMap{nullptr};
1020
1021 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
1022 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
1023};
1024
1025
1026class TestSurface : public Surface {
1027public:
Huihong Luo0a81aa32022-02-22 16:02:36 -08001028 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer, FenceToFenceTimeMap* fenceMap)
1029 : Surface(bufferProducer),
1030 mFakeSurfaceComposer(new FakeSurfaceComposer),
1031 mFakeSurfaceComposerAIDL(new FakeSurfaceComposerAIDL) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001032 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
1033 mFrameEventHistory.reset(mFakeFrameEventHistory);
1034 }
1035
1036 ~TestSurface() override {}
1037
1038 sp<ISurfaceComposer> composerService() const override {
1039 return mFakeSurfaceComposer;
1040 }
1041
Huihong Luo0a81aa32022-02-22 16:02:36 -08001042 sp<gui::ISurfaceComposer> composerServiceAIDL() const override {
1043 return mFakeSurfaceComposerAIDL;
1044 }
1045
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001046 nsecs_t now() const override {
1047 return mNow;
1048 }
1049
1050 void setNow(nsecs_t now) {
1051 mNow = now;
1052 }
1053
Brian Anderson3da8d272016-07-28 16:20:47 -07001054public:
1055 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001056 sp<FakeSurfaceComposerAIDL> mFakeSurfaceComposerAIDL;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001057 nsecs_t mNow = 0;
Brian Anderson3da8d272016-07-28 16:20:47 -07001058
1059 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
1060 // but this raw pointer gives access to test functionality.
1061 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
1062};
1063
1064
Brian Andersond0010582017-03-07 13:20:31 -08001065class GetFrameTimestampsTest : public ::testing::Test {
Brian Anderson3da8d272016-07-28 16:20:47 -07001066protected:
1067 struct FenceAndFenceTime {
1068 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001069 : mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
1070
1071 sp<Fence> mFence = sp<Fence>::make();
1072 std::shared_ptr<FenceTime> mFenceTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001073 };
1074
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001075 static CompositorTiming makeCompositorTiming(nsecs_t deadline = 1'000'000'000,
1076 nsecs_t interval = 16'666'667,
1077 nsecs_t presentLatency = 50'000'000) {
1078 CompositorTiming timing;
1079 timing.deadline = deadline;
1080 timing.interval = interval;
1081 timing.presentLatency = presentLatency;
1082 return timing;
1083 }
1084
Brian Anderson3da8d272016-07-28 16:20:47 -07001085 struct RefreshEvents {
1086 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001087 : mFenceMap(fenceMap),
1088 kCompositorTiming(
1089 makeCompositorTiming(refreshStart, refreshStart + 1, refreshStart + 2)),
1090 kStartTime(refreshStart + 3),
1091 kGpuCompositionDoneTime(refreshStart + 4),
1092 kPresentTime(refreshStart + 5) {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001093
1094 void signalPostCompositeFences() {
1095 mFenceMap.signalAllForTest(
1096 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1097 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1098 }
1099
1100 FenceToFenceTimeMap& mFenceMap;
1101
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001102 FenceAndFenceTime mGpuCompositionDone{mFenceMap};
1103 FenceAndFenceTime mPresent{mFenceMap};
Brian Anderson3da8d272016-07-28 16:20:47 -07001104
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001105 const CompositorTiming kCompositorTiming;
1106
Brian Anderson3da8d272016-07-28 16:20:47 -07001107 const nsecs_t kStartTime;
1108 const nsecs_t kGpuCompositionDoneTime;
1109 const nsecs_t kPresentTime;
1110 };
1111
1112 struct FrameEvents {
1113 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1114 : mFenceMap(fenceMap),
1115 kPostedTime(frameStartTime + 100),
1116 kRequestedPresentTime(frameStartTime + 200),
1117 kProducerAcquireTime(frameStartTime + 300),
1118 kConsumerAcquireTime(frameStartTime + 301),
1119 kLatchTime(frameStartTime + 500),
Brian Andersonf6386862016-10-31 16:34:13 -07001120 kDequeueReadyTime(frameStartTime + 600),
Brian Anderson4e606e32017-03-16 15:34:57 -07001121 kReleaseTime(frameStartTime + 700),
Brian Anderson3da8d272016-07-28 16:20:47 -07001122 mRefreshes {
1123 { mFenceMap, frameStartTime + 410 },
1124 { mFenceMap, frameStartTime + 420 },
1125 { mFenceMap, frameStartTime + 430 } } {}
1126
1127 void signalQueueFences() {
1128 mFenceMap.signalAllForTest(
1129 mAcquireConsumer.mFence, kConsumerAcquireTime);
1130 mFenceMap.signalAllForTest(
1131 mAcquireProducer.mFence, kProducerAcquireTime);
1132 }
1133
1134 void signalRefreshFences() {
1135 for (auto& re : mRefreshes) {
1136 re.signalPostCompositeFences();
1137 }
1138 }
1139
1140 void signalReleaseFences() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001141 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1142 }
1143
1144 FenceToFenceTimeMap& mFenceMap;
1145
1146 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1147 FenceAndFenceTime mAcquireProducer { mFenceMap };
Brian Anderson3da8d272016-07-28 16:20:47 -07001148 FenceAndFenceTime mRelease { mFenceMap };
1149
1150 const nsecs_t kPostedTime;
1151 const nsecs_t kRequestedPresentTime;
1152 const nsecs_t kProducerAcquireTime;
1153 const nsecs_t kConsumerAcquireTime;
1154 const nsecs_t kLatchTime;
Brian Andersonf6386862016-10-31 16:34:13 -07001155 const nsecs_t kDequeueReadyTime;
Brian Anderson3da8d272016-07-28 16:20:47 -07001156 const nsecs_t kReleaseTime;
1157
1158 RefreshEvents mRefreshes[3];
1159 };
1160
Brian Andersond0010582017-03-07 13:20:31 -08001161 GetFrameTimestampsTest() {}
Brian Anderson3da8d272016-07-28 16:20:47 -07001162
1163 virtual void SetUp() {
Brian Anderson3da8d272016-07-28 16:20:47 -07001164 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1165 mFakeConsumer = new FakeConsumer;
1166 mCfeh = &mFakeConsumer->mFrameEventHistory;
1167 mConsumer->consumerConnect(mFakeConsumer, false);
1168 mConsumer->setConsumerName(String8("TestConsumer"));
1169 mSurface = new TestSurface(mProducer, &mFenceMap);
1170 mWindow = mSurface;
1171
1172 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1173 NATIVE_WINDOW_API_CPU));
Nolan Scobie9c427942023-05-01 16:41:28 -04001174 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(mWindow.get(), 4));
1175 ASSERT_EQ(NO_ERROR, native_window_set_usage(mWindow.get(), TEST_PRODUCER_USAGE_BITS));
Brian Anderson3da8d272016-07-28 16:20:47 -07001176 }
1177
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001178 void disableFrameTimestamps() {
1179 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1180 native_window_enable_frame_timestamps(mWindow.get(), 0);
1181 mFrameTimestampsEnabled = false;
1182 }
1183
Brian Anderson3da8d272016-07-28 16:20:47 -07001184 void enableFrameTimestamps() {
1185 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1186 native_window_enable_frame_timestamps(mWindow.get(), 1);
1187 mFrameTimestampsEnabled = true;
1188 }
1189
Brian Anderson1049d1d2016-12-16 17:25:57 -08001190 int getAllFrameTimestamps(uint64_t frameId) {
1191 return native_window_get_frame_timestamps(mWindow.get(), frameId,
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001192 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1193 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1194 &outGpuCompositionDoneTime, &outDisplayPresentTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001195 &outDequeueReadyTime, &outReleaseTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001196 }
1197
Brian Anderson3da8d272016-07-28 16:20:47 -07001198 void resetTimestamps() {
1199 outRequestedPresentTime = -1;
1200 outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001201 outLatchTime = -1;
1202 outFirstRefreshStartTime = -1;
1203 outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001204 outGpuCompositionDoneTime = -1;
1205 outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001206 outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001207 outReleaseTime = -1;
1208 }
1209
Brian Anderson1049d1d2016-12-16 17:25:57 -08001210 uint64_t getNextFrameId() {
1211 uint64_t frameId = -1;
1212 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1213 EXPECT_EQ(status, NO_ERROR);
1214 return frameId;
1215 }
1216
Brian Anderson3da8d272016-07-28 16:20:47 -07001217 void dequeueAndQueue(uint64_t frameIndex) {
1218 int fence = -1;
1219 ANativeWindowBuffer* buffer = nullptr;
1220 ASSERT_EQ(NO_ERROR,
1221 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1222
1223 int oldAddFrameTimestampsCount =
1224 mFakeConsumer->mAddFrameTimestampsCount;
1225
1226 FrameEvents* frame = &mFrames[frameIndex];
1227 uint64_t frameNumber = frameIndex + 1;
1228
1229 NewFrameEventsEntry fe;
1230 fe.frameNumber = frameNumber;
1231 fe.postedTime = frame->kPostedTime;
1232 fe.requestedPresentTime = frame->kRequestedPresentTime;
1233 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1234 mFakeConsumer->mNewFrameEntryOverride = fe;
1235
1236 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1237 frame->mAcquireProducer.mFenceTime,
1238 frame->mAcquireConsumer.mFenceTime);
1239
1240 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1241
1242 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1243
1244 EXPECT_EQ(
1245 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1246 mFakeConsumer->mAddFrameTimestampsCount);
1247 }
1248
1249 void addFrameEvents(
1250 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1251 FrameEvents* oldFrame =
1252 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1253 FrameEvents* newFrame = &mFrames[iNewFrame];
1254
Courtney Goeltzenleuchter5e921442018-01-19 13:43:43 -08001255 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001256 uint64_t nNewFrame = iNewFrame + 1;
1257
Brian Anderson4e606e32017-03-16 15:34:57 -07001258 // Latch, Composite, and Release the frames in a plausible order.
1259 // Note: The timestamps won't necessarily match the order, but
Brian Anderson3da8d272016-07-28 16:20:47 -07001260 // that's okay for the purposes of this test.
1261 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1262
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001263 // Composite the previous frame one more time, which helps verify
1264 // LastRefresh is updated properly.
1265 if (oldFrame != nullptr) {
1266 mCfeh->addPreComposition(nOldFrame,
1267 oldFrame->mRefreshes[2].kStartTime);
1268 gpuDoneFenceTime = gpuComposited ?
1269 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1270 FenceTime::NO_FENCE;
1271 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001272 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1273 oldFrame->mRefreshes[2].kCompositorTiming);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001274 }
1275
1276 // Latch the new frame.
Brian Anderson3da8d272016-07-28 16:20:47 -07001277 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1278
1279 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1280 gpuDoneFenceTime = gpuComposited ?
1281 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1282 FenceTime::NO_FENCE;
1283 // HWC2 releases the previous buffer after a new latch just before
Leon Scroggins III5b581492023-10-31 14:29:41 -04001284 // calling onCompositionPresented.
Brian Anderson3da8d272016-07-28 16:20:47 -07001285 if (oldFrame != nullptr) {
Brian Andersonf6386862016-10-31 16:34:13 -07001286 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
Brian Anderson3da8d272016-07-28 16:20:47 -07001287 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1288 }
1289 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001290 newFrame->mRefreshes[0].mPresent.mFenceTime,
1291 newFrame->mRefreshes[0].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001292
Brian Anderson3da8d272016-07-28 16:20:47 -07001293 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1294 gpuDoneFenceTime = gpuComposited ?
1295 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1296 FenceTime::NO_FENCE;
1297 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001298 newFrame->mRefreshes[1].mPresent.mFenceTime,
1299 newFrame->mRefreshes[1].kCompositorTiming);
Brian Anderson3da8d272016-07-28 16:20:47 -07001300 }
1301
Brian Anderson3da8d272016-07-28 16:20:47 -07001302 sp<IGraphicBufferProducer> mProducer;
1303 sp<IGraphicBufferConsumer> mConsumer;
1304 sp<FakeConsumer> mFakeConsumer;
1305 ConsumerFrameEventHistory* mCfeh;
1306 sp<TestSurface> mSurface;
1307 sp<ANativeWindow> mWindow;
1308
1309 FenceToFenceTimeMap mFenceMap;
1310
1311 bool mFrameTimestampsEnabled = false;
1312
1313 int64_t outRequestedPresentTime = -1;
1314 int64_t outAcquireTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001315 int64_t outLatchTime = -1;
1316 int64_t outFirstRefreshStartTime = -1;
1317 int64_t outLastRefreshStartTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001318 int64_t outGpuCompositionDoneTime = -1;
1319 int64_t outDisplayPresentTime = -1;
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001320 int64_t outDequeueReadyTime = -1;
Brian Anderson3da8d272016-07-28 16:20:47 -07001321 int64_t outReleaseTime = -1;
1322
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001323 FrameEvents mFrames[3] {
1324 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
Brian Anderson3da8d272016-07-28 16:20:47 -07001325};
1326
1327
1328// This test verifies that the frame timestamps are not retrieved when not
1329// explicitly enabled via native_window_enable_frame_timestamps.
1330// We want to check this to make sure there's no overhead for users
1331// that don't need the timestamp information.
1332TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1333 int fence;
1334 ANativeWindowBuffer* buffer;
1335
1336 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1337 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1338
Brian Anderson1049d1d2016-12-16 17:25:57 -08001339 const uint64_t fId = getNextFrameId();
1340
Brian Anderson3da8d272016-07-28 16:20:47 -07001341 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1342 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1343 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1344 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1345
1346 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1347 // It is okay that frame timestamps are added in the consumer since it is
1348 // still needed for SurfaceFlinger dumps.
1349 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1350 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1351 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1352
1353 // Verify attempts to get frame timestamps fail.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001354 int result = getAllFrameTimestamps(fId);
Brian Anderson3da8d272016-07-28 16:20:47 -07001355 EXPECT_EQ(INVALID_OPERATION, result);
1356 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001357
1358 // Verify compositor timing query fails.
1359 nsecs_t compositeDeadline = 0;
1360 nsecs_t compositeInterval = 0;
1361 nsecs_t compositeToPresentLatency = 0;
1362 result = native_window_get_compositor_timing(mWindow.get(),
1363 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1364 EXPECT_EQ(INVALID_OPERATION, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001365}
1366
1367// This test verifies that the frame timestamps are retrieved if explicitly
1368// enabled via native_window_enable_frame_timestamps.
1369TEST_F(GetFrameTimestampsTest, EnabledSimple) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001370 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001371 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1372
Brian Anderson3da8d272016-07-28 16:20:47 -07001373 enableFrameTimestamps();
1374
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001375 // Verify the compositor timing query gets the initial compositor values
1376 // after timststamps are enabled; even before the first frame is queued
1377 // or dequeued.
1378 nsecs_t compositeDeadline = 0;
1379 nsecs_t compositeInterval = 0;
1380 nsecs_t compositeToPresentLatency = 0;
1381 mSurface->setNow(initialCompositorTiming.deadline - 1);
1382 int result = native_window_get_compositor_timing(mWindow.get(),
1383 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1384 EXPECT_EQ(NO_ERROR, result);
1385 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1386 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1387 EXPECT_EQ(initialCompositorTiming.presentLatency,
1388 compositeToPresentLatency);
1389
Brian Anderson3da8d272016-07-28 16:20:47 -07001390 int fence;
1391 ANativeWindowBuffer* buffer;
1392
1393 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001394 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001395
Brian Anderson1049d1d2016-12-16 17:25:57 -08001396 const uint64_t fId1 = getNextFrameId();
1397
Brian Anderson3da8d272016-07-28 16:20:47 -07001398 // Verify getFrameTimestamps is piggybacked on dequeue.
1399 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1400 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001401 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001402
1403 NewFrameEventsEntry f1;
1404 f1.frameNumber = 1;
1405 f1.postedTime = mFrames[0].kPostedTime;
1406 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1407 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1408 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1409 mFrames[0].mAcquireProducer.mFenceTime,
1410 mFrames[0].mAcquireConsumer.mFenceTime);
1411 mFakeConsumer->mNewFrameEntryOverride = f1;
1412 mFrames[0].signalQueueFences();
1413
1414 // Verify getFrameTimestamps is piggybacked on queue.
1415 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1416 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1417 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001418 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001419
1420 // Verify queries for timestamps that the producer doesn't know about
1421 // triggers a call to see if the consumer has any new timestamps.
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001422 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001423 EXPECT_EQ(NO_ERROR, result);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001424 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
Brian Anderson3da8d272016-07-28 16:20:47 -07001425}
1426
Brian Anderson6b376712017-04-04 10:51:39 -07001427TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1428 bool displayPresentSupported = true;
1429 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001430 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001431
1432 // Verify supported bits are forwarded.
1433 int supportsPresent = -1;
1434 mWindow.get()->query(mWindow.get(),
1435 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1436 EXPECT_EQ(displayPresentSupported, supportsPresent);
1437}
1438
1439TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1440 bool displayPresentSupported = false;
1441 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
Huihong Luo0a81aa32022-02-22 16:02:36 -08001442 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
Brian Anderson6b376712017-04-04 10:51:39 -07001443
1444 // Verify supported bits are forwarded.
1445 int supportsPresent = -1;
1446 mWindow.get()->query(mWindow.get(),
1447 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1448 EXPECT_EQ(displayPresentSupported, supportsPresent);
1449}
1450
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001451TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1452 nsecs_t phase = 4000;
1453 nsecs_t interval = 1000;
1454
1455 // Timestamp in previous interval.
1456 nsecs_t timestamp = 3500;
1457 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1458 timestamp, phase, interval));
1459
1460 // Timestamp in next interval.
1461 timestamp = 4500;
1462 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1463 timestamp, phase, interval));
1464
1465 // Timestamp multiple intervals before.
1466 timestamp = 2500;
1467 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1468 timestamp, phase, interval));
1469
1470 // Timestamp multiple intervals after.
1471 timestamp = 6500;
1472 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1473 timestamp, phase, interval));
1474
1475 // Timestamp on previous interval.
1476 timestamp = 3000;
1477 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1478 timestamp, phase, interval));
1479
1480 // Timestamp on next interval.
1481 timestamp = 5000;
1482 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1483 timestamp, phase, interval));
1484
1485 // Timestamp equal to phase.
1486 timestamp = 4000;
1487 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1488 timestamp, phase, interval));
1489}
1490
1491// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1492// if the number of intervals elapsed is internally stored in an int.
1493TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1494 nsecs_t phase = 0;
1495 nsecs_t interval = 4000;
1496 nsecs_t big_timestamp = 8635916564000;
1497 int32_t intervals = big_timestamp / interval;
1498
1499 EXPECT_LT(intervals, 0);
1500 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1501 big_timestamp, phase, interval));
1502 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1503 big_timestamp, big_timestamp, interval));
1504}
1505
1506// This verifies the compositor timing is updated by refresh events
1507// and piggy backed on a queue, dequeue, and enabling of timestamps..
1508TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001509 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001510 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1511
1512 enableFrameTimestamps();
1513
1514 // We get the initial values before any frames are submitted.
1515 nsecs_t compositeDeadline = 0;
1516 nsecs_t compositeInterval = 0;
1517 nsecs_t compositeToPresentLatency = 0;
1518 mSurface->setNow(initialCompositorTiming.deadline - 1);
1519 int result = native_window_get_compositor_timing(mWindow.get(),
1520 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1521 EXPECT_EQ(NO_ERROR, result);
1522 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1523 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1524 EXPECT_EQ(initialCompositorTiming.presentLatency,
1525 compositeToPresentLatency);
1526
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001527 dequeueAndQueue(0);
1528 addFrameEvents(true, NO_FRAME_INDEX, 0);
1529
1530 // Still get the initial values because the frame events for frame 0
1531 // didn't get a chance to piggyback on a queue or dequeue yet.
1532 result = native_window_get_compositor_timing(mWindow.get(),
1533 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1534 EXPECT_EQ(NO_ERROR, result);
1535 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1536 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1537 EXPECT_EQ(initialCompositorTiming.presentLatency,
1538 compositeToPresentLatency);
1539
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001540 dequeueAndQueue(1);
1541 addFrameEvents(true, 0, 1);
1542
1543 // Now expect the composite values associated with frame 1.
1544 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1545 result = native_window_get_compositor_timing(mWindow.get(),
1546 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1547 EXPECT_EQ(NO_ERROR, result);
1548 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1549 compositeDeadline);
1550 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1551 compositeInterval);
1552 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1553 compositeToPresentLatency);
1554
1555 dequeueAndQueue(2);
1556 addFrameEvents(true, 1, 2);
1557
1558 // Now expect the composite values associated with frame 2.
1559 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1560 result = native_window_get_compositor_timing(mWindow.get(),
1561 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1562 EXPECT_EQ(NO_ERROR, result);
1563 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1564 compositeDeadline);
1565 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1566 compositeInterval);
1567 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1568 compositeToPresentLatency);
1569
1570 // Re-enabling frame timestamps should get the latest values.
1571 disableFrameTimestamps();
1572 enableFrameTimestamps();
1573
1574 // Now expect the composite values associated with frame 3.
1575 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1576 result = native_window_get_compositor_timing(mWindow.get(),
1577 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1578 EXPECT_EQ(NO_ERROR, result);
1579 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1580 compositeDeadline);
1581 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1582 compositeInterval);
1583 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1584 compositeToPresentLatency);
1585}
1586
1587// This verifies the compositor deadline properly snaps to the the next
1588// deadline based on the current time.
1589TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07001590 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001591 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1592
1593 enableFrameTimestamps();
1594
1595 nsecs_t compositeDeadline = 0;
1596 nsecs_t compositeInterval = 0;
1597 nsecs_t compositeToPresentLatency = 0;
1598
1599 // A "now" just before the deadline snaps to the deadline.
1600 mSurface->setNow(initialCompositorTiming.deadline - 1);
1601 int result = native_window_get_compositor_timing(mWindow.get(),
1602 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1603 EXPECT_EQ(NO_ERROR, result);
1604 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1605 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1606 EXPECT_EQ(expectedDeadline, compositeDeadline);
1607
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001608 dequeueAndQueue(0);
1609 addFrameEvents(true, NO_FRAME_INDEX, 0);
1610
1611 // A "now" just after the deadline snaps properly.
1612 mSurface->setNow(initialCompositorTiming.deadline + 1);
1613 result = native_window_get_compositor_timing(mWindow.get(),
1614 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1615 EXPECT_EQ(NO_ERROR, result);
1616 expectedDeadline =
1617 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1618 EXPECT_EQ(expectedDeadline, compositeDeadline);
1619
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001620 dequeueAndQueue(1);
1621 addFrameEvents(true, 0, 1);
1622
1623 // A "now" just after the next interval snaps properly.
1624 mSurface->setNow(
1625 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1626 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1627 result = native_window_get_compositor_timing(mWindow.get(),
1628 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1629 EXPECT_EQ(NO_ERROR, result);
1630 expectedDeadline =
1631 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1632 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1633 EXPECT_EQ(expectedDeadline, compositeDeadline);
1634
1635 dequeueAndQueue(2);
1636 addFrameEvents(true, 1, 2);
1637
1638 // A "now" over 1 interval before the deadline snaps properly.
1639 mSurface->setNow(
1640 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1641 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1642 result = native_window_get_compositor_timing(mWindow.get(),
1643 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1644 EXPECT_EQ(NO_ERROR, result);
1645 expectedDeadline =
1646 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1647 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1648 EXPECT_EQ(expectedDeadline, compositeDeadline);
1649
1650 // Re-enabling frame timestamps should get the latest values.
1651 disableFrameTimestamps();
1652 enableFrameTimestamps();
1653
1654 // A "now" over 2 intervals before the deadline snaps properly.
1655 mSurface->setNow(
1656 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1657 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1658 result = native_window_get_compositor_timing(mWindow.get(),
1659 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1660 EXPECT_EQ(NO_ERROR, result);
1661 expectedDeadline =
1662 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1663 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1664 EXPECT_EQ(expectedDeadline, compositeDeadline);
1665}
1666
Brian Anderson1049d1d2016-12-16 17:25:57 -08001667// This verifies the timestamps recorded in the consumer's
1668// FrameTimestampsHistory are properly retrieved by the producer for the
1669// correct frames.
Brian Anderson3da8d272016-07-28 16:20:47 -07001670TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1671 enableFrameTimestamps();
1672
Brian Anderson1049d1d2016-12-16 17:25:57 -08001673 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001674 dequeueAndQueue(0);
1675 mFrames[0].signalQueueFences();
1676
Brian Anderson1049d1d2016-12-16 17:25:57 -08001677 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001678 dequeueAndQueue(1);
1679 mFrames[1].signalQueueFences();
1680
1681 addFrameEvents(true, NO_FRAME_INDEX, 0);
1682 mFrames[0].signalRefreshFences();
1683 addFrameEvents(true, 0, 1);
1684 mFrames[0].signalReleaseFences();
1685 mFrames[1].signalRefreshFences();
1686
1687 // Verify timestamps are correct for frame 1.
Brian Anderson3da8d272016-07-28 16:20:47 -07001688 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001689 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001690 EXPECT_EQ(NO_ERROR, result);
1691 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1692 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001693 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1694 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1695 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001696 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1697 outGpuCompositionDoneTime);
1698 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001699 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001700 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1701
1702 // Verify timestamps are correct for frame 2.
Brian Anderson3da8d272016-07-28 16:20:47 -07001703 resetTimestamps();
Brian Anderson1049d1d2016-12-16 17:25:57 -08001704 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07001705 EXPECT_EQ(NO_ERROR, result);
1706 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1707 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001708 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1709 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1710 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001711 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1712 outGpuCompositionDoneTime);
1713 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001714 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1715 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001716}
1717
1718// This test verifies the acquire fence recorded by the consumer is not sent
1719// back to the producer and the producer saves its own fence.
1720TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1721 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001722
Brian Anderson3da8d272016-07-28 16:20:47 -07001723 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001724 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001725 dequeueAndQueue(0);
1726
1727 // Verify queue-related timestamps for f1 are available immediately in the
1728 // producer without asking the consumer again, even before signaling the
1729 // acquire fence.
1730 resetTimestamps();
1731 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001732 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001733 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001734 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001735 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1736 EXPECT_EQ(NO_ERROR, result);
1737 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001738 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001739
1740 // Signal acquire fences. Verify a sync call still isn't necessary.
1741 mFrames[0].signalQueueFences();
1742
1743 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001744 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
Brian Anderson3da8d272016-07-28 16:20:47 -07001745 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001746 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001747 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1748 EXPECT_EQ(NO_ERROR, result);
1749 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1750 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1751
1752 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001753 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001754 dequeueAndQueue(1);
1755
1756 // Verify queue-related timestamps for f2 are available immediately in the
1757 // producer without asking the consumer again, even before signaling the
1758 // acquire fence.
1759 resetTimestamps();
1760 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001761 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001762 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001763 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001764 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1765 EXPECT_EQ(NO_ERROR, result);
1766 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001767 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001768
1769 // Signal acquire fences. Verify a sync call still isn't necessary.
1770 mFrames[1].signalQueueFences();
1771
1772 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001773 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson3da8d272016-07-28 16:20:47 -07001774 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
Brian Anderson4e606e32017-03-16 15:34:57 -07001775 nullptr, nullptr, nullptr, nullptr, nullptr);
Brian Anderson3da8d272016-07-28 16:20:47 -07001776 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1777 EXPECT_EQ(NO_ERROR, result);
1778 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1779 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1780}
1781
1782TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1783 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001784
1785 // Dequeue and queue frame 1.
1786 dequeueAndQueue(0);
1787 mFrames[0].signalQueueFences();
1788
1789 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001790 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001791 dequeueAndQueue(1);
1792 mFrames[1].signalQueueFences();
1793
1794 addFrameEvents(true, NO_FRAME_INDEX, 0);
1795 mFrames[0].signalRefreshFences();
1796 addFrameEvents(true, 0, 1);
1797 mFrames[0].signalReleaseFences();
1798 mFrames[1].signalRefreshFences();
1799
1800 // Verify a request for no timestamps doesn't result in a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001801 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001802 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
Brian Anderson6b376712017-04-04 10:51:39 -07001803 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1804 nullptr, nullptr);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001805 EXPECT_EQ(NO_ERROR, result);
Brian Anderson3da8d272016-07-28 16:20:47 -07001806 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1807}
1808
1809// This test verifies that fences can signal and update timestamps producer
1810// side without an additional sync call to the consumer.
1811TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1812 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001813
1814 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001815 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001816 dequeueAndQueue(0);
1817 mFrames[0].signalQueueFences();
1818
1819 // Dequeue and queue frame 2.
1820 dequeueAndQueue(1);
1821 mFrames[1].signalQueueFences();
1822
1823 addFrameEvents(true, NO_FRAME_INDEX, 0);
1824 addFrameEvents(true, 0, 1);
1825
1826 // Verify available timestamps are correct for frame 1, before any
1827 // fence has been signaled.
1828 // Note: A sync call is necessary here since the events triggered by
1829 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07001830 resetTimestamps();
1831 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001832 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001833 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1834 EXPECT_EQ(NO_ERROR, result);
1835 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1836 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001837 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1838 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1839 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001840 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1841 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001842 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001843 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001844
1845 // Verify available timestamps are correct for frame 1 again, before any
1846 // fence has been signaled.
1847 // This time a sync call should not be necessary.
Brian Anderson3da8d272016-07-28 16:20:47 -07001848 resetTimestamps();
1849 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001850 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001851 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1852 EXPECT_EQ(NO_ERROR, result);
1853 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1854 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001855 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1856 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1857 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001858 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1859 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001860 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001861 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001862
1863 // Signal the fences for frame 1.
1864 mFrames[0].signalRefreshFences();
1865 mFrames[0].signalReleaseFences();
1866
1867 // Verify all timestamps are available without a sync call.
Brian Anderson3da8d272016-07-28 16:20:47 -07001868 resetTimestamps();
1869 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001870 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001871 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1872 EXPECT_EQ(NO_ERROR, result);
1873 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1874 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001875 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1876 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1877 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001878 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1879 outGpuCompositionDoneTime);
1880 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001881 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001882 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1883}
1884
1885// This test verifies that if the frame wasn't GPU composited but has a refresh
1886// event a sync call isn't made to get the GPU composite done time since it will
1887// never exist.
1888TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1889 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001890
Brian Anderson3da8d272016-07-28 16:20:47 -07001891 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001892 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001893 dequeueAndQueue(0);
1894 mFrames[0].signalQueueFences();
1895
1896 // Dequeue and queue frame 2.
1897 dequeueAndQueue(1);
1898 mFrames[1].signalQueueFences();
1899
1900 addFrameEvents(false, NO_FRAME_INDEX, 0);
1901 addFrameEvents(false, 0, 1);
1902
1903 // Verify available timestamps are correct for frame 1, before any
1904 // fence has been signaled.
1905 // Note: A sync call is necessary here since the events triggered by
1906 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1907 resetTimestamps();
1908 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001909 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001910 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1911 EXPECT_EQ(NO_ERROR, result);
1912 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1913 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001914 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1915 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1916 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001917 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1918 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001919 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001920 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001921
1922 // Signal the fences for frame 1.
1923 mFrames[0].signalRefreshFences();
1924 mFrames[0].signalReleaseFences();
1925
1926 // Verify all timestamps, except GPU composition, are available without a
1927 // sync call.
1928 resetTimestamps();
1929 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001930 result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001931 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1932 EXPECT_EQ(NO_ERROR, result);
1933 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1934 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001935 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1936 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1937 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001938 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001939 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001940 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001941 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1942}
1943
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001944// This test verifies that if the certain timestamps can't possibly exist for
1945// the most recent frame, then a sync call is not done.
Brian Anderson6b376712017-04-04 10:51:39 -07001946TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001947 enableFrameTimestamps();
Brian Anderson3da8d272016-07-28 16:20:47 -07001948
1949 // Dequeue and queue frame 1.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001950 const uint64_t fId1 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001951 dequeueAndQueue(0);
1952 mFrames[0].signalQueueFences();
1953
1954 // Dequeue and queue frame 2.
Brian Anderson1049d1d2016-12-16 17:25:57 -08001955 const uint64_t fId2 = getNextFrameId();
Brian Anderson3da8d272016-07-28 16:20:47 -07001956 dequeueAndQueue(1);
1957 mFrames[1].signalQueueFences();
1958
1959 addFrameEvents(false, NO_FRAME_INDEX, 0);
1960 addFrameEvents(false, 0, 1);
1961
1962 // Verify available timestamps are correct for frame 1, before any
1963 // fence has been signaled.
1964 // Note: A sync call is necessary here since the events triggered by
1965 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
Brian Anderson3da8d272016-07-28 16:20:47 -07001966 resetTimestamps();
1967 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001968 int result = getAllFrameTimestamps(fId1);
Brian Anderson3da8d272016-07-28 16:20:47 -07001969 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1970 EXPECT_EQ(NO_ERROR, result);
1971 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1972 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001973 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1974 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1975 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001976 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1977 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001978 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07001979 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07001980
1981 mFrames[0].signalRefreshFences();
1982 mFrames[0].signalReleaseFences();
1983 mFrames[1].signalRefreshFences();
1984
Brian Anderson1049d1d2016-12-16 17:25:57 -08001985 // Verify querying for all timestmaps of f2 does not do a sync call. Even
Brian Anderson4e606e32017-03-16 15:34:57 -07001986 // though the lastRefresh, dequeueReady, and release times aren't
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001987 // available, a sync call should not occur because it's not possible for f2
1988 // to encounter the final value for those events until another frame is
1989 // queued.
Brian Anderson3da8d272016-07-28 16:20:47 -07001990 resetTimestamps();
1991 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001992 result = getAllFrameTimestamps(fId2);
Brian Anderson3da8d272016-07-28 16:20:47 -07001993 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1994 EXPECT_EQ(NO_ERROR, result);
1995 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1996 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001997 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1998 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1999 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002000 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002001 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
Brian Andersondc96fdf2017-03-20 16:54:25 -07002002 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
2003 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
Brian Anderson3da8d272016-07-28 16:20:47 -07002004}
2005
Brian Anderson6b376712017-04-04 10:51:39 -07002006// This test verifies there are no sync calls for present times
2007// when they aren't supported and that an error is returned.
2008
2009TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
2010 enableFrameTimestamps();
2011 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
Huihong Luo0a81aa32022-02-22 16:02:36 -08002012 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(false);
Brian Anderson6b376712017-04-04 10:51:39 -07002013
2014 // Dequeue and queue frame 1.
2015 const uint64_t fId1 = getNextFrameId();
2016 dequeueAndQueue(0);
2017
2018 // Verify a query for the Present times do not trigger a sync call if they
2019 // are not supported.
2020 resetTimestamps();
2021 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2022 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
2023 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
2024 &outDisplayPresentTime, nullptr, nullptr);
2025 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2026 EXPECT_EQ(BAD_VALUE, result);
2027 EXPECT_EQ(-1, outDisplayPresentTime);
2028}
2029
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002030TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
2031 sp<IGraphicBufferProducer> producer;
2032 sp<IGraphicBufferConsumer> consumer;
2033 BufferQueue::createBufferQueue(&producer, &consumer);
2034
Peiyong Lind8460c82020-07-28 16:04:22 -07002035 sp<MockConsumer> mockConsumer(new MockConsumer);
2036 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002037 consumer->setDefaultBufferSize(10, 10);
2038
2039 sp<Surface> surface = new Surface(producer);
2040 sp<ANativeWindow> window(surface);
Nolan Scobie9c427942023-05-01 16:41:28 -04002041 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2042 ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(window.get(), 0, 0));
2043 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002044
2045 int fence;
2046 ANativeWindowBuffer* buffer;
2047
2048 // Buffer size is driven by the consumer
2049 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2050 EXPECT_EQ(10, buffer->width);
2051 EXPECT_EQ(10, buffer->height);
2052 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2053
2054 // Buffer size is driven by the consumer
2055 consumer->setDefaultBufferSize(10, 20);
2056 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2057 EXPECT_EQ(10, buffer->width);
2058 EXPECT_EQ(20, buffer->height);
2059 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2060
2061 // Transform hint isn't synced to producer before queueBuffer or connect
2062 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2063 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2064 EXPECT_EQ(10, buffer->width);
2065 EXPECT_EQ(20, buffer->height);
2066 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2067
2068 // Transform hint is synced to producer but no auto prerotation
2069 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2070 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2071 EXPECT_EQ(10, buffer->width);
2072 EXPECT_EQ(20, buffer->height);
2073 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2074
2075 // Prerotation is driven by the consumer with the transform hint used by producer
2076 native_window_set_auto_prerotation(window.get(), true);
2077 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2078 EXPECT_EQ(20, buffer->width);
2079 EXPECT_EQ(10, buffer->height);
2080 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2081
2082 // Turn off auto prerotaton
2083 native_window_set_auto_prerotation(window.get(), false);
2084 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2085 EXPECT_EQ(10, buffer->width);
2086 EXPECT_EQ(20, buffer->height);
2087 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2088
2089 // Test auto prerotation bit is disabled after disconnect
2090 native_window_set_auto_prerotation(window.get(), true);
2091 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2092 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2093 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2094 native_window_set_buffers_dimensions(window.get(), 0, 0);
Nolan Scobie9c427942023-05-01 16:41:28 -04002095 native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS);
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002096 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2097 EXPECT_EQ(10, buffer->width);
2098 EXPECT_EQ(20, buffer->height);
2099 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2100}
2101
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002102TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2103 sp<IGraphicBufferProducer> producer;
2104 sp<IGraphicBufferConsumer> consumer;
2105 BufferQueue::createBufferQueue(&producer, &consumer);
2106
Peiyong Lind8460c82020-07-28 16:04:22 -07002107 sp<MockConsumer> mockConsumer(new MockConsumer);
2108 consumer->consumerConnect(mockConsumer, false);
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07002109
2110 sp<Surface> surface = new Surface(producer);
2111 sp<ANativeWindow> window(surface);
2112
2113 int count = -1;
2114 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2115 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2116
2117 consumer->setMaxBufferCount(10);
2118 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2119 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2120 EXPECT_EQ(10, count);
2121
2122 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2123 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2124 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2125}
2126
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08002127TEST_F(SurfaceTest, BatchOperations) {
2128 const int BUFFER_COUNT = 16;
2129 const int BATCH_SIZE = 8;
2130 sp<IGraphicBufferProducer> producer;
2131 sp<IGraphicBufferConsumer> consumer;
2132 BufferQueue::createBufferQueue(&producer, &consumer);
2133
2134 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2135 sp<Surface> surface = new Surface(producer);
2136 sp<ANativeWindow> window(surface);
2137 sp<StubProducerListener> listener = new StubProducerListener();
2138
2139 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2140 /*reportBufferRemoval*/false));
2141
2142 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2143
2144 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2145
2146 // Batch dequeued buffers can be queued individually
2147 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2148 for (size_t i = 0; i < BATCH_SIZE; i++) {
2149 ANativeWindowBuffer* buffer = buffers[i].buffer;
2150 int fence = buffers[i].fenceFd;
2151 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2152 }
2153
2154 // Batch dequeued buffers can be canceled individually
2155 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2156 for (size_t i = 0; i < BATCH_SIZE; i++) {
2157 ANativeWindowBuffer* buffer = buffers[i].buffer;
2158 int fence = buffers[i].fenceFd;
2159 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2160 }
2161
2162 // Batch dequeued buffers can be batch cancelled
2163 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2164 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2165
2166 // Batch dequeued buffers can be batch queued
2167 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2168 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2169 for (size_t i = 0; i < BATCH_SIZE; i++) {
2170 queuedBuffers[i].buffer = buffers[i].buffer;
2171 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2172 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2173 }
2174 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2175
2176 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2177}
2178
2179TEST_F(SurfaceTest, BatchIllegalOperations) {
2180 const int BUFFER_COUNT = 16;
2181 const int BATCH_SIZE = 8;
2182 sp<IGraphicBufferProducer> producer;
2183 sp<IGraphicBufferConsumer> consumer;
2184 BufferQueue::createBufferQueue(&producer, &consumer);
2185
2186 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2187 sp<Surface> surface = new Surface(producer);
2188 sp<ANativeWindow> window(surface);
2189 sp<StubProducerListener> listener = new StubProducerListener();
2190
2191 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2192 /*reportBufferRemoval*/false));
2193
2194 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2195
2196 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2197 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2198
2199 // Batch operations are invalid in shared buffer mode
2200 surface->setSharedBufferMode(true);
2201 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2202 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2203 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2204 surface->setSharedBufferMode(false);
2205
2206 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2207}
2208
Dan Stoza932f0082017-05-31 13:50:16 -07002209} // namespace android