1 /*
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
17 #include "DummyConsumer.h"
18
19 #include <gtest/gtest.h>
20
21 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
22 #include <binder/ProcessState.h>
23 #include <configstore/Utils.h>
24 #include <cutils/properties.h>
25 #include <gui/BufferItemConsumer.h>
26 #include <gui/IDisplayEventConnection.h>
27 #include <gui/IProducerListener.h>
28 #include <gui/ISurfaceComposer.h>
29 #include <gui/Surface.h>
30 #include <gui/SurfaceComposerClient.h>
31 #include <private/gui/ComposerService.h>
32 #include <ui/Rect.h>
33 #include <utils/String8.h>
34
35 #include <limits>
36 #include <thread>
37
38 namespace android {
39
40 using namespace std::chrono_literals;
41 // retrieve wide-color and hdr settings from configstore
42 using namespace android::hardware::configstore;
43 using namespace android::hardware::configstore::V1_0;
44
45 static bool hasWideColorDisplay =
46 getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
47
48 class FakeSurfaceComposer;
49 class FakeProducerFrameEventHistory;
50
51 static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
52
53 class SurfaceTest : public ::testing::Test {
54 protected:
55
SurfaceTest()56 SurfaceTest() {
57 ProcessState::self()->startThreadPool();
58 }
59
SetUp()60 virtual void SetUp() {
61 mComposerClient = new SurfaceComposerClient;
62 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
63
64 // TODO(brianderson): The following sometimes fails and is a source of
65 // test flakiness.
66 mSurfaceControl = mComposerClient->createSurface(
67 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
68
69 ASSERT_TRUE(mSurfaceControl != NULL);
70 ASSERT_TRUE(mSurfaceControl->isValid());
71
72 SurfaceComposerClient::openGlobalTransaction();
73 ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff));
74 ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
75 SurfaceComposerClient::closeGlobalTransaction();
76
77 mSurface = mSurfaceControl->getSurface();
78 ASSERT_TRUE(mSurface != NULL);
79 }
80
TearDown()81 virtual void TearDown() {
82 mComposerClient->dispose();
83 }
84
85 sp<Surface> mSurface;
86 sp<SurfaceComposerClient> mComposerClient;
87 sp<SurfaceControl> mSurfaceControl;
88 };
89
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenVisible)90 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
91 sp<ANativeWindow> anw(mSurface);
92 int result = -123;
93 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
94 &result);
95 EXPECT_EQ(NO_ERROR, err);
96 EXPECT_EQ(1, result);
97 }
98
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenPurgatorized)99 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
100 mSurfaceControl.clear();
101 // Wait for the async clean-up to complete.
102 std::this_thread::sleep_for(50ms);
103
104 sp<ANativeWindow> anw(mSurface);
105 int result = -123;
106 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
107 &result);
108 EXPECT_EQ(NO_ERROR, err);
109 EXPECT_EQ(1, result);
110 }
111
112 // This test probably doesn't belong here.
TEST_F(SurfaceTest,ScreenshotsOfProtectedBuffersSucceed)113 TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) {
114 sp<ANativeWindow> anw(mSurface);
115
116 // Verify the screenshot works with no protected buffers.
117 sp<IGraphicBufferProducer> producer;
118 sp<IGraphicBufferConsumer> consumer;
119 BufferQueue::createBufferQueue(&producer, &consumer);
120 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
121 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
122 sp<IBinder> display(sf->getBuiltInDisplay(
123 ISurfaceComposer::eDisplayIdMain));
124 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
125 64, 64, 0, 0x7fffffff, false));
126
127 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
128 NATIVE_WINDOW_API_CPU));
129 // Set the PROTECTED usage bit and verify that the screenshot fails. Note
130 // that we need to dequeue a buffer in order for it to actually get
131 // allocated in SurfaceFlinger.
132 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
133 GRALLOC_USAGE_PROTECTED));
134 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
135 ANativeWindowBuffer* buf = 0;
136
137 status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
138 if (err) {
139 // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
140 // that's okay as long as this is the reason for the failure.
141 // try again without the GRALLOC_USAGE_PROTECTED bit.
142 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
143 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
144 &buf));
145 return;
146 }
147 ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
148
149 for (int i = 0; i < 4; i++) {
150 // Loop to make sure SurfaceFlinger has retired a protected buffer.
151 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
152 &buf));
153 ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
154 }
155 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
156 64, 64, 0, 0x7fffffff, false));
157 }
158
TEST_F(SurfaceTest,ConcreteTypeIsSurface)159 TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
160 sp<ANativeWindow> anw(mSurface);
161 int result = -123;
162 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
163 EXPECT_EQ(NO_ERROR, err);
164 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
165 }
166
TEST_F(SurfaceTest,LayerCountIsOne)167 TEST_F(SurfaceTest, LayerCountIsOne) {
168 sp<ANativeWindow> anw(mSurface);
169 int result = -123;
170 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
171 EXPECT_EQ(NO_ERROR, err);
172 EXPECT_EQ(1, result);
173 }
174
TEST_F(SurfaceTest,QueryConsumerUsage)175 TEST_F(SurfaceTest, QueryConsumerUsage) {
176 const int TEST_USAGE_FLAGS =
177 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
178 sp<IGraphicBufferProducer> producer;
179 sp<IGraphicBufferConsumer> consumer;
180 BufferQueue::createBufferQueue(&producer, &consumer);
181 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
182 TEST_USAGE_FLAGS);
183 sp<Surface> s = new Surface(producer);
184
185 sp<ANativeWindow> anw(s);
186
187 int flags = -1;
188 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
189
190 ASSERT_EQ(NO_ERROR, err);
191 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
192 }
193
TEST_F(SurfaceTest,QueryDefaultBuffersDataSpace)194 TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
195 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB;
196 sp<IGraphicBufferProducer> producer;
197 sp<IGraphicBufferConsumer> consumer;
198 BufferQueue::createBufferQueue(&producer, &consumer);
199 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
200
201 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
202
203 sp<Surface> s = new Surface(producer);
204
205 sp<ANativeWindow> anw(s);
206
207 android_dataspace dataSpace;
208
209 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
210 reinterpret_cast<int*>(&dataSpace));
211
212 ASSERT_EQ(NO_ERROR, err);
213 ASSERT_EQ(TEST_DATASPACE, dataSpace);
214 }
215
TEST_F(SurfaceTest,SettingGenerationNumber)216 TEST_F(SurfaceTest, SettingGenerationNumber) {
217 sp<IGraphicBufferProducer> producer;
218 sp<IGraphicBufferConsumer> consumer;
219 BufferQueue::createBufferQueue(&producer, &consumer);
220 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
221 sp<Surface> surface = new Surface(producer);
222 sp<ANativeWindow> window(surface);
223
224 // Allocate a buffer with a generation number of 0
225 ANativeWindowBuffer* buffer;
226 int fenceFd;
227 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
228 NATIVE_WINDOW_API_CPU));
229 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
230 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
231
232 // Detach the buffer and check its generation number
233 sp<GraphicBuffer> graphicBuffer;
234 sp<Fence> fence;
235 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
236 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
237
238 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
239 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
240
241 // This should change the generation number of the GraphicBuffer
242 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
243
244 // Check that the new generation number sticks with the buffer
245 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
246 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
247 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
248 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
249 }
250
TEST_F(SurfaceTest,GetConsumerName)251 TEST_F(SurfaceTest, GetConsumerName) {
252 sp<IGraphicBufferProducer> producer;
253 sp<IGraphicBufferConsumer> consumer;
254 BufferQueue::createBufferQueue(&producer, &consumer);
255
256 sp<DummyConsumer> dummyConsumer(new DummyConsumer);
257 consumer->consumerConnect(dummyConsumer, false);
258 consumer->setConsumerName(String8("TestConsumer"));
259
260 sp<Surface> surface = new Surface(producer);
261 sp<ANativeWindow> window(surface);
262 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
263
264 EXPECT_STREQ("TestConsumer", surface->getConsumerName().string());
265 }
266
TEST_F(SurfaceTest,GetWideColorSupport)267 TEST_F(SurfaceTest, GetWideColorSupport) {
268 sp<IGraphicBufferProducer> producer;
269 sp<IGraphicBufferConsumer> consumer;
270 BufferQueue::createBufferQueue(&producer, &consumer);
271
272 sp<DummyConsumer> dummyConsumer(new DummyConsumer);
273 consumer->consumerConnect(dummyConsumer, false);
274 consumer->setConsumerName(String8("TestConsumer"));
275
276 sp<Surface> surface = new Surface(producer);
277 sp<ANativeWindow> window(surface);
278 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
279
280 bool supported;
281 surface->getWideColorSupport(&supported);
282
283 // NOTE: This test assumes that device that supports
284 // wide-color (as indicated by BoardConfig) must also
285 // have a wide-color primary display.
286 // That assumption allows this test to cover devices
287 // that advertised a wide-color color mode without
288 // actually supporting wide-color to pass this test
289 // as well as the case of a device that does support
290 // wide-color (via BoardConfig) and has a wide-color
291 // primary display.
292 // NOT covered at this time is a device that supports
293 // wide color in the BoardConfig but does not support
294 // a wide-color color mode on the primary display.
295 ASSERT_EQ(hasWideColorDisplay, supported);
296 }
297
TEST_F(SurfaceTest,DynamicSetBufferCount)298 TEST_F(SurfaceTest, DynamicSetBufferCount) {
299 sp<IGraphicBufferProducer> producer;
300 sp<IGraphicBufferConsumer> consumer;
301 BufferQueue::createBufferQueue(&producer, &consumer);
302
303 sp<DummyConsumer> dummyConsumer(new DummyConsumer);
304 consumer->consumerConnect(dummyConsumer, false);
305 consumer->setConsumerName(String8("TestConsumer"));
306
307 sp<Surface> surface = new Surface(producer);
308 sp<ANativeWindow> window(surface);
309
310 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
311 NATIVE_WINDOW_API_CPU));
312 native_window_set_buffer_count(window.get(), 4);
313
314 int fence;
315 ANativeWindowBuffer* buffer;
316 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
317 native_window_set_buffer_count(window.get(), 3);
318 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
319 native_window_set_buffer_count(window.get(), 2);
320 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
321 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
322 }
323
TEST_F(SurfaceTest,GetAndFlushRemovedBuffers)324 TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
325 sp<IGraphicBufferProducer> producer;
326 sp<IGraphicBufferConsumer> consumer;
327 BufferQueue::createBufferQueue(&producer, &consumer);
328
329 sp<DummyConsumer> dummyConsumer(new DummyConsumer);
330 consumer->consumerConnect(dummyConsumer, false);
331 consumer->setConsumerName(String8("TestConsumer"));
332
333 sp<Surface> surface = new Surface(producer);
334 sp<ANativeWindow> window(surface);
335 sp<DummyProducerListener> listener = new DummyProducerListener();
336 ASSERT_EQ(OK, surface->connect(
337 NATIVE_WINDOW_API_CPU,
338 /*listener*/listener,
339 /*reportBufferRemoval*/true));
340 const int BUFFER_COUNT = 4;
341 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
342
343 sp<GraphicBuffer> detachedBuffer;
344 sp<Fence> outFence;
345 int fences[BUFFER_COUNT];
346 ANativeWindowBuffer* buffers[BUFFER_COUNT];
347 // Allocate buffers because detachNextBuffer requires allocated buffers
348 for (int i = 0; i < BUFFER_COUNT; i++) {
349 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
350 }
351 for (int i = 0; i < BUFFER_COUNT; i++) {
352 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
353 }
354
355 // Test detached buffer is correctly reported
356 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
357 std::vector<sp<GraphicBuffer>> removedBuffers;
358 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
359 ASSERT_EQ(1u, removedBuffers.size());
360 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
361 // Test the list is flushed one getAndFlushRemovedBuffers returns
362 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
363 ASSERT_EQ(0u, removedBuffers.size());
364
365
366 // Test removed buffer list is cleanup after next dequeueBuffer call
367 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
368 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
369 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
370 ASSERT_EQ(0u, removedBuffers.size());
371 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
372
373 // Test removed buffer list is cleanup after next detachNextBuffer call
374 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
375 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
376 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
377 ASSERT_EQ(1u, removedBuffers.size());
378 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
379
380 // Re-allocate buffers since all buffers are detached up to now
381 for (int i = 0; i < BUFFER_COUNT; i++) {
382 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
383 }
384 for (int i = 0; i < BUFFER_COUNT; i++) {
385 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
386 }
387
388 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
389 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
390 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
391 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
392 // get 0 or 1 buffer removed.
393 ASSERT_LE(removedBuffers.size(), 1u);
394 }
395
TEST_F(SurfaceTest,TestGetLastDequeueStartTime)396 TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
397 sp<ANativeWindow> anw(mSurface);
398 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
399
400 ANativeWindowBuffer* buffer = nullptr;
401 int32_t fenceFd = -1;
402
403 nsecs_t before = systemTime(CLOCK_MONOTONIC);
404 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
405 nsecs_t after = systemTime(CLOCK_MONOTONIC);
406
407 nsecs_t lastDequeueTime = mSurface->getLastDequeueStartTime();
408 ASSERT_LE(before, lastDequeueTime);
409 ASSERT_GE(after, lastDequeueTime);
410 }
411
412 class FakeConsumer : public BnConsumerListener {
413 public:
onFrameAvailable(const BufferItem &)414 void onFrameAvailable(const BufferItem& /*item*/) override {}
onBuffersReleased()415 void onBuffersReleased() override {}
onSidebandStreamChanged()416 void onSidebandStreamChanged() override {}
417
addAndGetFrameTimestamps(const NewFrameEventsEntry * newTimestamps,FrameEventHistoryDelta * outDelta)418 void addAndGetFrameTimestamps(
419 const NewFrameEventsEntry* newTimestamps,
420 FrameEventHistoryDelta* outDelta) override {
421 if (newTimestamps) {
422 if (mGetFrameTimestampsEnabled) {
423 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
424 "Test should set mNewFrameEntryOverride before queuing "
425 "a frame.";
426 EXPECT_EQ(newTimestamps->frameNumber,
427 mNewFrameEntryOverride.frameNumber) <<
428 "Test attempting to add NewFrameEntryOverride with "
429 "incorrect frame number.";
430 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
431 mNewFrameEntryOverride.frameNumber = 0;
432 }
433 mAddFrameTimestampsCount++;
434 mLastAddedFrameNumber = newTimestamps->frameNumber;
435 }
436 if (outDelta) {
437 mFrameEventHistory.getAndResetDelta(outDelta);
438 mGetFrameTimestampsCount++;
439 }
440 mAddAndGetFrameTimestampsCallCount++;
441 }
442
443 bool mGetFrameTimestampsEnabled = false;
444
445 ConsumerFrameEventHistory mFrameEventHistory;
446 int mAddAndGetFrameTimestampsCallCount = 0;
447 int mAddFrameTimestampsCount = 0;
448 int mGetFrameTimestampsCount = 0;
449 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
450
451 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
452 };
453
454
455 class FakeSurfaceComposer : public ISurfaceComposer{
456 public:
~FakeSurfaceComposer()457 ~FakeSurfaceComposer() override {}
458
setSupportsPresent(bool supportsPresent)459 void setSupportsPresent(bool supportsPresent) {
460 mSupportsPresent = supportsPresent;
461 }
462
createConnection()463 sp<ISurfaceComposerClient> createConnection() override { return nullptr; }
createScopedConnection(const sp<IGraphicBufferProducer> &)464 sp<ISurfaceComposerClient> createScopedConnection(
465 const sp<IGraphicBufferProducer>& /* parent */) override {
466 return nullptr;
467 }
createDisplayEventConnection(ISurfaceComposer::VsyncSource)468 sp<IDisplayEventConnection> createDisplayEventConnection(ISurfaceComposer::VsyncSource)
469 override {
470 return nullptr;
471 }
createDisplay(const String8 &,bool)472 sp<IBinder> createDisplay(const String8& /*displayName*/,
473 bool /*secure*/) override { return nullptr; }
destroyDisplay(const sp<IBinder> &)474 void destroyDisplay(const sp<IBinder>& /*display */) override {}
getBuiltInDisplay(int32_t)475 sp<IBinder> getBuiltInDisplay(int32_t /*id*/) override { return nullptr; }
setTransactionState(const Vector<ComposerState> &,const Vector<DisplayState> &,uint32_t)476 void setTransactionState(const Vector<ComposerState>& /*state*/,
477 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/)
478 override {}
bootFinished()479 void bootFinished() override {}
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> &) const480 bool authenticateSurfaceTexture(
481 const sp<IGraphicBufferProducer>& /*surface*/) const override {
482 return false;
483 }
484
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported) const485 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported)
486 const override {
487 *outSupported = {
488 FrameEvent::REQUESTED_PRESENT,
489 FrameEvent::ACQUIRE,
490 FrameEvent::LATCH,
491 FrameEvent::FIRST_REFRESH_START,
492 FrameEvent::LAST_REFRESH_START,
493 FrameEvent::GPU_COMPOSITION_DONE,
494 FrameEvent::DEQUEUE_READY,
495 FrameEvent::RELEASE
496 };
497 if (mSupportsPresent) {
498 outSupported->push_back(
499 FrameEvent::DISPLAY_PRESENT);
500 }
501 return NO_ERROR;
502 }
503
setPowerMode(const sp<IBinder> &,int)504 void setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {}
getDisplayConfigs(const sp<IBinder> &,Vector<DisplayInfo> *)505 status_t getDisplayConfigs(const sp<IBinder>& /*display*/,
506 Vector<DisplayInfo>* /*configs*/) override { return NO_ERROR; }
getDisplayStats(const sp<IBinder> &,DisplayStatInfo *)507 status_t getDisplayStats(const sp<IBinder>& /*display*/,
508 DisplayStatInfo* /*stats*/) override { return NO_ERROR; }
getActiveConfig(const sp<IBinder> &)509 int getActiveConfig(const sp<IBinder>& /*display*/) override { return 0; }
setActiveConfig(const sp<IBinder> &,int)510 status_t setActiveConfig(const sp<IBinder>& /*display*/, int /*id*/)
511 override {
512 return NO_ERROR;
513 }
getDisplayColorModes(const sp<IBinder> &,Vector<android_color_mode_t> *)514 status_t getDisplayColorModes(const sp<IBinder>& /*display*/,
515 Vector<android_color_mode_t>* /*outColorModes*/) override {
516 return NO_ERROR;
517 }
getActiveColorMode(const sp<IBinder> &)518 android_color_mode_t getActiveColorMode(const sp<IBinder>& /*display*/)
519 override {
520 return HAL_COLOR_MODE_NATIVE;
521 }
setActiveColorMode(const sp<IBinder> &,android_color_mode_t)522 status_t setActiveColorMode(const sp<IBinder>& /*display*/,
523 android_color_mode_t /*colorMode*/) override { return NO_ERROR; }
captureScreen(const sp<IBinder> &,const sp<IGraphicBufferProducer> &,Rect,uint32_t,uint32_t,int32_t,int32_t,bool,Rotation)524 status_t captureScreen(const sp<IBinder>& /*display*/,
525 const sp<IGraphicBufferProducer>& /*producer*/,
526 Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/,
527 int32_t /*minLayerZ*/, int32_t /*maxLayerZ*/,
528 bool /*useIdentityTransform*/,
529 Rotation /*rotation*/) override { return NO_ERROR; }
clearAnimationFrameStats()530 status_t clearAnimationFrameStats() override { return NO_ERROR; }
getAnimationFrameStats(FrameStats *) const531 status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override {
532 return NO_ERROR;
533 }
getHdrCapabilities(const sp<IBinder> &,HdrCapabilities *) const534 status_t getHdrCapabilities(const sp<IBinder>& /*display*/,
535 HdrCapabilities* /*outCapabilities*/) const override {
536 return NO_ERROR;
537 }
enableVSyncInjections(bool)538 status_t enableVSyncInjections(bool /*enable*/) override {
539 return NO_ERROR;
540 }
injectVSync(nsecs_t)541 status_t injectVSync(nsecs_t /*when*/) override { return NO_ERROR; }
542
543 protected:
onAsBinder()544 IBinder* onAsBinder() override { return nullptr; }
545
546 private:
547 bool mSupportsPresent{true};
548 };
549
550 class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
551 public:
FakeProducerFrameEventHistory(FenceToFenceTimeMap * fenceMap)552 FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap)
553 : mFenceMap(fenceMap) {}
554
~FakeProducerFrameEventHistory()555 ~FakeProducerFrameEventHistory() {}
556
updateAcquireFence(uint64_t frameNumber,std::shared_ptr<FenceTime> && acquire)557 void updateAcquireFence(uint64_t frameNumber,
558 std::shared_ptr<FenceTime>&& acquire) override {
559 // Verify the acquire fence being added isn't the one from the consumer.
560 EXPECT_NE(mConsumerAcquireFence, acquire);
561 // Override the fence, so we can verify this was called by the
562 // producer after the frame is queued.
563 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
564 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
565 }
566
setAcquireFenceOverride(const std::shared_ptr<FenceTime> & acquireFenceOverride,const std::shared_ptr<FenceTime> & consumerAcquireFence)567 void setAcquireFenceOverride(
568 const std::shared_ptr<FenceTime>& acquireFenceOverride,
569 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
570 mAcquireFenceOverride = acquireFenceOverride;
571 mConsumerAcquireFence = consumerAcquireFence;
572 }
573
574 protected:
createFenceTime(const sp<Fence> & fence) const575 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
576 const override {
577 return mFenceMap->createFenceTimeForTest(fence);
578 }
579
580 FenceToFenceTimeMap* mFenceMap{nullptr};
581
582 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
583 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
584 };
585
586
587 class TestSurface : public Surface {
588 public:
TestSurface(const sp<IGraphicBufferProducer> & bufferProducer,FenceToFenceTimeMap * fenceMap)589 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer,
590 FenceToFenceTimeMap* fenceMap)
591 : Surface(bufferProducer),
592 mFakeSurfaceComposer(new FakeSurfaceComposer) {
593 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
594 mFrameEventHistory.reset(mFakeFrameEventHistory);
595 }
596
~TestSurface()597 ~TestSurface() override {}
598
composerService() const599 sp<ISurfaceComposer> composerService() const override {
600 return mFakeSurfaceComposer;
601 }
602
now() const603 nsecs_t now() const override {
604 return mNow;
605 }
606
setNow(nsecs_t now)607 void setNow(nsecs_t now) {
608 mNow = now;
609 }
610
611 public:
612 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
613 nsecs_t mNow = 0;
614
615 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
616 // but this raw pointer gives access to test functionality.
617 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
618 };
619
620
621 class GetFrameTimestampsTest : public ::testing::Test {
622 protected:
623 struct FenceAndFenceTime {
FenceAndFenceTimeandroid::GetFrameTimestampsTest::FenceAndFenceTime624 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
625 : mFence(new Fence),
626 mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
627 sp<Fence> mFence { nullptr };
628 std::shared_ptr<FenceTime> mFenceTime { nullptr };
629 };
630
631 struct RefreshEvents {
RefreshEventsandroid::GetFrameTimestampsTest::RefreshEvents632 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
633 : mFenceMap(fenceMap),
634 kCompositorTiming(
635 {refreshStart, refreshStart + 1, refreshStart + 2 }),
636 kStartTime(refreshStart + 3),
637 kGpuCompositionDoneTime(refreshStart + 4),
638 kPresentTime(refreshStart + 5) {}
639
signalPostCompositeFencesandroid::GetFrameTimestampsTest::RefreshEvents640 void signalPostCompositeFences() {
641 mFenceMap.signalAllForTest(
642 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
643 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
644 }
645
646 FenceToFenceTimeMap& mFenceMap;
647
648 FenceAndFenceTime mGpuCompositionDone { mFenceMap };
649 FenceAndFenceTime mPresent { mFenceMap };
650
651 const CompositorTiming kCompositorTiming;
652
653 const nsecs_t kStartTime;
654 const nsecs_t kGpuCompositionDoneTime;
655 const nsecs_t kPresentTime;
656 };
657
658 struct FrameEvents {
FrameEventsandroid::GetFrameTimestampsTest::FrameEvents659 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
660 : mFenceMap(fenceMap),
661 kPostedTime(frameStartTime + 100),
662 kRequestedPresentTime(frameStartTime + 200),
663 kProducerAcquireTime(frameStartTime + 300),
664 kConsumerAcquireTime(frameStartTime + 301),
665 kLatchTime(frameStartTime + 500),
666 kDequeueReadyTime(frameStartTime + 600),
667 kReleaseTime(frameStartTime + 700),
668 mRefreshes {
669 { mFenceMap, frameStartTime + 410 },
670 { mFenceMap, frameStartTime + 420 },
671 { mFenceMap, frameStartTime + 430 } } {}
672
signalQueueFencesandroid::GetFrameTimestampsTest::FrameEvents673 void signalQueueFences() {
674 mFenceMap.signalAllForTest(
675 mAcquireConsumer.mFence, kConsumerAcquireTime);
676 mFenceMap.signalAllForTest(
677 mAcquireProducer.mFence, kProducerAcquireTime);
678 }
679
signalRefreshFencesandroid::GetFrameTimestampsTest::FrameEvents680 void signalRefreshFences() {
681 for (auto& re : mRefreshes) {
682 re.signalPostCompositeFences();
683 }
684 }
685
signalReleaseFencesandroid::GetFrameTimestampsTest::FrameEvents686 void signalReleaseFences() {
687 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
688 }
689
690 FenceToFenceTimeMap& mFenceMap;
691
692 FenceAndFenceTime mAcquireConsumer { mFenceMap };
693 FenceAndFenceTime mAcquireProducer { mFenceMap };
694 FenceAndFenceTime mRelease { mFenceMap };
695
696 const nsecs_t kPostedTime;
697 const nsecs_t kRequestedPresentTime;
698 const nsecs_t kProducerAcquireTime;
699 const nsecs_t kConsumerAcquireTime;
700 const nsecs_t kLatchTime;
701 const nsecs_t kDequeueReadyTime;
702 const nsecs_t kReleaseTime;
703
704 RefreshEvents mRefreshes[3];
705 };
706
GetFrameTimestampsTest()707 GetFrameTimestampsTest() {}
708
SetUp()709 virtual void SetUp() {
710 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
711 mFakeConsumer = new FakeConsumer;
712 mCfeh = &mFakeConsumer->mFrameEventHistory;
713 mConsumer->consumerConnect(mFakeConsumer, false);
714 mConsumer->setConsumerName(String8("TestConsumer"));
715 mSurface = new TestSurface(mProducer, &mFenceMap);
716 mWindow = mSurface;
717
718 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
719 NATIVE_WINDOW_API_CPU));
720 native_window_set_buffer_count(mWindow.get(), 4);
721 }
722
disableFrameTimestamps()723 void disableFrameTimestamps() {
724 mFakeConsumer->mGetFrameTimestampsEnabled = false;
725 native_window_enable_frame_timestamps(mWindow.get(), 0);
726 mFrameTimestampsEnabled = false;
727 }
728
enableFrameTimestamps()729 void enableFrameTimestamps() {
730 mFakeConsumer->mGetFrameTimestampsEnabled = true;
731 native_window_enable_frame_timestamps(mWindow.get(), 1);
732 mFrameTimestampsEnabled = true;
733 }
734
getAllFrameTimestamps(uint64_t frameId)735 int getAllFrameTimestamps(uint64_t frameId) {
736 return native_window_get_frame_timestamps(mWindow.get(), frameId,
737 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
738 &outFirstRefreshStartTime, &outLastRefreshStartTime,
739 &outGpuCompositionDoneTime, &outDisplayPresentTime,
740 &outDequeueReadyTime, &outReleaseTime);
741 }
742
resetTimestamps()743 void resetTimestamps() {
744 outRequestedPresentTime = -1;
745 outAcquireTime = -1;
746 outLatchTime = -1;
747 outFirstRefreshStartTime = -1;
748 outLastRefreshStartTime = -1;
749 outGpuCompositionDoneTime = -1;
750 outDisplayPresentTime = -1;
751 outDequeueReadyTime = -1;
752 outReleaseTime = -1;
753 }
754
getNextFrameId()755 uint64_t getNextFrameId() {
756 uint64_t frameId = -1;
757 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
758 EXPECT_EQ(status, NO_ERROR);
759 return frameId;
760 }
761
dequeueAndQueue(uint64_t frameIndex)762 void dequeueAndQueue(uint64_t frameIndex) {
763 int fence = -1;
764 ANativeWindowBuffer* buffer = nullptr;
765 ASSERT_EQ(NO_ERROR,
766 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
767
768 int oldAddFrameTimestampsCount =
769 mFakeConsumer->mAddFrameTimestampsCount;
770
771 FrameEvents* frame = &mFrames[frameIndex];
772 uint64_t frameNumber = frameIndex + 1;
773
774 NewFrameEventsEntry fe;
775 fe.frameNumber = frameNumber;
776 fe.postedTime = frame->kPostedTime;
777 fe.requestedPresentTime = frame->kRequestedPresentTime;
778 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
779 mFakeConsumer->mNewFrameEntryOverride = fe;
780
781 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
782 frame->mAcquireProducer.mFenceTime,
783 frame->mAcquireConsumer.mFenceTime);
784
785 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
786
787 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
788
789 EXPECT_EQ(
790 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
791 mFakeConsumer->mAddFrameTimestampsCount);
792 }
793
addFrameEvents(bool gpuComposited,uint64_t iOldFrame,int64_t iNewFrame)794 void addFrameEvents(
795 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
796 FrameEvents* oldFrame =
797 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
798 FrameEvents* newFrame = &mFrames[iNewFrame];
799
800 uint64_t nOldFrame = iOldFrame + 1;
801 uint64_t nNewFrame = iNewFrame + 1;
802
803 // Latch, Composite, and Release the frames in a plausible order.
804 // Note: The timestamps won't necessarily match the order, but
805 // that's okay for the purposes of this test.
806 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
807
808 // Composite the previous frame one more time, which helps verify
809 // LastRefresh is updated properly.
810 if (oldFrame != nullptr) {
811 mCfeh->addPreComposition(nOldFrame,
812 oldFrame->mRefreshes[2].kStartTime);
813 gpuDoneFenceTime = gpuComposited ?
814 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
815 FenceTime::NO_FENCE;
816 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
817 oldFrame->mRefreshes[2].mPresent.mFenceTime,
818 oldFrame->mRefreshes[2].kCompositorTiming);
819 }
820
821 // Latch the new frame.
822 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
823
824 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
825 gpuDoneFenceTime = gpuComposited ?
826 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
827 FenceTime::NO_FENCE;
828 // HWC2 releases the previous buffer after a new latch just before
829 // calling postComposition.
830 if (oldFrame != nullptr) {
831 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
832 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
833 }
834 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
835 newFrame->mRefreshes[0].mPresent.mFenceTime,
836 newFrame->mRefreshes[0].kCompositorTiming);
837
838 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
839 gpuDoneFenceTime = gpuComposited ?
840 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
841 FenceTime::NO_FENCE;
842 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
843 newFrame->mRefreshes[1].mPresent.mFenceTime,
844 newFrame->mRefreshes[1].kCompositorTiming);
845 }
846
847 sp<IGraphicBufferProducer> mProducer;
848 sp<IGraphicBufferConsumer> mConsumer;
849 sp<FakeConsumer> mFakeConsumer;
850 ConsumerFrameEventHistory* mCfeh;
851 sp<TestSurface> mSurface;
852 sp<ANativeWindow> mWindow;
853
854 FenceToFenceTimeMap mFenceMap;
855
856 bool mFrameTimestampsEnabled = false;
857
858 int64_t outRequestedPresentTime = -1;
859 int64_t outAcquireTime = -1;
860 int64_t outLatchTime = -1;
861 int64_t outFirstRefreshStartTime = -1;
862 int64_t outLastRefreshStartTime = -1;
863 int64_t outGpuCompositionDoneTime = -1;
864 int64_t outDisplayPresentTime = -1;
865 int64_t outDequeueReadyTime = -1;
866 int64_t outReleaseTime = -1;
867
868 FrameEvents mFrames[3] {
869 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
870 };
871
872
873 // This test verifies that the frame timestamps are not retrieved when not
874 // explicitly enabled via native_window_enable_frame_timestamps.
875 // We want to check this to make sure there's no overhead for users
876 // that don't need the timestamp information.
TEST_F(GetFrameTimestampsTest,DefaultDisabled)877 TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
878 int fence;
879 ANativeWindowBuffer* buffer;
880
881 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
882 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
883
884 const uint64_t fId = getNextFrameId();
885
886 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
887 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
888 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
889 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
890
891 // Verify the producer doesn't get frame timestamps piggybacked on queue.
892 // It is okay that frame timestamps are added in the consumer since it is
893 // still needed for SurfaceFlinger dumps.
894 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
895 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
896 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
897
898 // Verify attempts to get frame timestamps fail.
899 int result = getAllFrameTimestamps(fId);
900 EXPECT_EQ(INVALID_OPERATION, result);
901 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
902
903 // Verify compositor timing query fails.
904 nsecs_t compositeDeadline = 0;
905 nsecs_t compositeInterval = 0;
906 nsecs_t compositeToPresentLatency = 0;
907 result = native_window_get_compositor_timing(mWindow.get(),
908 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
909 EXPECT_EQ(INVALID_OPERATION, result);
910 }
911
912 // This test verifies that the frame timestamps are retrieved if explicitly
913 // enabled via native_window_enable_frame_timestamps.
TEST_F(GetFrameTimestampsTest,EnabledSimple)914 TEST_F(GetFrameTimestampsTest, EnabledSimple) {
915 CompositorTiming initialCompositorTiming {
916 1000000000, // 1s deadline
917 16666667, // 16ms interval
918 50000000, // 50ms present latency
919 };
920 mCfeh->initializeCompositorTiming(initialCompositorTiming);
921
922 enableFrameTimestamps();
923
924 // Verify the compositor timing query gets the initial compositor values
925 // after timststamps are enabled; even before the first frame is queued
926 // or dequeued.
927 nsecs_t compositeDeadline = 0;
928 nsecs_t compositeInterval = 0;
929 nsecs_t compositeToPresentLatency = 0;
930 mSurface->setNow(initialCompositorTiming.deadline - 1);
931 int result = native_window_get_compositor_timing(mWindow.get(),
932 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
933 EXPECT_EQ(NO_ERROR, result);
934 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
935 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
936 EXPECT_EQ(initialCompositorTiming.presentLatency,
937 compositeToPresentLatency);
938
939 int fence;
940 ANativeWindowBuffer* buffer;
941
942 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
943 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
944
945 const uint64_t fId1 = getNextFrameId();
946
947 // Verify getFrameTimestamps is piggybacked on dequeue.
948 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
949 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
950 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
951
952 NewFrameEventsEntry f1;
953 f1.frameNumber = 1;
954 f1.postedTime = mFrames[0].kPostedTime;
955 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
956 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
957 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
958 mFrames[0].mAcquireProducer.mFenceTime,
959 mFrames[0].mAcquireConsumer.mFenceTime);
960 mFakeConsumer->mNewFrameEntryOverride = f1;
961 mFrames[0].signalQueueFences();
962
963 // Verify getFrameTimestamps is piggybacked on queue.
964 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
965 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
966 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
967 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
968
969 // Verify queries for timestamps that the producer doesn't know about
970 // triggers a call to see if the consumer has any new timestamps.
971 result = getAllFrameTimestamps(fId1);
972 EXPECT_EQ(NO_ERROR, result);
973 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
974 }
975
TEST_F(GetFrameTimestampsTest,QueryPresentSupported)976 TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
977 bool displayPresentSupported = true;
978 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
979
980 // Verify supported bits are forwarded.
981 int supportsPresent = -1;
982 mWindow.get()->query(mWindow.get(),
983 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
984 EXPECT_EQ(displayPresentSupported, supportsPresent);
985 }
986
TEST_F(GetFrameTimestampsTest,QueryPresentNotSupported)987 TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
988 bool displayPresentSupported = false;
989 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
990
991 // Verify supported bits are forwarded.
992 int supportsPresent = -1;
993 mWindow.get()->query(mWindow.get(),
994 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
995 EXPECT_EQ(displayPresentSupported, supportsPresent);
996 }
997
TEST_F(GetFrameTimestampsTest,SnapToNextTickBasic)998 TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
999 nsecs_t phase = 4000;
1000 nsecs_t interval = 1000;
1001
1002 // Timestamp in previous interval.
1003 nsecs_t timestamp = 3500;
1004 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1005 timestamp, phase, interval));
1006
1007 // Timestamp in next interval.
1008 timestamp = 4500;
1009 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1010 timestamp, phase, interval));
1011
1012 // Timestamp multiple intervals before.
1013 timestamp = 2500;
1014 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1015 timestamp, phase, interval));
1016
1017 // Timestamp multiple intervals after.
1018 timestamp = 6500;
1019 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1020 timestamp, phase, interval));
1021
1022 // Timestamp on previous interval.
1023 timestamp = 3000;
1024 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1025 timestamp, phase, interval));
1026
1027 // Timestamp on next interval.
1028 timestamp = 5000;
1029 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1030 timestamp, phase, interval));
1031
1032 // Timestamp equal to phase.
1033 timestamp = 4000;
1034 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1035 timestamp, phase, interval));
1036 }
1037
1038 // int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1039 // if the number of intervals elapsed is internally stored in an int.
TEST_F(GetFrameTimestampsTest,SnapToNextTickOverflow)1040 TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1041 nsecs_t phase = 0;
1042 nsecs_t interval = 4000;
1043 nsecs_t big_timestamp = 8635916564000;
1044 int32_t intervals = big_timestamp / interval;
1045
1046 EXPECT_LT(intervals, 0);
1047 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1048 big_timestamp, phase, interval));
1049 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1050 big_timestamp, big_timestamp, interval));
1051 }
1052
1053 // This verifies the compositor timing is updated by refresh events
1054 // and piggy backed on a queue, dequeue, and enabling of timestamps..
TEST_F(GetFrameTimestampsTest,CompositorTimingUpdatesBasic)1055 TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
1056 CompositorTiming initialCompositorTiming {
1057 1000000000, // 1s deadline
1058 16666667, // 16ms interval
1059 50000000, // 50ms present latency
1060 };
1061 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1062
1063 enableFrameTimestamps();
1064
1065 // We get the initial values before any frames are submitted.
1066 nsecs_t compositeDeadline = 0;
1067 nsecs_t compositeInterval = 0;
1068 nsecs_t compositeToPresentLatency = 0;
1069 mSurface->setNow(initialCompositorTiming.deadline - 1);
1070 int result = native_window_get_compositor_timing(mWindow.get(),
1071 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1072 EXPECT_EQ(NO_ERROR, result);
1073 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1074 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1075 EXPECT_EQ(initialCompositorTiming.presentLatency,
1076 compositeToPresentLatency);
1077
1078 const uint64_t fId1 = getNextFrameId();
1079 dequeueAndQueue(0);
1080 addFrameEvents(true, NO_FRAME_INDEX, 0);
1081
1082 // Still get the initial values because the frame events for frame 0
1083 // didn't get a chance to piggyback on a queue or dequeue yet.
1084 result = native_window_get_compositor_timing(mWindow.get(),
1085 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1086 EXPECT_EQ(NO_ERROR, result);
1087 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1088 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1089 EXPECT_EQ(initialCompositorTiming.presentLatency,
1090 compositeToPresentLatency);
1091
1092 const uint64_t fId2 = getNextFrameId();
1093 dequeueAndQueue(1);
1094 addFrameEvents(true, 0, 1);
1095
1096 // Now expect the composite values associated with frame 1.
1097 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1098 result = native_window_get_compositor_timing(mWindow.get(),
1099 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1100 EXPECT_EQ(NO_ERROR, result);
1101 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1102 compositeDeadline);
1103 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1104 compositeInterval);
1105 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1106 compositeToPresentLatency);
1107
1108 dequeueAndQueue(2);
1109 addFrameEvents(true, 1, 2);
1110
1111 // Now expect the composite values associated with frame 2.
1112 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1113 result = native_window_get_compositor_timing(mWindow.get(),
1114 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1115 EXPECT_EQ(NO_ERROR, result);
1116 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1117 compositeDeadline);
1118 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1119 compositeInterval);
1120 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1121 compositeToPresentLatency);
1122
1123 // Re-enabling frame timestamps should get the latest values.
1124 disableFrameTimestamps();
1125 enableFrameTimestamps();
1126
1127 // Now expect the composite values associated with frame 3.
1128 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1129 result = native_window_get_compositor_timing(mWindow.get(),
1130 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1131 EXPECT_EQ(NO_ERROR, result);
1132 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1133 compositeDeadline);
1134 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1135 compositeInterval);
1136 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1137 compositeToPresentLatency);
1138 }
1139
1140 // This verifies the compositor deadline properly snaps to the the next
1141 // deadline based on the current time.
TEST_F(GetFrameTimestampsTest,CompositorTimingDeadlineSnaps)1142 TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
1143 CompositorTiming initialCompositorTiming {
1144 1000000000, // 1s deadline
1145 16666667, // 16ms interval
1146 50000000, // 50ms present latency
1147 };
1148 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1149
1150 enableFrameTimestamps();
1151
1152 nsecs_t compositeDeadline = 0;
1153 nsecs_t compositeInterval = 0;
1154 nsecs_t compositeToPresentLatency = 0;
1155
1156 // A "now" just before the deadline snaps to the deadline.
1157 mSurface->setNow(initialCompositorTiming.deadline - 1);
1158 int result = native_window_get_compositor_timing(mWindow.get(),
1159 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1160 EXPECT_EQ(NO_ERROR, result);
1161 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1162 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1163 EXPECT_EQ(expectedDeadline, compositeDeadline);
1164
1165 const uint64_t fId1 = getNextFrameId();
1166 dequeueAndQueue(0);
1167 addFrameEvents(true, NO_FRAME_INDEX, 0);
1168
1169 // A "now" just after the deadline snaps properly.
1170 mSurface->setNow(initialCompositorTiming.deadline + 1);
1171 result = native_window_get_compositor_timing(mWindow.get(),
1172 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1173 EXPECT_EQ(NO_ERROR, result);
1174 expectedDeadline =
1175 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1176 EXPECT_EQ(expectedDeadline, compositeDeadline);
1177
1178 const uint64_t fId2 = getNextFrameId();
1179 dequeueAndQueue(1);
1180 addFrameEvents(true, 0, 1);
1181
1182 // A "now" just after the next interval snaps properly.
1183 mSurface->setNow(
1184 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1185 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1186 result = native_window_get_compositor_timing(mWindow.get(),
1187 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1188 EXPECT_EQ(NO_ERROR, result);
1189 expectedDeadline =
1190 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1191 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1192 EXPECT_EQ(expectedDeadline, compositeDeadline);
1193
1194 dequeueAndQueue(2);
1195 addFrameEvents(true, 1, 2);
1196
1197 // A "now" over 1 interval before the deadline snaps properly.
1198 mSurface->setNow(
1199 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1200 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1201 result = native_window_get_compositor_timing(mWindow.get(),
1202 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1203 EXPECT_EQ(NO_ERROR, result);
1204 expectedDeadline =
1205 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1206 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1207 EXPECT_EQ(expectedDeadline, compositeDeadline);
1208
1209 // Re-enabling frame timestamps should get the latest values.
1210 disableFrameTimestamps();
1211 enableFrameTimestamps();
1212
1213 // A "now" over 2 intervals before the deadline snaps properly.
1214 mSurface->setNow(
1215 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1216 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1217 result = native_window_get_compositor_timing(mWindow.get(),
1218 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1219 EXPECT_EQ(NO_ERROR, result);
1220 expectedDeadline =
1221 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1222 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1223 EXPECT_EQ(expectedDeadline, compositeDeadline);
1224 }
1225
1226 // This verifies the timestamps recorded in the consumer's
1227 // FrameTimestampsHistory are properly retrieved by the producer for the
1228 // correct frames.
TEST_F(GetFrameTimestampsTest,TimestampsAssociatedWithCorrectFrame)1229 TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1230 enableFrameTimestamps();
1231
1232 const uint64_t fId1 = getNextFrameId();
1233 dequeueAndQueue(0);
1234 mFrames[0].signalQueueFences();
1235
1236 const uint64_t fId2 = getNextFrameId();
1237 dequeueAndQueue(1);
1238 mFrames[1].signalQueueFences();
1239
1240 addFrameEvents(true, NO_FRAME_INDEX, 0);
1241 mFrames[0].signalRefreshFences();
1242 addFrameEvents(true, 0, 1);
1243 mFrames[0].signalReleaseFences();
1244 mFrames[1].signalRefreshFences();
1245
1246 // Verify timestamps are correct for frame 1.
1247 resetTimestamps();
1248 int result = getAllFrameTimestamps(fId1);
1249 EXPECT_EQ(NO_ERROR, result);
1250 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1251 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1252 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1253 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1254 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1255 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1256 outGpuCompositionDoneTime);
1257 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1258 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1259 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1260
1261 // Verify timestamps are correct for frame 2.
1262 resetTimestamps();
1263 result = getAllFrameTimestamps(fId2);
1264 EXPECT_EQ(NO_ERROR, result);
1265 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1266 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1267 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1268 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1269 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1270 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1271 outGpuCompositionDoneTime);
1272 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1273 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1274 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1275 }
1276
1277 // This test verifies the acquire fence recorded by the consumer is not sent
1278 // back to the producer and the producer saves its own fence.
TEST_F(GetFrameTimestampsTest,QueueTimestampsNoSync)1279 TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1280 enableFrameTimestamps();
1281
1282 // Dequeue and queue frame 1.
1283 const uint64_t fId1 = getNextFrameId();
1284 dequeueAndQueue(0);
1285
1286 // Verify queue-related timestamps for f1 are available immediately in the
1287 // producer without asking the consumer again, even before signaling the
1288 // acquire fence.
1289 resetTimestamps();
1290 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1291 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1292 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1293 nullptr, nullptr, nullptr, nullptr, nullptr);
1294 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1295 EXPECT_EQ(NO_ERROR, result);
1296 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1297 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1298
1299 // Signal acquire fences. Verify a sync call still isn't necessary.
1300 mFrames[0].signalQueueFences();
1301
1302 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1303 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1304 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1305 nullptr, nullptr, nullptr, nullptr, nullptr);
1306 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1307 EXPECT_EQ(NO_ERROR, result);
1308 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1309 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1310
1311 // Dequeue and queue frame 2.
1312 const uint64_t fId2 = getNextFrameId();
1313 dequeueAndQueue(1);
1314
1315 // Verify queue-related timestamps for f2 are available immediately in the
1316 // producer without asking the consumer again, even before signaling the
1317 // acquire fence.
1318 resetTimestamps();
1319 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1320 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1321 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1322 nullptr, nullptr, nullptr, nullptr, nullptr);
1323 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1324 EXPECT_EQ(NO_ERROR, result);
1325 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1326 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1327
1328 // Signal acquire fences. Verify a sync call still isn't necessary.
1329 mFrames[1].signalQueueFences();
1330
1331 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1332 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1333 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1334 nullptr, nullptr, nullptr, nullptr, nullptr);
1335 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1336 EXPECT_EQ(NO_ERROR, result);
1337 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1338 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1339 }
1340
TEST_F(GetFrameTimestampsTest,ZeroRequestedTimestampsNoSync)1341 TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1342 enableFrameTimestamps();
1343
1344 // Dequeue and queue frame 1.
1345 dequeueAndQueue(0);
1346 mFrames[0].signalQueueFences();
1347
1348 // Dequeue and queue frame 2.
1349 const uint64_t fId2 = getNextFrameId();
1350 dequeueAndQueue(1);
1351 mFrames[1].signalQueueFences();
1352
1353 addFrameEvents(true, NO_FRAME_INDEX, 0);
1354 mFrames[0].signalRefreshFences();
1355 addFrameEvents(true, 0, 1);
1356 mFrames[0].signalReleaseFences();
1357 mFrames[1].signalRefreshFences();
1358
1359 // Verify a request for no timestamps doesn't result in a sync call.
1360 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1361 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1362 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1363 nullptr, nullptr);
1364 EXPECT_EQ(NO_ERROR, result);
1365 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1366 }
1367
1368 // This test verifies that fences can signal and update timestamps producer
1369 // side without an additional sync call to the consumer.
TEST_F(GetFrameTimestampsTest,FencesInProducerNoSync)1370 TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1371 enableFrameTimestamps();
1372
1373 // Dequeue and queue frame 1.
1374 const uint64_t fId1 = getNextFrameId();
1375 dequeueAndQueue(0);
1376 mFrames[0].signalQueueFences();
1377
1378 // Dequeue and queue frame 2.
1379 dequeueAndQueue(1);
1380 mFrames[1].signalQueueFences();
1381
1382 addFrameEvents(true, NO_FRAME_INDEX, 0);
1383 addFrameEvents(true, 0, 1);
1384
1385 // Verify available timestamps are correct for frame 1, before any
1386 // fence has been signaled.
1387 // Note: A sync call is necessary here since the events triggered by
1388 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1389 resetTimestamps();
1390 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1391 int result = getAllFrameTimestamps(fId1);
1392 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1393 EXPECT_EQ(NO_ERROR, result);
1394 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1395 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1396 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1397 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1398 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1399 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1400 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1401 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1402 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1403
1404 // Verify available timestamps are correct for frame 1 again, before any
1405 // fence has been signaled.
1406 // This time a sync call should not be necessary.
1407 resetTimestamps();
1408 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1409 result = getAllFrameTimestamps(fId1);
1410 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1411 EXPECT_EQ(NO_ERROR, result);
1412 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1413 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1414 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1415 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1416 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1417 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1418 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1419 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1420 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1421
1422 // Signal the fences for frame 1.
1423 mFrames[0].signalRefreshFences();
1424 mFrames[0].signalReleaseFences();
1425
1426 // Verify all timestamps are available without a sync call.
1427 resetTimestamps();
1428 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1429 result = getAllFrameTimestamps(fId1);
1430 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1431 EXPECT_EQ(NO_ERROR, result);
1432 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1433 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1434 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1435 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1436 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1437 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1438 outGpuCompositionDoneTime);
1439 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1440 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1441 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1442 }
1443
1444 // This test verifies that if the frame wasn't GPU composited but has a refresh
1445 // event a sync call isn't made to get the GPU composite done time since it will
1446 // never exist.
TEST_F(GetFrameTimestampsTest,NoGpuNoSync)1447 TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1448 enableFrameTimestamps();
1449
1450 // Dequeue and queue frame 1.
1451 const uint64_t fId1 = getNextFrameId();
1452 dequeueAndQueue(0);
1453 mFrames[0].signalQueueFences();
1454
1455 // Dequeue and queue frame 2.
1456 dequeueAndQueue(1);
1457 mFrames[1].signalQueueFences();
1458
1459 addFrameEvents(false, NO_FRAME_INDEX, 0);
1460 addFrameEvents(false, 0, 1);
1461
1462 // Verify available timestamps are correct for frame 1, before any
1463 // fence has been signaled.
1464 // Note: A sync call is necessary here since the events triggered by
1465 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1466 resetTimestamps();
1467 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1468 int result = getAllFrameTimestamps(fId1);
1469 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1470 EXPECT_EQ(NO_ERROR, result);
1471 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1472 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1473 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1474 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1475 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1476 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1477 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1478 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1479 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1480
1481 // Signal the fences for frame 1.
1482 mFrames[0].signalRefreshFences();
1483 mFrames[0].signalReleaseFences();
1484
1485 // Verify all timestamps, except GPU composition, are available without a
1486 // sync call.
1487 resetTimestamps();
1488 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1489 result = getAllFrameTimestamps(fId1);
1490 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1491 EXPECT_EQ(NO_ERROR, result);
1492 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1493 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1494 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1495 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1496 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1497 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1498 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1499 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1500 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1501 }
1502
1503 // This test verifies that if the certain timestamps can't possibly exist for
1504 // the most recent frame, then a sync call is not done.
TEST_F(GetFrameTimestampsTest,NoReleaseNoSync)1505 TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
1506 enableFrameTimestamps();
1507
1508 // Dequeue and queue frame 1.
1509 const uint64_t fId1 = getNextFrameId();
1510 dequeueAndQueue(0);
1511 mFrames[0].signalQueueFences();
1512
1513 // Dequeue and queue frame 2.
1514 const uint64_t fId2 = getNextFrameId();
1515 dequeueAndQueue(1);
1516 mFrames[1].signalQueueFences();
1517
1518 addFrameEvents(false, NO_FRAME_INDEX, 0);
1519 addFrameEvents(false, 0, 1);
1520
1521 // Verify available timestamps are correct for frame 1, before any
1522 // fence has been signaled.
1523 // Note: A sync call is necessary here since the events triggered by
1524 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1525 resetTimestamps();
1526 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1527 int result = getAllFrameTimestamps(fId1);
1528 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1529 EXPECT_EQ(NO_ERROR, result);
1530 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1531 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1532 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1533 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1534 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1535 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1536 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1537 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1538 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1539
1540 mFrames[0].signalRefreshFences();
1541 mFrames[0].signalReleaseFences();
1542 mFrames[1].signalRefreshFences();
1543
1544 // Verify querying for all timestmaps of f2 does not do a sync call. Even
1545 // though the lastRefresh, dequeueReady, and release times aren't
1546 // available, a sync call should not occur because it's not possible for f2
1547 // to encounter the final value for those events until another frame is
1548 // queued.
1549 resetTimestamps();
1550 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1551 result = getAllFrameTimestamps(fId2);
1552 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1553 EXPECT_EQ(NO_ERROR, result);
1554 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1555 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1556 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1557 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1558 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1559 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1560 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1561 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1562 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1563 }
1564
1565 // This test verifies there are no sync calls for present times
1566 // when they aren't supported and that an error is returned.
1567
TEST_F(GetFrameTimestampsTest,PresentUnsupportedNoSync)1568 TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
1569 enableFrameTimestamps();
1570 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
1571
1572 // Dequeue and queue frame 1.
1573 const uint64_t fId1 = getNextFrameId();
1574 dequeueAndQueue(0);
1575
1576 // Verify a query for the Present times do not trigger a sync call if they
1577 // are not supported.
1578 resetTimestamps();
1579 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1580 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1581 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1582 &outDisplayPresentTime, nullptr, nullptr);
1583 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1584 EXPECT_EQ(BAD_VALUE, result);
1585 EXPECT_EQ(-1, outDisplayPresentTime);
1586 }
1587
1588 } // namespace android
1589