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 "MockConsumer.h"
18
19 #include <gtest/gtest.h>
20
21 #include <SurfaceFlingerProperties.h>
22 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
23 #include <binder/ProcessState.h>
24 #include <configstore/Utils.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 <gui/SyncScreenCaptureListener.h>
32 #include <inttypes.h>
33 #include <private/gui/ComposerService.h>
34 #include <ui/BufferQueueDefs.h>
35 #include <ui/DisplayMode.h>
36 #include <ui/Rect.h>
37 #include <utils/String8.h>
38
39 #include <limits>
40 #include <thread>
41
42 namespace android {
43
44 using namespace std::chrono_literals;
45 // retrieve wide-color and hdr settings from configstore
46 using namespace android::hardware::configstore;
47 using namespace android::hardware::configstore::V1_0;
48 using ui::ColorMode;
49
50 using Transaction = SurfaceComposerClient::Transaction;
51
52 static bool hasWideColorDisplay = android::sysprop::has_wide_color_display(false);
53
54 static bool hasHdrDisplay = android::sysprop::has_HDR_display(false);
55
56 class FakeSurfaceComposer;
57 class FakeProducerFrameEventHistory;
58
59 static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
60
61 class FakeSurfaceListener : public SurfaceListener {
62 public:
FakeSurfaceListener(bool enableReleasedCb=false)63 FakeSurfaceListener(bool enableReleasedCb = false)
64 : mEnableReleaseCb(enableReleasedCb), mBuffersReleased(0) {}
65 virtual ~FakeSurfaceListener() = default;
66
onBufferReleased()67 virtual void onBufferReleased() {
68 mBuffersReleased++;
69 }
needsReleaseNotify()70 virtual bool needsReleaseNotify() {
71 return mEnableReleaseCb;
72 }
onBuffersDiscarded(const std::vector<sp<GraphicBuffer>> & buffers)73 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers) {
74 mDiscardedBuffers.insert(mDiscardedBuffers.end(), buffers.begin(), buffers.end());
75 }
76
getReleaseNotifyCount() const77 int getReleaseNotifyCount() const {
78 return mBuffersReleased;
79 }
getDiscardedBuffers() const80 const std::vector<sp<GraphicBuffer>>& getDiscardedBuffers() const {
81 return mDiscardedBuffers;
82 }
83 private:
84 // No need to use lock given the test triggers the listener in the same
85 // thread context.
86 bool mEnableReleaseCb;
87 int32_t mBuffersReleased;
88 std::vector<sp<GraphicBuffer>> mDiscardedBuffers;
89 };
90
91 class SurfaceTest : public ::testing::Test {
92 protected:
SurfaceTest()93 SurfaceTest() {
94 ProcessState::self()->startThreadPool();
95 }
96
SetUp()97 virtual void SetUp() {
98 mComposerClient = new SurfaceComposerClient;
99 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
100
101 // TODO(brianderson): The following sometimes fails and is a source of
102 // test flakiness.
103 mSurfaceControl = mComposerClient->createSurface(
104 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
105 SurfaceComposerClient::Transaction().apply(true);
106
107 ASSERT_TRUE(mSurfaceControl != nullptr);
108 ASSERT_TRUE(mSurfaceControl->isValid());
109
110 Transaction t;
111 ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff).show(mSurfaceControl).apply());
112
113 mSurface = mSurfaceControl->getSurface();
114 ASSERT_TRUE(mSurface != nullptr);
115 }
116
TearDown()117 virtual void TearDown() {
118 mComposerClient->dispose();
119 }
120
testSurfaceListener(bool hasSurfaceListener,bool enableReleasedCb,int32_t extraDiscardedBuffers)121 void testSurfaceListener(bool hasSurfaceListener, bool enableReleasedCb,
122 int32_t extraDiscardedBuffers) {
123 sp<IGraphicBufferProducer> producer;
124 sp<IGraphicBufferConsumer> consumer;
125 BufferQueue::createBufferQueue(&producer, &consumer);
126
127 sp<MockConsumer> mockConsumer(new MockConsumer);
128 consumer->consumerConnect(mockConsumer, false);
129 consumer->setConsumerName(String8("TestConsumer"));
130
131 sp<Surface> surface = new Surface(producer);
132 sp<ANativeWindow> window(surface);
133 sp<FakeSurfaceListener> listener;
134 if (hasSurfaceListener) {
135 listener = new FakeSurfaceListener(enableReleasedCb);
136 }
137 ASSERT_EQ(OK, surface->connect(
138 NATIVE_WINDOW_API_CPU,
139 /*reportBufferRemoval*/true,
140 /*listener*/listener));
141 const int BUFFER_COUNT = 4 + extraDiscardedBuffers;
142 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
143
144 ANativeWindowBuffer* buffers[BUFFER_COUNT];
145 // Dequeue first to allocate a number of buffers
146 for (int i = 0; i < BUFFER_COUNT; i++) {
147 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffers[i]));
148 }
149 for (int i = 0; i < BUFFER_COUNT; i++) {
150 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], -1));
151 }
152
153 ANativeWindowBuffer* buffer;
154 // Fill BUFFER_COUNT-1 buffers
155 for (int i = 0; i < BUFFER_COUNT-1; i++) {
156 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
157 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, -1));
158 }
159
160 // Dequeue 1 buffer
161 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
162
163 // Acquire and free 1+extraDiscardedBuffers buffer, check onBufferReleased is called.
164 std::vector<BufferItem> releasedItems;
165 releasedItems.resize(1+extraDiscardedBuffers);
166 for (int i = 0; i < releasedItems.size(); i++) {
167 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&releasedItems[i], 0));
168 ASSERT_EQ(NO_ERROR, consumer->releaseBuffer(releasedItems[i].mSlot,
169 releasedItems[i].mFrameNumber, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
170 Fence::NO_FENCE));
171 }
172 int32_t expectedReleaseCb = (enableReleasedCb ? releasedItems.size() : 0);
173 if (hasSurfaceListener) {
174 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
175 }
176
177 // Acquire 1 buffer, leaving 1+extraDiscardedBuffers filled buffer in queue
178 BufferItem item;
179 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&item, 0));
180
181 // Discard free buffers
182 ASSERT_EQ(NO_ERROR, consumer->discardFreeBuffers());
183
184 if (hasSurfaceListener) {
185 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
186
187 // Check onBufferDiscarded is called with correct buffer
188 auto discardedBuffers = listener->getDiscardedBuffers();
189 ASSERT_EQ(discardedBuffers.size(), releasedItems.size());
190 for (int i = 0; i < releasedItems.size(); i++) {
191 ASSERT_EQ(discardedBuffers[i], releasedItems[i].mGraphicBuffer);
192 }
193
194 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
195 }
196
197 // Disconnect the surface
198 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
199 }
200
captureDisplay(DisplayCaptureArgs & captureArgs,ScreenCaptureResults & captureResults)201 static status_t captureDisplay(DisplayCaptureArgs& captureArgs,
202 ScreenCaptureResults& captureResults) {
203 const auto sf = ComposerService::getComposerService();
204 SurfaceComposerClient::Transaction().apply(true);
205
206 const sp<SyncScreenCaptureListener> captureListener = new SyncScreenCaptureListener();
207 status_t status = sf->captureDisplay(captureArgs, captureListener);
208 if (status != NO_ERROR) {
209 return status;
210 }
211 captureResults = captureListener->waitForResults();
212 return captureResults.result;
213 }
214
215 sp<Surface> mSurface;
216 sp<SurfaceComposerClient> mComposerClient;
217 sp<SurfaceControl> mSurfaceControl;
218 };
219
TEST_F(SurfaceTest,CreateSurfaceReturnsErrorBadClient)220 TEST_F(SurfaceTest, CreateSurfaceReturnsErrorBadClient) {
221 mComposerClient->dispose();
222 ASSERT_EQ(NO_INIT, mComposerClient->initCheck());
223
224 sp<SurfaceControl> sc;
225 status_t err = mComposerClient->createSurfaceChecked(
226 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, &sc, 0);
227 ASSERT_EQ(NO_INIT, err);
228 }
229
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenVisible)230 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
231 sp<ANativeWindow> anw(mSurface);
232 int result = -123;
233 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
234 &result);
235 EXPECT_EQ(NO_ERROR, err);
236 EXPECT_EQ(1, result);
237 }
238
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenPurgatorized)239 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
240 mSurfaceControl.clear();
241 // Wait for the async clean-up to complete.
242 std::this_thread::sleep_for(50ms);
243
244 sp<ANativeWindow> anw(mSurface);
245 int result = -123;
246 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
247 &result);
248 EXPECT_EQ(NO_ERROR, err);
249 EXPECT_EQ(1, result);
250 }
251
252 // This test probably doesn't belong here.
TEST_F(SurfaceTest,ScreenshotsOfProtectedBuffersDontSucceed)253 TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersDontSucceed) {
254 sp<ANativeWindow> anw(mSurface);
255
256 // Verify the screenshot works with no protected buffers.
257 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
258
259 const sp<IBinder> display = sf->getInternalDisplayToken();
260 ASSERT_FALSE(display == nullptr);
261
262 DisplayCaptureArgs captureArgs;
263 captureArgs.displayToken = display;
264 captureArgs.width = 64;
265 captureArgs.height = 64;
266
267 ScreenCaptureResults captureResults;
268 ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));
269
270 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
271 NATIVE_WINDOW_API_CPU));
272 // Set the PROTECTED usage bit and verify that the screenshot fails. Note
273 // that we need to dequeue a buffer in order for it to actually get
274 // allocated in SurfaceFlinger.
275 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
276 GRALLOC_USAGE_PROTECTED));
277 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
278 ANativeWindowBuffer* buf = nullptr;
279
280 status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
281 if (err) {
282 // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
283 // that's okay as long as this is the reason for the failure.
284 // try again without the GRALLOC_USAGE_PROTECTED bit.
285 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
286 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
287 &buf));
288 return;
289 }
290 ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
291
292 for (int i = 0; i < 4; i++) {
293 // Loop to make sure SurfaceFlinger has retired a protected buffer.
294 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
295 &buf));
296 ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
297 }
298 ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));
299 }
300
TEST_F(SurfaceTest,ConcreteTypeIsSurface)301 TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
302 sp<ANativeWindow> anw(mSurface);
303 int result = -123;
304 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
305 EXPECT_EQ(NO_ERROR, err);
306 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
307 }
308
TEST_F(SurfaceTest,LayerCountIsOne)309 TEST_F(SurfaceTest, LayerCountIsOne) {
310 sp<ANativeWindow> anw(mSurface);
311 int result = -123;
312 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
313 EXPECT_EQ(NO_ERROR, err);
314 EXPECT_EQ(1, result);
315 }
316
TEST_F(SurfaceTest,QueryConsumerUsage)317 TEST_F(SurfaceTest, QueryConsumerUsage) {
318 const int TEST_USAGE_FLAGS =
319 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
320 sp<IGraphicBufferProducer> producer;
321 sp<IGraphicBufferConsumer> consumer;
322 BufferQueue::createBufferQueue(&producer, &consumer);
323 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
324 TEST_USAGE_FLAGS);
325 sp<Surface> s = new Surface(producer);
326
327 sp<ANativeWindow> anw(s);
328
329 int flags = -1;
330 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
331
332 ASSERT_EQ(NO_ERROR, err);
333 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
334 }
335
TEST_F(SurfaceTest,QueryDefaultBuffersDataSpace)336 TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
337 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_V0_SRGB;
338 sp<IGraphicBufferProducer> producer;
339 sp<IGraphicBufferConsumer> consumer;
340 BufferQueue::createBufferQueue(&producer, &consumer);
341 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
342
343 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
344
345 sp<Surface> s = new Surface(producer);
346
347 sp<ANativeWindow> anw(s);
348
349 android_dataspace dataSpace;
350
351 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
352 reinterpret_cast<int*>(&dataSpace));
353
354 ASSERT_EQ(NO_ERROR, err);
355 ASSERT_EQ(TEST_DATASPACE, dataSpace);
356 }
357
TEST_F(SurfaceTest,SettingGenerationNumber)358 TEST_F(SurfaceTest, SettingGenerationNumber) {
359 sp<IGraphicBufferProducer> producer;
360 sp<IGraphicBufferConsumer> consumer;
361 BufferQueue::createBufferQueue(&producer, &consumer);
362 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
363 sp<Surface> surface = new Surface(producer);
364 sp<ANativeWindow> window(surface);
365
366 // Allocate a buffer with a generation number of 0
367 ANativeWindowBuffer* buffer;
368 int fenceFd;
369 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
370 NATIVE_WINDOW_API_CPU));
371 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
372 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
373
374 // Detach the buffer and check its generation number
375 sp<GraphicBuffer> graphicBuffer;
376 sp<Fence> fence;
377 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
378 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
379
380 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
381 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
382
383 // This should change the generation number of the GraphicBuffer
384 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
385
386 // Check that the new generation number sticks with the buffer
387 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
388 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
389 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
390 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
391 }
392
TEST_F(SurfaceTest,GetConsumerName)393 TEST_F(SurfaceTest, GetConsumerName) {
394 sp<IGraphicBufferProducer> producer;
395 sp<IGraphicBufferConsumer> consumer;
396 BufferQueue::createBufferQueue(&producer, &consumer);
397
398 sp<MockConsumer> mockConsumer(new MockConsumer);
399 consumer->consumerConnect(mockConsumer, false);
400 consumer->setConsumerName(String8("TestConsumer"));
401
402 sp<Surface> surface = new Surface(producer);
403 sp<ANativeWindow> window(surface);
404 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
405
406 EXPECT_STREQ("TestConsumer", surface->getConsumerName().string());
407 }
408
TEST_F(SurfaceTest,GetWideColorSupport)409 TEST_F(SurfaceTest, GetWideColorSupport) {
410 sp<IGraphicBufferProducer> producer;
411 sp<IGraphicBufferConsumer> consumer;
412 BufferQueue::createBufferQueue(&producer, &consumer);
413
414 sp<MockConsumer> mockConsumer(new MockConsumer);
415 consumer->consumerConnect(mockConsumer, false);
416 consumer->setConsumerName(String8("TestConsumer"));
417
418 sp<Surface> surface = new Surface(producer);
419 sp<ANativeWindow> window(surface);
420 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
421
422 bool supported;
423 surface->getWideColorSupport(&supported);
424
425 // NOTE: This test assumes that device that supports
426 // wide-color (as indicated by BoardConfig) must also
427 // have a wide-color primary display.
428 // That assumption allows this test to cover devices
429 // that advertised a wide-color color mode without
430 // actually supporting wide-color to pass this test
431 // as well as the case of a device that does support
432 // wide-color (via BoardConfig) and has a wide-color
433 // primary display.
434 // NOT covered at this time is a device that supports
435 // wide color in the BoardConfig but does not support
436 // a wide-color color mode on the primary display.
437 ASSERT_EQ(hasWideColorDisplay, supported);
438 }
439
TEST_F(SurfaceTest,GetHdrSupport)440 TEST_F(SurfaceTest, GetHdrSupport) {
441 sp<IGraphicBufferProducer> producer;
442 sp<IGraphicBufferConsumer> consumer;
443 BufferQueue::createBufferQueue(&producer, &consumer);
444
445 sp<MockConsumer> mockConsumer(new MockConsumer);
446 consumer->consumerConnect(mockConsumer, false);
447 consumer->setConsumerName(String8("TestConsumer"));
448
449 sp<Surface> surface = new Surface(producer);
450 sp<ANativeWindow> window(surface);
451 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
452
453 bool supported;
454 status_t result = surface->getHdrSupport(&supported);
455 ASSERT_EQ(NO_ERROR, result);
456
457 // NOTE: This is not a CTS test.
458 // This test verifies that when the BoardConfig TARGET_HAS_HDR_DISPLAY
459 // is TRUE, getHdrSupport is also true.
460 // TODO: Add check for an HDR color mode on the primary display.
461 ASSERT_EQ(hasHdrDisplay, supported);
462 }
463
TEST_F(SurfaceTest,SetHdrMetadata)464 TEST_F(SurfaceTest, SetHdrMetadata) {
465 sp<IGraphicBufferProducer> producer;
466 sp<IGraphicBufferConsumer> consumer;
467 BufferQueue::createBufferQueue(&producer, &consumer);
468
469 sp<MockConsumer> mockConsumer(new MockConsumer);
470 consumer->consumerConnect(mockConsumer, false);
471 consumer->setConsumerName(String8("TestConsumer"));
472
473 sp<Surface> surface = new Surface(producer);
474 sp<ANativeWindow> window(surface);
475 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
476
477 bool supported;
478 status_t result = surface->getHdrSupport(&supported);
479 ASSERT_EQ(NO_ERROR, result);
480
481 if (!hasHdrDisplay || !supported) {
482 return;
483 }
484 const android_smpte2086_metadata smpte2086 = {
485 {0.680, 0.320},
486 {0.265, 0.690},
487 {0.150, 0.060},
488 {0.3127, 0.3290},
489 100.0,
490 0.1,
491 };
492 const android_cta861_3_metadata cta861_3 = {
493 78.0,
494 62.0,
495 };
496
497 std::vector<uint8_t> hdr10plus;
498 hdr10plus.push_back(0xff);
499
500 int error = native_window_set_buffers_smpte2086_metadata(window.get(), &smpte2086);
501 ASSERT_EQ(error, NO_ERROR);
502 error = native_window_set_buffers_cta861_3_metadata(window.get(), &cta861_3);
503 ASSERT_EQ(error, NO_ERROR);
504 error = native_window_set_buffers_hdr10_plus_metadata(window.get(), hdr10plus.size(),
505 hdr10plus.data());
506 ASSERT_EQ(error, NO_ERROR);
507 }
508
TEST_F(SurfaceTest,DynamicSetBufferCount)509 TEST_F(SurfaceTest, DynamicSetBufferCount) {
510 sp<IGraphicBufferProducer> producer;
511 sp<IGraphicBufferConsumer> consumer;
512 BufferQueue::createBufferQueue(&producer, &consumer);
513
514 sp<MockConsumer> mockConsumer(new MockConsumer);
515 consumer->consumerConnect(mockConsumer, false);
516 consumer->setConsumerName(String8("TestConsumer"));
517
518 sp<Surface> surface = new Surface(producer);
519 sp<ANativeWindow> window(surface);
520
521 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
522 NATIVE_WINDOW_API_CPU));
523 native_window_set_buffer_count(window.get(), 4);
524
525 int fence;
526 ANativeWindowBuffer* buffer;
527 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
528 native_window_set_buffer_count(window.get(), 3);
529 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
530 native_window_set_buffer_count(window.get(), 2);
531 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
532 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
533 }
534
TEST_F(SurfaceTest,GetAndFlushRemovedBuffers)535 TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
536 sp<IGraphicBufferProducer> producer;
537 sp<IGraphicBufferConsumer> consumer;
538 BufferQueue::createBufferQueue(&producer, &consumer);
539
540 sp<MockConsumer> mockConsumer(new MockConsumer);
541 consumer->consumerConnect(mockConsumer, false);
542 consumer->setConsumerName(String8("TestConsumer"));
543
544 sp<Surface> surface = new Surface(producer);
545 sp<ANativeWindow> window(surface);
546 sp<StubProducerListener> listener = new StubProducerListener();
547 ASSERT_EQ(OK, surface->connect(
548 NATIVE_WINDOW_API_CPU,
549 /*listener*/listener,
550 /*reportBufferRemoval*/true));
551 const int BUFFER_COUNT = 4;
552 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
553
554 sp<GraphicBuffer> detachedBuffer;
555 sp<Fence> outFence;
556 int fences[BUFFER_COUNT];
557 ANativeWindowBuffer* buffers[BUFFER_COUNT];
558 // Allocate buffers because detachNextBuffer requires allocated buffers
559 for (int i = 0; i < BUFFER_COUNT; i++) {
560 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
561 }
562 for (int i = 0; i < BUFFER_COUNT; i++) {
563 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
564 }
565
566 // Test detached buffer is correctly reported
567 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
568 std::vector<sp<GraphicBuffer>> removedBuffers;
569 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
570 ASSERT_EQ(1u, removedBuffers.size());
571 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
572 // Test the list is flushed one getAndFlushRemovedBuffers returns
573 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
574 ASSERT_EQ(0u, removedBuffers.size());
575
576
577 // Test removed buffer list is cleanup after next dequeueBuffer call
578 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
579 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
580 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
581 ASSERT_EQ(0u, removedBuffers.size());
582 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
583
584 // Test removed buffer list is cleanup after next detachNextBuffer call
585 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
586 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
587 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
588 ASSERT_EQ(1u, removedBuffers.size());
589 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
590
591 // Re-allocate buffers since all buffers are detached up to now
592 for (int i = 0; i < BUFFER_COUNT; i++) {
593 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
594 }
595 for (int i = 0; i < BUFFER_COUNT; i++) {
596 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
597 }
598
599 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
600 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
601 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
602 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
603 // get 0 or 1 buffer removed.
604 ASSERT_LE(removedBuffers.size(), 1u);
605 }
606
TEST_F(SurfaceTest,SurfaceListenerTest)607 TEST_F(SurfaceTest, SurfaceListenerTest) {
608 // Test discarding 1 free buffers with no listener
609 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/0);
610 // Test discarding 2 free buffers with no listener
611 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/1);
612 // Test discarding 1 free buffers with a listener, disabling onBufferReleased
613 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/0);
614 // Test discarding 2 free buffers with a listener, disabling onBufferReleased
615 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/1);
616 // Test discarding 1 free buffers with a listener, enabling onBufferReleased
617 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/0);
618 // Test discarding 3 free buffers with a listener, enabling onBufferReleased
619 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/2);
620 }
621
TEST_F(SurfaceTest,TestGetLastDequeueStartTime)622 TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
623 sp<ANativeWindow> anw(mSurface);
624 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
625
626 ANativeWindowBuffer* buffer = nullptr;
627 int32_t fenceFd = -1;
628
629 nsecs_t before = systemTime(CLOCK_MONOTONIC);
630 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
631 nsecs_t after = systemTime(CLOCK_MONOTONIC);
632
633 nsecs_t lastDequeueTime = ANativeWindow_getLastDequeueStartTime(anw.get());
634 ASSERT_LE(before, lastDequeueTime);
635 ASSERT_GE(after, lastDequeueTime);
636 }
637
638 class FakeConsumer : public BnConsumerListener {
639 public:
onFrameAvailable(const BufferItem &)640 void onFrameAvailable(const BufferItem& /*item*/) override {}
onBuffersReleased()641 void onBuffersReleased() override {}
onSidebandStreamChanged()642 void onSidebandStreamChanged() override {}
643
addAndGetFrameTimestamps(const NewFrameEventsEntry * newTimestamps,FrameEventHistoryDelta * outDelta)644 void addAndGetFrameTimestamps(
645 const NewFrameEventsEntry* newTimestamps,
646 FrameEventHistoryDelta* outDelta) override {
647 if (newTimestamps) {
648 if (mGetFrameTimestampsEnabled) {
649 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
650 "Test should set mNewFrameEntryOverride before queuing "
651 "a frame.";
652 EXPECT_EQ(newTimestamps->frameNumber,
653 mNewFrameEntryOverride.frameNumber) <<
654 "Test attempting to add NewFrameEntryOverride with "
655 "incorrect frame number.";
656 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
657 mNewFrameEntryOverride.frameNumber = 0;
658 }
659 mAddFrameTimestampsCount++;
660 mLastAddedFrameNumber = newTimestamps->frameNumber;
661 }
662 if (outDelta) {
663 mFrameEventHistory.getAndResetDelta(outDelta);
664 mGetFrameTimestampsCount++;
665 }
666 mAddAndGetFrameTimestampsCallCount++;
667 }
668
669 bool mGetFrameTimestampsEnabled = false;
670
671 ConsumerFrameEventHistory mFrameEventHistory;
672 int mAddAndGetFrameTimestampsCallCount = 0;
673 int mAddFrameTimestampsCount = 0;
674 int mGetFrameTimestampsCount = 0;
675 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
676
677 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
678 };
679
680 class FakeSurfaceComposer : public ISurfaceComposer {
681 public:
~FakeSurfaceComposer()682 ~FakeSurfaceComposer() override {}
683
setSupportsPresent(bool supportsPresent)684 void setSupportsPresent(bool supportsPresent) {
685 mSupportsPresent = supportsPresent;
686 }
687
createConnection()688 sp<ISurfaceComposerClient> createConnection() override { return nullptr; }
createDisplayEventConnection(ISurfaceComposer::VsyncSource,ISurfaceComposer::EventRegistrationFlags)689 sp<IDisplayEventConnection> createDisplayEventConnection(
690 ISurfaceComposer::VsyncSource, ISurfaceComposer::EventRegistrationFlags) override {
691 return nullptr;
692 }
createDisplay(const String8 &,bool)693 sp<IBinder> createDisplay(const String8& /*displayName*/,
694 bool /*secure*/) override { return nullptr; }
destroyDisplay(const sp<IBinder> &)695 void destroyDisplay(const sp<IBinder>& /*display */) override {}
getPhysicalDisplayIds() const696 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override { return {}; }
getPrimaryPhysicalDisplayId(PhysicalDisplayId *) const697 status_t getPrimaryPhysicalDisplayId(PhysicalDisplayId*) const override { return NO_ERROR; }
getPhysicalDisplayToken(PhysicalDisplayId) const698 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId) const override { return nullptr; }
setTransactionState(const FrameTimelineInfo &,const Vector<ComposerState> &,const Vector<DisplayState> &,uint32_t,const sp<IBinder> &,const InputWindowCommands &,int64_t,bool,const client_cache_t &,bool,const std::vector<ListenerCallbacks> &,uint64_t)699 status_t setTransactionState(const FrameTimelineInfo& /*frameTimelineInfo*/,
700 const Vector<ComposerState>& /*state*/,
701 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
702 const sp<IBinder>& /*applyToken*/,
703 const InputWindowCommands& /*inputWindowCommands*/,
704 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
705 const client_cache_t& /*cachedBuffer*/,
706 bool /*hasListenerCallbacks*/,
707 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/,
708 uint64_t /*transactionId*/) override {
709 return NO_ERROR;
710 }
711
bootFinished()712 void bootFinished() override {}
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> &) const713 bool authenticateSurfaceTexture(
714 const sp<IGraphicBufferProducer>& /*surface*/) const override {
715 return false;
716 }
717
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported) const718 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported)
719 const override {
720 *outSupported = {
721 FrameEvent::REQUESTED_PRESENT,
722 FrameEvent::ACQUIRE,
723 FrameEvent::LATCH,
724 FrameEvent::FIRST_REFRESH_START,
725 FrameEvent::LAST_REFRESH_START,
726 FrameEvent::GPU_COMPOSITION_DONE,
727 FrameEvent::DEQUEUE_READY,
728 FrameEvent::RELEASE
729 };
730 if (mSupportsPresent) {
731 outSupported->push_back(
732 FrameEvent::DISPLAY_PRESENT);
733 }
734 return NO_ERROR;
735 }
736
setPowerMode(const sp<IBinder> &,int)737 void setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {}
getStaticDisplayInfo(const sp<IBinder> &,ui::StaticDisplayInfo *)738 status_t getStaticDisplayInfo(const sp<IBinder>& /*display*/, ui::StaticDisplayInfo*) override {
739 return NO_ERROR;
740 }
getDynamicDisplayInfo(const sp<IBinder> &,ui::DynamicDisplayInfo *)741 status_t getDynamicDisplayInfo(const sp<IBinder>& /*display*/,
742 ui::DynamicDisplayInfo*) override {
743 return NO_ERROR;
744 }
getDisplayState(const sp<IBinder> &,ui::DisplayState *)745 status_t getDisplayState(const sp<IBinder>& /*display*/, ui::DisplayState*) override {
746 return NO_ERROR;
747 }
getDisplayStats(const sp<IBinder> &,DisplayStatInfo *)748 status_t getDisplayStats(const sp<IBinder>& /*display*/,
749 DisplayStatInfo* /*stats*/) override { return NO_ERROR; }
getDisplayNativePrimaries(const sp<IBinder> &,ui::DisplayPrimaries &)750 status_t getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
751 ui::DisplayPrimaries& /*primaries*/) override {
752 return NO_ERROR;
753 }
setActiveColorMode(const sp<IBinder> &,ColorMode)754 status_t setActiveColorMode(const sp<IBinder>& /*display*/,
755 ColorMode /*colorMode*/) override { return NO_ERROR; }
captureDisplay(const DisplayCaptureArgs &,const sp<IScreenCaptureListener> &)756 status_t captureDisplay(const DisplayCaptureArgs& /* captureArgs */,
757 const sp<IScreenCaptureListener>& /* captureListener */) override {
758 return NO_ERROR;
759 }
setAutoLowLatencyMode(const sp<IBinder> &,bool)760 void setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {}
setGameContentType(const sp<IBinder> &,bool)761 void setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {}
captureDisplay(uint64_t,const sp<IScreenCaptureListener> &)762 status_t captureDisplay(uint64_t /*displayOrLayerStack*/,
763 const sp<IScreenCaptureListener>& /* captureListener */) override {
764 return NO_ERROR;
765 }
captureLayers(const LayerCaptureArgs &,const sp<IScreenCaptureListener> &)766 virtual status_t captureLayers(
767 const LayerCaptureArgs& /* captureArgs */,
768 const sp<IScreenCaptureListener>& /* captureListener */) override {
769 return NO_ERROR;
770 }
clearAnimationFrameStats()771 status_t clearAnimationFrameStats() override { return NO_ERROR; }
getAnimationFrameStats(FrameStats *) const772 status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override {
773 return NO_ERROR;
774 }
overrideHdrTypes(const sp<IBinder> &,const std::vector<ui::Hdr> &)775 status_t overrideHdrTypes(const sp<IBinder>& /*display*/,
776 const std::vector<ui::Hdr>& /*hdrTypes*/) override {
777 return NO_ERROR;
778 }
onPullAtom(const int32_t,std::string *,bool *)779 status_t onPullAtom(const int32_t /*atomId*/, std::string* /*outData*/,
780 bool* /*success*/) override {
781 return NO_ERROR;
782 }
enableVSyncInjections(bool)783 status_t enableVSyncInjections(bool /*enable*/) override {
784 return NO_ERROR;
785 }
injectVSync(nsecs_t)786 status_t injectVSync(nsecs_t /*when*/) override { return NO_ERROR; }
getLayerDebugInfo(std::vector<LayerDebugInfo> *)787 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* /*layers*/) override {
788 return NO_ERROR;
789 }
getCompositionPreference(ui::Dataspace *,ui::PixelFormat *,ui::Dataspace *,ui::PixelFormat *) const790 status_t getCompositionPreference(
791 ui::Dataspace* /*outDefaultDataspace*/, ui::PixelFormat* /*outDefaultPixelFormat*/,
792 ui::Dataspace* /*outWideColorGamutDataspace*/,
793 ui::PixelFormat* /*outWideColorGamutPixelFormat*/) const override {
794 return NO_ERROR;
795 }
getDisplayedContentSamplingAttributes(const sp<IBinder> &,ui::PixelFormat *,ui::Dataspace *,uint8_t *) const796 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& /*display*/,
797 ui::PixelFormat* /*outFormat*/,
798 ui::Dataspace* /*outDataspace*/,
799 uint8_t* /*outComponentMask*/) const override {
800 return NO_ERROR;
801 }
setDisplayContentSamplingEnabled(const sp<IBinder> &,bool,uint8_t,uint64_t)802 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
803 uint8_t /*componentMask*/,
804 uint64_t /*maxFrames*/) override {
805 return NO_ERROR;
806 }
getDisplayedContentSample(const sp<IBinder> &,uint64_t,uint64_t,DisplayedFrameStats *) const807 status_t getDisplayedContentSample(const sp<IBinder>& /*display*/, uint64_t /*maxFrames*/,
808 uint64_t /*timestamp*/,
809 DisplayedFrameStats* /*outStats*/) const override {
810 return NO_ERROR;
811 }
812
getColorManagement(bool *) const813 status_t getColorManagement(bool* /*outGetColorManagement*/) const override { return NO_ERROR; }
getProtectedContentSupport(bool *) const814 status_t getProtectedContentSupport(bool* /*outSupported*/) const override { return NO_ERROR; }
815
isWideColorDisplay(const sp<IBinder> &,bool *) const816 status_t isWideColorDisplay(const sp<IBinder>&, bool*) const override { return NO_ERROR; }
getDisplayBrightnessSupport(const sp<IBinder> &,bool *) const817 status_t getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
818 bool* /*outSupport*/) const override {
819 return NO_ERROR;
820 }
setDisplayBrightness(const sp<IBinder> &,const gui::DisplayBrightness &)821 status_t setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
822 const gui::DisplayBrightness& /*brightness*/) override {
823 return NO_ERROR;
824 }
825
addHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)826 status_t addHdrLayerInfoListener(const sp<IBinder>&,
827 const sp<gui::IHdrLayerInfoListener>&) override {
828 return NO_ERROR;
829 }
830
removeHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)831 status_t removeHdrLayerInfoListener(const sp<IBinder>&,
832 const sp<gui::IHdrLayerInfoListener>&) override {
833 return NO_ERROR;
834 }
835
addRegionSamplingListener(const Rect &,const sp<IBinder> &,const sp<IRegionSamplingListener> &)836 status_t addRegionSamplingListener(const Rect& /*samplingArea*/,
837 const sp<IBinder>& /*stopLayerHandle*/,
838 const sp<IRegionSamplingListener>& /*listener*/) override {
839 return NO_ERROR;
840 }
removeRegionSamplingListener(const sp<IRegionSamplingListener> &)841 status_t removeRegionSamplingListener(
842 const sp<IRegionSamplingListener>& /*listener*/) override {
843 return NO_ERROR;
844 }
addFpsListener(int32_t,const sp<gui::IFpsListener> &)845 status_t addFpsListener(int32_t /*taskId*/, const sp<gui::IFpsListener>& /*listener*/) {
846 return NO_ERROR;
847 }
removeFpsListener(const sp<gui::IFpsListener> &)848 status_t removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) { return NO_ERROR; }
849
addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)850 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& /*listener*/) {
851 return NO_ERROR;
852 }
853
removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)854 status_t removeTunnelModeEnabledListener(
855 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) {
856 return NO_ERROR;
857 }
858
setDesiredDisplayModeSpecs(const sp<IBinder> &,ui::DisplayModeId,bool,float,float,float,float)859 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
860 ui::DisplayModeId /*defaultMode*/,
861 bool /*allowGroupSwitching*/,
862 float /*primaryRefreshRateMin*/,
863 float /*primaryRefreshRateMax*/,
864 float /*appRequestRefreshRateMin*/,
865 float /*appRequestRefreshRateMax*/) {
866 return NO_ERROR;
867 }
getDesiredDisplayModeSpecs(const sp<IBinder> &,ui::DisplayModeId *,bool *,float *,float *,float *,float *)868 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
869 ui::DisplayModeId* /*outDefaultMode*/,
870 bool* /*outAllowGroupSwitching*/,
871 float* /*outPrimaryRefreshRateMin*/,
872 float* /*outPrimaryRefreshRateMax*/,
873 float* /*outAppRequestRefreshRateMin*/,
874 float* /*outAppRequestRefreshRateMax*/) override {
875 return NO_ERROR;
876 };
notifyPowerBoost(int32_t)877 status_t notifyPowerBoost(int32_t /*boostId*/) override { return NO_ERROR; }
878
setGlobalShadowSettings(const half4 &,const half4 &,float,float,float)879 status_t setGlobalShadowSettings(const half4& /*ambientColor*/, const half4& /*spotColor*/,
880 float /*lightPosY*/, float /*lightPosZ*/,
881 float /*lightRadius*/) override {
882 return NO_ERROR;
883 }
884
setFrameRate(const sp<IGraphicBufferProducer> &,float,int8_t,int8_t)885 status_t setFrameRate(const sp<IGraphicBufferProducer>& /*surface*/, float /*frameRate*/,
886 int8_t /*compatibility*/, int8_t /*changeFrameRateStrategy*/) override {
887 return NO_ERROR;
888 }
889
acquireFrameRateFlexibilityToken(sp<IBinder> *)890 status_t acquireFrameRateFlexibilityToken(sp<IBinder>* /*outToken*/) override {
891 return NO_ERROR;
892 }
893
setFrameTimelineInfo(const sp<IGraphicBufferProducer> &,const FrameTimelineInfo &)894 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& /*surface*/,
895 const FrameTimelineInfo& /*frameTimelineInfo*/) override {
896 return NO_ERROR;
897 }
898
addTransactionTraceListener(const sp<gui::ITransactionTraceListener> &)899 status_t addTransactionTraceListener(
900 const sp<gui::ITransactionTraceListener>& /*listener*/) override {
901 return NO_ERROR;
902 }
903
getGPUContextPriority()904 int getGPUContextPriority() override { return 0; };
905
getMaxAcquiredBufferCount(int *) const906 status_t getMaxAcquiredBufferCount(int* /*buffers*/) const override { return NO_ERROR; }
907
addWindowInfosListener(const sp<gui::IWindowInfosListener> &) const908 status_t addWindowInfosListener(
909 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) const override {
910 return NO_ERROR;
911 }
912
removeWindowInfosListener(const sp<gui::IWindowInfosListener> &) const913 status_t removeWindowInfosListener(
914 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) const override {
915 return NO_ERROR;
916 }
917
918 protected:
onAsBinder()919 IBinder* onAsBinder() override { return nullptr; }
920
921 private:
922 bool mSupportsPresent{true};
923 };
924
925 class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
926 public:
FakeProducerFrameEventHistory(FenceToFenceTimeMap * fenceMap)927 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
928
~FakeProducerFrameEventHistory()929 ~FakeProducerFrameEventHistory() {}
930
updateAcquireFence(uint64_t frameNumber,std::shared_ptr<FenceTime> && acquire)931 void updateAcquireFence(uint64_t frameNumber,
932 std::shared_ptr<FenceTime>&& acquire) override {
933 // Verify the acquire fence being added isn't the one from the consumer.
934 EXPECT_NE(mConsumerAcquireFence, acquire);
935 // Override the fence, so we can verify this was called by the
936 // producer after the frame is queued.
937 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
938 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
939 }
940
setAcquireFenceOverride(const std::shared_ptr<FenceTime> & acquireFenceOverride,const std::shared_ptr<FenceTime> & consumerAcquireFence)941 void setAcquireFenceOverride(
942 const std::shared_ptr<FenceTime>& acquireFenceOverride,
943 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
944 mAcquireFenceOverride = acquireFenceOverride;
945 mConsumerAcquireFence = consumerAcquireFence;
946 }
947
948 protected:
createFenceTime(const sp<Fence> & fence) const949 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
950 const override {
951 return mFenceMap->createFenceTimeForTest(fence);
952 }
953
954 FenceToFenceTimeMap* mFenceMap{nullptr};
955
956 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
957 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
958 };
959
960
961 class TestSurface : public Surface {
962 public:
TestSurface(const sp<IGraphicBufferProducer> & bufferProducer,FenceToFenceTimeMap * fenceMap)963 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer,
964 FenceToFenceTimeMap* fenceMap)
965 : Surface(bufferProducer),
966 mFakeSurfaceComposer(new FakeSurfaceComposer) {
967 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
968 mFrameEventHistory.reset(mFakeFrameEventHistory);
969 }
970
~TestSurface()971 ~TestSurface() override {}
972
composerService() const973 sp<ISurfaceComposer> composerService() const override {
974 return mFakeSurfaceComposer;
975 }
976
now() const977 nsecs_t now() const override {
978 return mNow;
979 }
980
setNow(nsecs_t now)981 void setNow(nsecs_t now) {
982 mNow = now;
983 }
984
985 public:
986 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
987 nsecs_t mNow = 0;
988
989 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
990 // but this raw pointer gives access to test functionality.
991 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
992 };
993
994
995 class GetFrameTimestampsTest : public ::testing::Test {
996 protected:
997 struct FenceAndFenceTime {
FenceAndFenceTimeandroid::GetFrameTimestampsTest::FenceAndFenceTime998 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
999 : mFence(new Fence),
1000 mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
1001 sp<Fence> mFence { nullptr };
1002 std::shared_ptr<FenceTime> mFenceTime { nullptr };
1003 };
1004
1005 struct RefreshEvents {
RefreshEventsandroid::GetFrameTimestampsTest::RefreshEvents1006 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
1007 : mFenceMap(fenceMap),
1008 kCompositorTiming(
1009 {refreshStart, refreshStart + 1, refreshStart + 2 }),
1010 kStartTime(refreshStart + 3),
1011 kGpuCompositionDoneTime(refreshStart + 4),
1012 kPresentTime(refreshStart + 5) {}
1013
signalPostCompositeFencesandroid::GetFrameTimestampsTest::RefreshEvents1014 void signalPostCompositeFences() {
1015 mFenceMap.signalAllForTest(
1016 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1017 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1018 }
1019
1020 FenceToFenceTimeMap& mFenceMap;
1021
1022 FenceAndFenceTime mGpuCompositionDone { mFenceMap };
1023 FenceAndFenceTime mPresent { mFenceMap };
1024
1025 const CompositorTiming kCompositorTiming;
1026
1027 const nsecs_t kStartTime;
1028 const nsecs_t kGpuCompositionDoneTime;
1029 const nsecs_t kPresentTime;
1030 };
1031
1032 struct FrameEvents {
FrameEventsandroid::GetFrameTimestampsTest::FrameEvents1033 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1034 : mFenceMap(fenceMap),
1035 kPostedTime(frameStartTime + 100),
1036 kRequestedPresentTime(frameStartTime + 200),
1037 kProducerAcquireTime(frameStartTime + 300),
1038 kConsumerAcquireTime(frameStartTime + 301),
1039 kLatchTime(frameStartTime + 500),
1040 kDequeueReadyTime(frameStartTime + 600),
1041 kReleaseTime(frameStartTime + 700),
1042 mRefreshes {
1043 { mFenceMap, frameStartTime + 410 },
1044 { mFenceMap, frameStartTime + 420 },
1045 { mFenceMap, frameStartTime + 430 } } {}
1046
signalQueueFencesandroid::GetFrameTimestampsTest::FrameEvents1047 void signalQueueFences() {
1048 mFenceMap.signalAllForTest(
1049 mAcquireConsumer.mFence, kConsumerAcquireTime);
1050 mFenceMap.signalAllForTest(
1051 mAcquireProducer.mFence, kProducerAcquireTime);
1052 }
1053
signalRefreshFencesandroid::GetFrameTimestampsTest::FrameEvents1054 void signalRefreshFences() {
1055 for (auto& re : mRefreshes) {
1056 re.signalPostCompositeFences();
1057 }
1058 }
1059
signalReleaseFencesandroid::GetFrameTimestampsTest::FrameEvents1060 void signalReleaseFences() {
1061 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1062 }
1063
1064 FenceToFenceTimeMap& mFenceMap;
1065
1066 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1067 FenceAndFenceTime mAcquireProducer { mFenceMap };
1068 FenceAndFenceTime mRelease { mFenceMap };
1069
1070 const nsecs_t kPostedTime;
1071 const nsecs_t kRequestedPresentTime;
1072 const nsecs_t kProducerAcquireTime;
1073 const nsecs_t kConsumerAcquireTime;
1074 const nsecs_t kLatchTime;
1075 const nsecs_t kDequeueReadyTime;
1076 const nsecs_t kReleaseTime;
1077
1078 RefreshEvents mRefreshes[3];
1079 };
1080
GetFrameTimestampsTest()1081 GetFrameTimestampsTest() {}
1082
SetUp()1083 virtual void SetUp() {
1084 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1085 mFakeConsumer = new FakeConsumer;
1086 mCfeh = &mFakeConsumer->mFrameEventHistory;
1087 mConsumer->consumerConnect(mFakeConsumer, false);
1088 mConsumer->setConsumerName(String8("TestConsumer"));
1089 mSurface = new TestSurface(mProducer, &mFenceMap);
1090 mWindow = mSurface;
1091
1092 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1093 NATIVE_WINDOW_API_CPU));
1094 native_window_set_buffer_count(mWindow.get(), 4);
1095 }
1096
disableFrameTimestamps()1097 void disableFrameTimestamps() {
1098 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1099 native_window_enable_frame_timestamps(mWindow.get(), 0);
1100 mFrameTimestampsEnabled = false;
1101 }
1102
enableFrameTimestamps()1103 void enableFrameTimestamps() {
1104 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1105 native_window_enable_frame_timestamps(mWindow.get(), 1);
1106 mFrameTimestampsEnabled = true;
1107 }
1108
getAllFrameTimestamps(uint64_t frameId)1109 int getAllFrameTimestamps(uint64_t frameId) {
1110 return native_window_get_frame_timestamps(mWindow.get(), frameId,
1111 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1112 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1113 &outGpuCompositionDoneTime, &outDisplayPresentTime,
1114 &outDequeueReadyTime, &outReleaseTime);
1115 }
1116
resetTimestamps()1117 void resetTimestamps() {
1118 outRequestedPresentTime = -1;
1119 outAcquireTime = -1;
1120 outLatchTime = -1;
1121 outFirstRefreshStartTime = -1;
1122 outLastRefreshStartTime = -1;
1123 outGpuCompositionDoneTime = -1;
1124 outDisplayPresentTime = -1;
1125 outDequeueReadyTime = -1;
1126 outReleaseTime = -1;
1127 }
1128
getNextFrameId()1129 uint64_t getNextFrameId() {
1130 uint64_t frameId = -1;
1131 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1132 EXPECT_EQ(status, NO_ERROR);
1133 return frameId;
1134 }
1135
dequeueAndQueue(uint64_t frameIndex)1136 void dequeueAndQueue(uint64_t frameIndex) {
1137 int fence = -1;
1138 ANativeWindowBuffer* buffer = nullptr;
1139 ASSERT_EQ(NO_ERROR,
1140 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1141
1142 int oldAddFrameTimestampsCount =
1143 mFakeConsumer->mAddFrameTimestampsCount;
1144
1145 FrameEvents* frame = &mFrames[frameIndex];
1146 uint64_t frameNumber = frameIndex + 1;
1147
1148 NewFrameEventsEntry fe;
1149 fe.frameNumber = frameNumber;
1150 fe.postedTime = frame->kPostedTime;
1151 fe.requestedPresentTime = frame->kRequestedPresentTime;
1152 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1153 mFakeConsumer->mNewFrameEntryOverride = fe;
1154
1155 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1156 frame->mAcquireProducer.mFenceTime,
1157 frame->mAcquireConsumer.mFenceTime);
1158
1159 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1160
1161 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1162
1163 EXPECT_EQ(
1164 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1165 mFakeConsumer->mAddFrameTimestampsCount);
1166 }
1167
addFrameEvents(bool gpuComposited,uint64_t iOldFrame,int64_t iNewFrame)1168 void addFrameEvents(
1169 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1170 FrameEvents* oldFrame =
1171 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1172 FrameEvents* newFrame = &mFrames[iNewFrame];
1173
1174 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
1175 uint64_t nNewFrame = iNewFrame + 1;
1176
1177 // Latch, Composite, and Release the frames in a plausible order.
1178 // Note: The timestamps won't necessarily match the order, but
1179 // that's okay for the purposes of this test.
1180 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1181
1182 // Composite the previous frame one more time, which helps verify
1183 // LastRefresh is updated properly.
1184 if (oldFrame != nullptr) {
1185 mCfeh->addPreComposition(nOldFrame,
1186 oldFrame->mRefreshes[2].kStartTime);
1187 gpuDoneFenceTime = gpuComposited ?
1188 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1189 FenceTime::NO_FENCE;
1190 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
1191 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1192 oldFrame->mRefreshes[2].kCompositorTiming);
1193 }
1194
1195 // Latch the new frame.
1196 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1197
1198 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1199 gpuDoneFenceTime = gpuComposited ?
1200 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1201 FenceTime::NO_FENCE;
1202 // HWC2 releases the previous buffer after a new latch just before
1203 // calling postComposition.
1204 if (oldFrame != nullptr) {
1205 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
1206 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1207 }
1208 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1209 newFrame->mRefreshes[0].mPresent.mFenceTime,
1210 newFrame->mRefreshes[0].kCompositorTiming);
1211
1212 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1213 gpuDoneFenceTime = gpuComposited ?
1214 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1215 FenceTime::NO_FENCE;
1216 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1217 newFrame->mRefreshes[1].mPresent.mFenceTime,
1218 newFrame->mRefreshes[1].kCompositorTiming);
1219 }
1220
1221 sp<IGraphicBufferProducer> mProducer;
1222 sp<IGraphicBufferConsumer> mConsumer;
1223 sp<FakeConsumer> mFakeConsumer;
1224 ConsumerFrameEventHistory* mCfeh;
1225 sp<TestSurface> mSurface;
1226 sp<ANativeWindow> mWindow;
1227
1228 FenceToFenceTimeMap mFenceMap;
1229
1230 bool mFrameTimestampsEnabled = false;
1231
1232 int64_t outRequestedPresentTime = -1;
1233 int64_t outAcquireTime = -1;
1234 int64_t outLatchTime = -1;
1235 int64_t outFirstRefreshStartTime = -1;
1236 int64_t outLastRefreshStartTime = -1;
1237 int64_t outGpuCompositionDoneTime = -1;
1238 int64_t outDisplayPresentTime = -1;
1239 int64_t outDequeueReadyTime = -1;
1240 int64_t outReleaseTime = -1;
1241
1242 FrameEvents mFrames[3] {
1243 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
1244 };
1245
1246
1247 // This test verifies that the frame timestamps are not retrieved when not
1248 // explicitly enabled via native_window_enable_frame_timestamps.
1249 // We want to check this to make sure there's no overhead for users
1250 // that don't need the timestamp information.
TEST_F(GetFrameTimestampsTest,DefaultDisabled)1251 TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1252 int fence;
1253 ANativeWindowBuffer* buffer;
1254
1255 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1256 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1257
1258 const uint64_t fId = getNextFrameId();
1259
1260 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1261 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1262 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1263 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1264
1265 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1266 // It is okay that frame timestamps are added in the consumer since it is
1267 // still needed for SurfaceFlinger dumps.
1268 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1269 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1270 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1271
1272 // Verify attempts to get frame timestamps fail.
1273 int result = getAllFrameTimestamps(fId);
1274 EXPECT_EQ(INVALID_OPERATION, result);
1275 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1276
1277 // Verify compositor timing query fails.
1278 nsecs_t compositeDeadline = 0;
1279 nsecs_t compositeInterval = 0;
1280 nsecs_t compositeToPresentLatency = 0;
1281 result = native_window_get_compositor_timing(mWindow.get(),
1282 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1283 EXPECT_EQ(INVALID_OPERATION, result);
1284 }
1285
1286 // This test verifies that the frame timestamps are retrieved if explicitly
1287 // enabled via native_window_enable_frame_timestamps.
TEST_F(GetFrameTimestampsTest,EnabledSimple)1288 TEST_F(GetFrameTimestampsTest, EnabledSimple) {
1289 CompositorTiming initialCompositorTiming {
1290 1000000000, // 1s deadline
1291 16666667, // 16ms interval
1292 50000000, // 50ms present latency
1293 };
1294 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1295
1296 enableFrameTimestamps();
1297
1298 // Verify the compositor timing query gets the initial compositor values
1299 // after timststamps are enabled; even before the first frame is queued
1300 // or dequeued.
1301 nsecs_t compositeDeadline = 0;
1302 nsecs_t compositeInterval = 0;
1303 nsecs_t compositeToPresentLatency = 0;
1304 mSurface->setNow(initialCompositorTiming.deadline - 1);
1305 int result = native_window_get_compositor_timing(mWindow.get(),
1306 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1307 EXPECT_EQ(NO_ERROR, result);
1308 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1309 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1310 EXPECT_EQ(initialCompositorTiming.presentLatency,
1311 compositeToPresentLatency);
1312
1313 int fence;
1314 ANativeWindowBuffer* buffer;
1315
1316 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1317 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
1318
1319 const uint64_t fId1 = getNextFrameId();
1320
1321 // Verify getFrameTimestamps is piggybacked on dequeue.
1322 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1323 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1324 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
1325
1326 NewFrameEventsEntry f1;
1327 f1.frameNumber = 1;
1328 f1.postedTime = mFrames[0].kPostedTime;
1329 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1330 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1331 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1332 mFrames[0].mAcquireProducer.mFenceTime,
1333 mFrames[0].mAcquireConsumer.mFenceTime);
1334 mFakeConsumer->mNewFrameEntryOverride = f1;
1335 mFrames[0].signalQueueFences();
1336
1337 // Verify getFrameTimestamps is piggybacked on queue.
1338 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1339 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1340 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
1341 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
1342
1343 // Verify queries for timestamps that the producer doesn't know about
1344 // triggers a call to see if the consumer has any new timestamps.
1345 result = getAllFrameTimestamps(fId1);
1346 EXPECT_EQ(NO_ERROR, result);
1347 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
1348 }
1349
TEST_F(GetFrameTimestampsTest,QueryPresentSupported)1350 TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1351 bool displayPresentSupported = true;
1352 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
1353
1354 // Verify supported bits are forwarded.
1355 int supportsPresent = -1;
1356 mWindow.get()->query(mWindow.get(),
1357 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1358 EXPECT_EQ(displayPresentSupported, supportsPresent);
1359 }
1360
TEST_F(GetFrameTimestampsTest,QueryPresentNotSupported)1361 TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1362 bool displayPresentSupported = false;
1363 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
1364
1365 // Verify supported bits are forwarded.
1366 int supportsPresent = -1;
1367 mWindow.get()->query(mWindow.get(),
1368 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1369 EXPECT_EQ(displayPresentSupported, supportsPresent);
1370 }
1371
TEST_F(GetFrameTimestampsTest,SnapToNextTickBasic)1372 TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1373 nsecs_t phase = 4000;
1374 nsecs_t interval = 1000;
1375
1376 // Timestamp in previous interval.
1377 nsecs_t timestamp = 3500;
1378 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1379 timestamp, phase, interval));
1380
1381 // Timestamp in next interval.
1382 timestamp = 4500;
1383 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1384 timestamp, phase, interval));
1385
1386 // Timestamp multiple intervals before.
1387 timestamp = 2500;
1388 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1389 timestamp, phase, interval));
1390
1391 // Timestamp multiple intervals after.
1392 timestamp = 6500;
1393 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1394 timestamp, phase, interval));
1395
1396 // Timestamp on previous interval.
1397 timestamp = 3000;
1398 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1399 timestamp, phase, interval));
1400
1401 // Timestamp on next interval.
1402 timestamp = 5000;
1403 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1404 timestamp, phase, interval));
1405
1406 // Timestamp equal to phase.
1407 timestamp = 4000;
1408 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1409 timestamp, phase, interval));
1410 }
1411
1412 // int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1413 // if the number of intervals elapsed is internally stored in an int.
TEST_F(GetFrameTimestampsTest,SnapToNextTickOverflow)1414 TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1415 nsecs_t phase = 0;
1416 nsecs_t interval = 4000;
1417 nsecs_t big_timestamp = 8635916564000;
1418 int32_t intervals = big_timestamp / interval;
1419
1420 EXPECT_LT(intervals, 0);
1421 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1422 big_timestamp, phase, interval));
1423 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1424 big_timestamp, big_timestamp, interval));
1425 }
1426
1427 // This verifies the compositor timing is updated by refresh events
1428 // and piggy backed on a queue, dequeue, and enabling of timestamps..
TEST_F(GetFrameTimestampsTest,CompositorTimingUpdatesBasic)1429 TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
1430 CompositorTiming initialCompositorTiming {
1431 1000000000, // 1s deadline
1432 16666667, // 16ms interval
1433 50000000, // 50ms present latency
1434 };
1435 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1436
1437 enableFrameTimestamps();
1438
1439 // We get the initial values before any frames are submitted.
1440 nsecs_t compositeDeadline = 0;
1441 nsecs_t compositeInterval = 0;
1442 nsecs_t compositeToPresentLatency = 0;
1443 mSurface->setNow(initialCompositorTiming.deadline - 1);
1444 int result = native_window_get_compositor_timing(mWindow.get(),
1445 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1446 EXPECT_EQ(NO_ERROR, result);
1447 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1448 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1449 EXPECT_EQ(initialCompositorTiming.presentLatency,
1450 compositeToPresentLatency);
1451
1452 dequeueAndQueue(0);
1453 addFrameEvents(true, NO_FRAME_INDEX, 0);
1454
1455 // Still get the initial values because the frame events for frame 0
1456 // didn't get a chance to piggyback on a queue or dequeue yet.
1457 result = native_window_get_compositor_timing(mWindow.get(),
1458 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1459 EXPECT_EQ(NO_ERROR, result);
1460 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1461 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1462 EXPECT_EQ(initialCompositorTiming.presentLatency,
1463 compositeToPresentLatency);
1464
1465 dequeueAndQueue(1);
1466 addFrameEvents(true, 0, 1);
1467
1468 // Now expect the composite values associated with frame 1.
1469 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1470 result = native_window_get_compositor_timing(mWindow.get(),
1471 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1472 EXPECT_EQ(NO_ERROR, result);
1473 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1474 compositeDeadline);
1475 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1476 compositeInterval);
1477 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1478 compositeToPresentLatency);
1479
1480 dequeueAndQueue(2);
1481 addFrameEvents(true, 1, 2);
1482
1483 // Now expect the composite values associated with frame 2.
1484 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1485 result = native_window_get_compositor_timing(mWindow.get(),
1486 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1487 EXPECT_EQ(NO_ERROR, result);
1488 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1489 compositeDeadline);
1490 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1491 compositeInterval);
1492 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1493 compositeToPresentLatency);
1494
1495 // Re-enabling frame timestamps should get the latest values.
1496 disableFrameTimestamps();
1497 enableFrameTimestamps();
1498
1499 // Now expect the composite values associated with frame 3.
1500 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1501 result = native_window_get_compositor_timing(mWindow.get(),
1502 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1503 EXPECT_EQ(NO_ERROR, result);
1504 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1505 compositeDeadline);
1506 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1507 compositeInterval);
1508 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1509 compositeToPresentLatency);
1510 }
1511
1512 // This verifies the compositor deadline properly snaps to the the next
1513 // deadline based on the current time.
TEST_F(GetFrameTimestampsTest,CompositorTimingDeadlineSnaps)1514 TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
1515 CompositorTiming initialCompositorTiming {
1516 1000000000, // 1s deadline
1517 16666667, // 16ms interval
1518 50000000, // 50ms present latency
1519 };
1520 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1521
1522 enableFrameTimestamps();
1523
1524 nsecs_t compositeDeadline = 0;
1525 nsecs_t compositeInterval = 0;
1526 nsecs_t compositeToPresentLatency = 0;
1527
1528 // A "now" just before the deadline snaps to the deadline.
1529 mSurface->setNow(initialCompositorTiming.deadline - 1);
1530 int result = native_window_get_compositor_timing(mWindow.get(),
1531 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1532 EXPECT_EQ(NO_ERROR, result);
1533 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1534 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1535 EXPECT_EQ(expectedDeadline, compositeDeadline);
1536
1537 dequeueAndQueue(0);
1538 addFrameEvents(true, NO_FRAME_INDEX, 0);
1539
1540 // A "now" just after the deadline snaps properly.
1541 mSurface->setNow(initialCompositorTiming.deadline + 1);
1542 result = native_window_get_compositor_timing(mWindow.get(),
1543 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1544 EXPECT_EQ(NO_ERROR, result);
1545 expectedDeadline =
1546 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1547 EXPECT_EQ(expectedDeadline, compositeDeadline);
1548
1549 dequeueAndQueue(1);
1550 addFrameEvents(true, 0, 1);
1551
1552 // A "now" just after the next interval snaps properly.
1553 mSurface->setNow(
1554 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1555 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1556 result = native_window_get_compositor_timing(mWindow.get(),
1557 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1558 EXPECT_EQ(NO_ERROR, result);
1559 expectedDeadline =
1560 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1561 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1562 EXPECT_EQ(expectedDeadline, compositeDeadline);
1563
1564 dequeueAndQueue(2);
1565 addFrameEvents(true, 1, 2);
1566
1567 // A "now" over 1 interval before the deadline snaps properly.
1568 mSurface->setNow(
1569 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1570 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1571 result = native_window_get_compositor_timing(mWindow.get(),
1572 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1573 EXPECT_EQ(NO_ERROR, result);
1574 expectedDeadline =
1575 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1576 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1577 EXPECT_EQ(expectedDeadline, compositeDeadline);
1578
1579 // Re-enabling frame timestamps should get the latest values.
1580 disableFrameTimestamps();
1581 enableFrameTimestamps();
1582
1583 // A "now" over 2 intervals before the deadline snaps properly.
1584 mSurface->setNow(
1585 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1586 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1587 result = native_window_get_compositor_timing(mWindow.get(),
1588 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1589 EXPECT_EQ(NO_ERROR, result);
1590 expectedDeadline =
1591 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1592 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1593 EXPECT_EQ(expectedDeadline, compositeDeadline);
1594 }
1595
1596 // This verifies the timestamps recorded in the consumer's
1597 // FrameTimestampsHistory are properly retrieved by the producer for the
1598 // correct frames.
TEST_F(GetFrameTimestampsTest,TimestampsAssociatedWithCorrectFrame)1599 TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1600 enableFrameTimestamps();
1601
1602 const uint64_t fId1 = getNextFrameId();
1603 dequeueAndQueue(0);
1604 mFrames[0].signalQueueFences();
1605
1606 const uint64_t fId2 = getNextFrameId();
1607 dequeueAndQueue(1);
1608 mFrames[1].signalQueueFences();
1609
1610 addFrameEvents(true, NO_FRAME_INDEX, 0);
1611 mFrames[0].signalRefreshFences();
1612 addFrameEvents(true, 0, 1);
1613 mFrames[0].signalReleaseFences();
1614 mFrames[1].signalRefreshFences();
1615
1616 // Verify timestamps are correct for frame 1.
1617 resetTimestamps();
1618 int result = getAllFrameTimestamps(fId1);
1619 EXPECT_EQ(NO_ERROR, result);
1620 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1621 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1622 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1623 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1624 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1625 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1626 outGpuCompositionDoneTime);
1627 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1628 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1629 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1630
1631 // Verify timestamps are correct for frame 2.
1632 resetTimestamps();
1633 result = getAllFrameTimestamps(fId2);
1634 EXPECT_EQ(NO_ERROR, result);
1635 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1636 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1637 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1638 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1639 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1640 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1641 outGpuCompositionDoneTime);
1642 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1643 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1644 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1645 }
1646
1647 // This test verifies the acquire fence recorded by the consumer is not sent
1648 // back to the producer and the producer saves its own fence.
TEST_F(GetFrameTimestampsTest,QueueTimestampsNoSync)1649 TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1650 enableFrameTimestamps();
1651
1652 // Dequeue and queue frame 1.
1653 const uint64_t fId1 = getNextFrameId();
1654 dequeueAndQueue(0);
1655
1656 // Verify queue-related timestamps for f1 are available immediately in the
1657 // producer without asking the consumer again, even before signaling the
1658 // acquire fence.
1659 resetTimestamps();
1660 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1661 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1662 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1663 nullptr, nullptr, nullptr, nullptr, nullptr);
1664 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1665 EXPECT_EQ(NO_ERROR, result);
1666 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1667 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1668
1669 // Signal acquire fences. Verify a sync call still isn't necessary.
1670 mFrames[0].signalQueueFences();
1671
1672 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1673 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1674 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1675 nullptr, nullptr, nullptr, nullptr, nullptr);
1676 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1677 EXPECT_EQ(NO_ERROR, result);
1678 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1679 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1680
1681 // Dequeue and queue frame 2.
1682 const uint64_t fId2 = getNextFrameId();
1683 dequeueAndQueue(1);
1684
1685 // Verify queue-related timestamps for f2 are available immediately in the
1686 // producer without asking the consumer again, even before signaling the
1687 // acquire fence.
1688 resetTimestamps();
1689 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1690 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1691 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1692 nullptr, nullptr, nullptr, nullptr, nullptr);
1693 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1694 EXPECT_EQ(NO_ERROR, result);
1695 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1696 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1697
1698 // Signal acquire fences. Verify a sync call still isn't necessary.
1699 mFrames[1].signalQueueFences();
1700
1701 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1702 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1703 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1704 nullptr, nullptr, nullptr, nullptr, nullptr);
1705 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1706 EXPECT_EQ(NO_ERROR, result);
1707 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1708 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1709 }
1710
TEST_F(GetFrameTimestampsTest,ZeroRequestedTimestampsNoSync)1711 TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1712 enableFrameTimestamps();
1713
1714 // Dequeue and queue frame 1.
1715 dequeueAndQueue(0);
1716 mFrames[0].signalQueueFences();
1717
1718 // Dequeue and queue frame 2.
1719 const uint64_t fId2 = getNextFrameId();
1720 dequeueAndQueue(1);
1721 mFrames[1].signalQueueFences();
1722
1723 addFrameEvents(true, NO_FRAME_INDEX, 0);
1724 mFrames[0].signalRefreshFences();
1725 addFrameEvents(true, 0, 1);
1726 mFrames[0].signalReleaseFences();
1727 mFrames[1].signalRefreshFences();
1728
1729 // Verify a request for no timestamps doesn't result in a sync call.
1730 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1731 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1732 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1733 nullptr, nullptr);
1734 EXPECT_EQ(NO_ERROR, result);
1735 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1736 }
1737
1738 // This test verifies that fences can signal and update timestamps producer
1739 // side without an additional sync call to the consumer.
TEST_F(GetFrameTimestampsTest,FencesInProducerNoSync)1740 TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1741 enableFrameTimestamps();
1742
1743 // Dequeue and queue frame 1.
1744 const uint64_t fId1 = getNextFrameId();
1745 dequeueAndQueue(0);
1746 mFrames[0].signalQueueFences();
1747
1748 // Dequeue and queue frame 2.
1749 dequeueAndQueue(1);
1750 mFrames[1].signalQueueFences();
1751
1752 addFrameEvents(true, NO_FRAME_INDEX, 0);
1753 addFrameEvents(true, 0, 1);
1754
1755 // Verify available timestamps are correct for frame 1, before any
1756 // fence has been signaled.
1757 // Note: A sync call is necessary here since the events triggered by
1758 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1759 resetTimestamps();
1760 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1761 int result = getAllFrameTimestamps(fId1);
1762 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1763 EXPECT_EQ(NO_ERROR, result);
1764 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1765 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1766 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1767 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1768 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1769 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1770 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1771 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1772 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1773
1774 // Verify available timestamps are correct for frame 1 again, before any
1775 // fence has been signaled.
1776 // This time a sync call should not be necessary.
1777 resetTimestamps();
1778 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1779 result = getAllFrameTimestamps(fId1);
1780 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1781 EXPECT_EQ(NO_ERROR, result);
1782 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1783 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1784 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1785 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1786 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1787 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1788 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1789 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1790 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1791
1792 // Signal the fences for frame 1.
1793 mFrames[0].signalRefreshFences();
1794 mFrames[0].signalReleaseFences();
1795
1796 // Verify all timestamps are available without a sync call.
1797 resetTimestamps();
1798 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1799 result = getAllFrameTimestamps(fId1);
1800 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1801 EXPECT_EQ(NO_ERROR, result);
1802 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1803 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1804 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1805 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1806 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1807 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1808 outGpuCompositionDoneTime);
1809 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1810 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1811 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1812 }
1813
1814 // This test verifies that if the frame wasn't GPU composited but has a refresh
1815 // event a sync call isn't made to get the GPU composite done time since it will
1816 // never exist.
TEST_F(GetFrameTimestampsTest,NoGpuNoSync)1817 TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1818 enableFrameTimestamps();
1819
1820 // Dequeue and queue frame 1.
1821 const uint64_t fId1 = getNextFrameId();
1822 dequeueAndQueue(0);
1823 mFrames[0].signalQueueFences();
1824
1825 // Dequeue and queue frame 2.
1826 dequeueAndQueue(1);
1827 mFrames[1].signalQueueFences();
1828
1829 addFrameEvents(false, NO_FRAME_INDEX, 0);
1830 addFrameEvents(false, 0, 1);
1831
1832 // Verify available timestamps are correct for frame 1, before any
1833 // fence has been signaled.
1834 // Note: A sync call is necessary here since the events triggered by
1835 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1836 resetTimestamps();
1837 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1838 int result = getAllFrameTimestamps(fId1);
1839 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1840 EXPECT_EQ(NO_ERROR, result);
1841 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1842 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1843 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1844 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1845 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1846 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1847 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1848 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1849 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1850
1851 // Signal the fences for frame 1.
1852 mFrames[0].signalRefreshFences();
1853 mFrames[0].signalReleaseFences();
1854
1855 // Verify all timestamps, except GPU composition, are available without a
1856 // sync call.
1857 resetTimestamps();
1858 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1859 result = getAllFrameTimestamps(fId1);
1860 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1861 EXPECT_EQ(NO_ERROR, result);
1862 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1863 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1864 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1865 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1866 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1867 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1868 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1869 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1870 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1871 }
1872
1873 // This test verifies that if the certain timestamps can't possibly exist for
1874 // the most recent frame, then a sync call is not done.
TEST_F(GetFrameTimestampsTest,NoReleaseNoSync)1875 TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
1876 enableFrameTimestamps();
1877
1878 // Dequeue and queue frame 1.
1879 const uint64_t fId1 = getNextFrameId();
1880 dequeueAndQueue(0);
1881 mFrames[0].signalQueueFences();
1882
1883 // Dequeue and queue frame 2.
1884 const uint64_t fId2 = getNextFrameId();
1885 dequeueAndQueue(1);
1886 mFrames[1].signalQueueFences();
1887
1888 addFrameEvents(false, NO_FRAME_INDEX, 0);
1889 addFrameEvents(false, 0, 1);
1890
1891 // Verify available timestamps are correct for frame 1, before any
1892 // fence has been signaled.
1893 // Note: A sync call is necessary here since the events triggered by
1894 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1895 resetTimestamps();
1896 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1897 int result = getAllFrameTimestamps(fId1);
1898 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1899 EXPECT_EQ(NO_ERROR, result);
1900 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1901 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1902 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1903 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1904 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1905 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1906 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1907 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1908 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1909
1910 mFrames[0].signalRefreshFences();
1911 mFrames[0].signalReleaseFences();
1912 mFrames[1].signalRefreshFences();
1913
1914 // Verify querying for all timestmaps of f2 does not do a sync call. Even
1915 // though the lastRefresh, dequeueReady, and release times aren't
1916 // available, a sync call should not occur because it's not possible for f2
1917 // to encounter the final value for those events until another frame is
1918 // queued.
1919 resetTimestamps();
1920 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1921 result = getAllFrameTimestamps(fId2);
1922 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1923 EXPECT_EQ(NO_ERROR, result);
1924 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1925 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1926 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1927 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1928 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1929 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1930 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1931 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1932 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1933 }
1934
1935 // This test verifies there are no sync calls for present times
1936 // when they aren't supported and that an error is returned.
1937
TEST_F(GetFrameTimestampsTest,PresentUnsupportedNoSync)1938 TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
1939 enableFrameTimestamps();
1940 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
1941
1942 // Dequeue and queue frame 1.
1943 const uint64_t fId1 = getNextFrameId();
1944 dequeueAndQueue(0);
1945
1946 // Verify a query for the Present times do not trigger a sync call if they
1947 // are not supported.
1948 resetTimestamps();
1949 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1950 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1951 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1952 &outDisplayPresentTime, nullptr, nullptr);
1953 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1954 EXPECT_EQ(BAD_VALUE, result);
1955 EXPECT_EQ(-1, outDisplayPresentTime);
1956 }
1957
TEST_F(SurfaceTest,DequeueWithConsumerDrivenSize)1958 TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
1959 sp<IGraphicBufferProducer> producer;
1960 sp<IGraphicBufferConsumer> consumer;
1961 BufferQueue::createBufferQueue(&producer, &consumer);
1962
1963 sp<MockConsumer> mockConsumer(new MockConsumer);
1964 consumer->consumerConnect(mockConsumer, false);
1965 consumer->setDefaultBufferSize(10, 10);
1966
1967 sp<Surface> surface = new Surface(producer);
1968 sp<ANativeWindow> window(surface);
1969 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
1970 native_window_set_buffers_dimensions(window.get(), 0, 0);
1971
1972 int fence;
1973 ANativeWindowBuffer* buffer;
1974
1975 // Buffer size is driven by the consumer
1976 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1977 EXPECT_EQ(10, buffer->width);
1978 EXPECT_EQ(10, buffer->height);
1979 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1980
1981 // Buffer size is driven by the consumer
1982 consumer->setDefaultBufferSize(10, 20);
1983 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1984 EXPECT_EQ(10, buffer->width);
1985 EXPECT_EQ(20, buffer->height);
1986 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1987
1988 // Transform hint isn't synced to producer before queueBuffer or connect
1989 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
1990 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1991 EXPECT_EQ(10, buffer->width);
1992 EXPECT_EQ(20, buffer->height);
1993 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
1994
1995 // Transform hint is synced to producer but no auto prerotation
1996 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
1997 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1998 EXPECT_EQ(10, buffer->width);
1999 EXPECT_EQ(20, buffer->height);
2000 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2001
2002 // Prerotation is driven by the consumer with the transform hint used by producer
2003 native_window_set_auto_prerotation(window.get(), true);
2004 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2005 EXPECT_EQ(20, buffer->width);
2006 EXPECT_EQ(10, buffer->height);
2007 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2008
2009 // Turn off auto prerotaton
2010 native_window_set_auto_prerotation(window.get(), false);
2011 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2012 EXPECT_EQ(10, buffer->width);
2013 EXPECT_EQ(20, buffer->height);
2014 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2015
2016 // Test auto prerotation bit is disabled after disconnect
2017 native_window_set_auto_prerotation(window.get(), true);
2018 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2019 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2020 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2021 native_window_set_buffers_dimensions(window.get(), 0, 0);
2022 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2023 EXPECT_EQ(10, buffer->width);
2024 EXPECT_EQ(20, buffer->height);
2025 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2026 }
2027
TEST_F(SurfaceTest,DefaultMaxBufferCountSetAndUpdated)2028 TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2029 sp<IGraphicBufferProducer> producer;
2030 sp<IGraphicBufferConsumer> consumer;
2031 BufferQueue::createBufferQueue(&producer, &consumer);
2032
2033 sp<MockConsumer> mockConsumer(new MockConsumer);
2034 consumer->consumerConnect(mockConsumer, false);
2035
2036 sp<Surface> surface = new Surface(producer);
2037 sp<ANativeWindow> window(surface);
2038
2039 int count = -1;
2040 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2041 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2042
2043 consumer->setMaxBufferCount(10);
2044 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2045 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2046 EXPECT_EQ(10, count);
2047
2048 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2049 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2050 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2051 }
2052
TEST_F(SurfaceTest,BatchOperations)2053 TEST_F(SurfaceTest, BatchOperations) {
2054 const int BUFFER_COUNT = 16;
2055 const int BATCH_SIZE = 8;
2056 sp<IGraphicBufferProducer> producer;
2057 sp<IGraphicBufferConsumer> consumer;
2058 BufferQueue::createBufferQueue(&producer, &consumer);
2059
2060 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2061 sp<Surface> surface = new Surface(producer);
2062 sp<ANativeWindow> window(surface);
2063 sp<StubProducerListener> listener = new StubProducerListener();
2064
2065 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2066 /*reportBufferRemoval*/false));
2067
2068 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2069
2070 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2071
2072 // Batch dequeued buffers can be queued individually
2073 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2074 for (size_t i = 0; i < BATCH_SIZE; i++) {
2075 ANativeWindowBuffer* buffer = buffers[i].buffer;
2076 int fence = buffers[i].fenceFd;
2077 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2078 }
2079
2080 // Batch dequeued buffers can be canceled individually
2081 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2082 for (size_t i = 0; i < BATCH_SIZE; i++) {
2083 ANativeWindowBuffer* buffer = buffers[i].buffer;
2084 int fence = buffers[i].fenceFd;
2085 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2086 }
2087
2088 // Batch dequeued buffers can be batch cancelled
2089 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2090 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2091
2092 // Batch dequeued buffers can be batch queued
2093 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2094 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2095 for (size_t i = 0; i < BATCH_SIZE; i++) {
2096 queuedBuffers[i].buffer = buffers[i].buffer;
2097 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2098 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2099 }
2100 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2101
2102 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2103 }
2104
TEST_F(SurfaceTest,BatchIllegalOperations)2105 TEST_F(SurfaceTest, BatchIllegalOperations) {
2106 const int BUFFER_COUNT = 16;
2107 const int BATCH_SIZE = 8;
2108 sp<IGraphicBufferProducer> producer;
2109 sp<IGraphicBufferConsumer> consumer;
2110 BufferQueue::createBufferQueue(&producer, &consumer);
2111
2112 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2113 sp<Surface> surface = new Surface(producer);
2114 sp<ANativeWindow> window(surface);
2115 sp<StubProducerListener> listener = new StubProducerListener();
2116
2117 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2118 /*reportBufferRemoval*/false));
2119
2120 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2121
2122 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2123 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2124
2125 // Batch operations are invalid in shared buffer mode
2126 surface->setSharedBufferMode(true);
2127 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2128 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2129 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2130 surface->setSharedBufferMode(false);
2131
2132 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2133 }
2134
2135 } // namespace android
2136