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 {}; }
getPhysicalDisplayToken(PhysicalDisplayId) const697 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)698 status_t setTransactionState(const FrameTimelineInfo& /*frameTimelineInfo*/,
699 const Vector<ComposerState>& /*state*/,
700 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
701 const sp<IBinder>& /*applyToken*/,
702 const InputWindowCommands& /*inputWindowCommands*/,
703 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
704 const client_cache_t& /*cachedBuffer*/,
705 bool /*hasListenerCallbacks*/,
706 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/,
707 uint64_t /*transactionId*/) override {
708 return NO_ERROR;
709 }
710
bootFinished()711 void bootFinished() override {}
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> &) const712 bool authenticateSurfaceTexture(
713 const sp<IGraphicBufferProducer>& /*surface*/) const override {
714 return false;
715 }
716
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported) const717 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported)
718 const override {
719 *outSupported = {
720 FrameEvent::REQUESTED_PRESENT,
721 FrameEvent::ACQUIRE,
722 FrameEvent::LATCH,
723 FrameEvent::FIRST_REFRESH_START,
724 FrameEvent::LAST_REFRESH_START,
725 FrameEvent::GPU_COMPOSITION_DONE,
726 FrameEvent::DEQUEUE_READY,
727 FrameEvent::RELEASE
728 };
729 if (mSupportsPresent) {
730 outSupported->push_back(
731 FrameEvent::DISPLAY_PRESENT);
732 }
733 return NO_ERROR;
734 }
735
setPowerMode(const sp<IBinder> &,int)736 void setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {}
getStaticDisplayInfo(const sp<IBinder> &,ui::StaticDisplayInfo *)737 status_t getStaticDisplayInfo(const sp<IBinder>& /*display*/, ui::StaticDisplayInfo*) override {
738 return NO_ERROR;
739 }
getDynamicDisplayInfo(const sp<IBinder> &,ui::DynamicDisplayInfo *)740 status_t getDynamicDisplayInfo(const sp<IBinder>& /*display*/,
741 ui::DynamicDisplayInfo*) override {
742 return NO_ERROR;
743 }
getDisplayState(const sp<IBinder> &,ui::DisplayState *)744 status_t getDisplayState(const sp<IBinder>& /*display*/, ui::DisplayState*) override {
745 return NO_ERROR;
746 }
getDisplayStats(const sp<IBinder> &,DisplayStatInfo *)747 status_t getDisplayStats(const sp<IBinder>& /*display*/,
748 DisplayStatInfo* /*stats*/) override { return NO_ERROR; }
getDisplayNativePrimaries(const sp<IBinder> &,ui::DisplayPrimaries &)749 status_t getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
750 ui::DisplayPrimaries& /*primaries*/) override {
751 return NO_ERROR;
752 }
setActiveColorMode(const sp<IBinder> &,ColorMode)753 status_t setActiveColorMode(const sp<IBinder>& /*display*/,
754 ColorMode /*colorMode*/) override { return NO_ERROR; }
captureDisplay(const DisplayCaptureArgs &,const sp<IScreenCaptureListener> &)755 status_t captureDisplay(const DisplayCaptureArgs& /* captureArgs */,
756 const sp<IScreenCaptureListener>& /* captureListener */) override {
757 return NO_ERROR;
758 }
setAutoLowLatencyMode(const sp<IBinder> &,bool)759 void setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {}
setGameContentType(const sp<IBinder> &,bool)760 void setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {}
captureDisplay(uint64_t,const sp<IScreenCaptureListener> &)761 status_t captureDisplay(uint64_t /*displayOrLayerStack*/,
762 const sp<IScreenCaptureListener>& /* captureListener */) override {
763 return NO_ERROR;
764 }
captureLayers(const LayerCaptureArgs &,const sp<IScreenCaptureListener> &)765 virtual status_t captureLayers(
766 const LayerCaptureArgs& /* captureArgs */,
767 const sp<IScreenCaptureListener>& /* captureListener */) override {
768 return NO_ERROR;
769 }
clearAnimationFrameStats()770 status_t clearAnimationFrameStats() override { return NO_ERROR; }
getAnimationFrameStats(FrameStats *) const771 status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override {
772 return NO_ERROR;
773 }
overrideHdrTypes(const sp<IBinder> &,const std::vector<ui::Hdr> &)774 status_t overrideHdrTypes(const sp<IBinder>& /*display*/,
775 const std::vector<ui::Hdr>& /*hdrTypes*/) override {
776 return NO_ERROR;
777 }
onPullAtom(const int32_t,std::string *,bool *)778 status_t onPullAtom(const int32_t /*atomId*/, std::string* /*outData*/,
779 bool* /*success*/) override {
780 return NO_ERROR;
781 }
enableVSyncInjections(bool)782 status_t enableVSyncInjections(bool /*enable*/) override {
783 return NO_ERROR;
784 }
injectVSync(nsecs_t)785 status_t injectVSync(nsecs_t /*when*/) override { return NO_ERROR; }
getLayerDebugInfo(std::vector<LayerDebugInfo> *)786 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* /*layers*/) override {
787 return NO_ERROR;
788 }
getCompositionPreference(ui::Dataspace *,ui::PixelFormat *,ui::Dataspace *,ui::PixelFormat *) const789 status_t getCompositionPreference(
790 ui::Dataspace* /*outDefaultDataspace*/, ui::PixelFormat* /*outDefaultPixelFormat*/,
791 ui::Dataspace* /*outWideColorGamutDataspace*/,
792 ui::PixelFormat* /*outWideColorGamutPixelFormat*/) const override {
793 return NO_ERROR;
794 }
getDisplayedContentSamplingAttributes(const sp<IBinder> &,ui::PixelFormat *,ui::Dataspace *,uint8_t *) const795 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& /*display*/,
796 ui::PixelFormat* /*outFormat*/,
797 ui::Dataspace* /*outDataspace*/,
798 uint8_t* /*outComponentMask*/) const override {
799 return NO_ERROR;
800 }
setDisplayContentSamplingEnabled(const sp<IBinder> &,bool,uint8_t,uint64_t)801 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
802 uint8_t /*componentMask*/,
803 uint64_t /*maxFrames*/) override {
804 return NO_ERROR;
805 }
getDisplayedContentSample(const sp<IBinder> &,uint64_t,uint64_t,DisplayedFrameStats *) const806 status_t getDisplayedContentSample(const sp<IBinder>& /*display*/, uint64_t /*maxFrames*/,
807 uint64_t /*timestamp*/,
808 DisplayedFrameStats* /*outStats*/) const override {
809 return NO_ERROR;
810 }
811
getColorManagement(bool *) const812 status_t getColorManagement(bool* /*outGetColorManagement*/) const override { return NO_ERROR; }
getProtectedContentSupport(bool *) const813 status_t getProtectedContentSupport(bool* /*outSupported*/) const override { return NO_ERROR; }
814
isWideColorDisplay(const sp<IBinder> &,bool *) const815 status_t isWideColorDisplay(const sp<IBinder>&, bool*) const override { return NO_ERROR; }
getDisplayBrightnessSupport(const sp<IBinder> &,bool *) const816 status_t getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
817 bool* /*outSupport*/) const override {
818 return NO_ERROR;
819 }
setDisplayBrightness(const sp<IBinder> &,const gui::DisplayBrightness &)820 status_t setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
821 const gui::DisplayBrightness& /*brightness*/) override {
822 return NO_ERROR;
823 }
824
addHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)825 status_t addHdrLayerInfoListener(const sp<IBinder>&,
826 const sp<gui::IHdrLayerInfoListener>&) override {
827 return NO_ERROR;
828 }
829
removeHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)830 status_t removeHdrLayerInfoListener(const sp<IBinder>&,
831 const sp<gui::IHdrLayerInfoListener>&) override {
832 return NO_ERROR;
833 }
834
addRegionSamplingListener(const Rect &,const sp<IBinder> &,const sp<IRegionSamplingListener> &)835 status_t addRegionSamplingListener(const Rect& /*samplingArea*/,
836 const sp<IBinder>& /*stopLayerHandle*/,
837 const sp<IRegionSamplingListener>& /*listener*/) override {
838 return NO_ERROR;
839 }
removeRegionSamplingListener(const sp<IRegionSamplingListener> &)840 status_t removeRegionSamplingListener(
841 const sp<IRegionSamplingListener>& /*listener*/) override {
842 return NO_ERROR;
843 }
addFpsListener(int32_t,const sp<gui::IFpsListener> &)844 status_t addFpsListener(int32_t /*taskId*/, const sp<gui::IFpsListener>& /*listener*/) {
845 return NO_ERROR;
846 }
removeFpsListener(const sp<gui::IFpsListener> &)847 status_t removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) { return NO_ERROR; }
848
addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)849 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& /*listener*/) {
850 return NO_ERROR;
851 }
852
removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)853 status_t removeTunnelModeEnabledListener(
854 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) {
855 return NO_ERROR;
856 }
857
setDesiredDisplayModeSpecs(const sp<IBinder> &,ui::DisplayModeId,bool,float,float,float,float)858 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
859 ui::DisplayModeId /*defaultMode*/,
860 bool /*allowGroupSwitching*/,
861 float /*primaryRefreshRateMin*/,
862 float /*primaryRefreshRateMax*/,
863 float /*appRequestRefreshRateMin*/,
864 float /*appRequestRefreshRateMax*/) {
865 return NO_ERROR;
866 }
getDesiredDisplayModeSpecs(const sp<IBinder> &,ui::DisplayModeId *,bool *,float *,float *,float *,float *)867 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
868 ui::DisplayModeId* /*outDefaultMode*/,
869 bool* /*outAllowGroupSwitching*/,
870 float* /*outPrimaryRefreshRateMin*/,
871 float* /*outPrimaryRefreshRateMax*/,
872 float* /*outAppRequestRefreshRateMin*/,
873 float* /*outAppRequestRefreshRateMax*/) override {
874 return NO_ERROR;
875 };
notifyPowerBoost(int32_t)876 status_t notifyPowerBoost(int32_t /*boostId*/) override { return NO_ERROR; }
877
setGlobalShadowSettings(const half4 &,const half4 &,float,float,float)878 status_t setGlobalShadowSettings(const half4& /*ambientColor*/, const half4& /*spotColor*/,
879 float /*lightPosY*/, float /*lightPosZ*/,
880 float /*lightRadius*/) override {
881 return NO_ERROR;
882 }
883
setFrameRate(const sp<IGraphicBufferProducer> &,float,int8_t,int8_t)884 status_t setFrameRate(const sp<IGraphicBufferProducer>& /*surface*/, float /*frameRate*/,
885 int8_t /*compatibility*/, int8_t /*changeFrameRateStrategy*/) override {
886 return NO_ERROR;
887 }
888
acquireFrameRateFlexibilityToken(sp<IBinder> *)889 status_t acquireFrameRateFlexibilityToken(sp<IBinder>* /*outToken*/) override {
890 return NO_ERROR;
891 }
892
setFrameTimelineInfo(const sp<IGraphicBufferProducer> &,const FrameTimelineInfo &)893 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& /*surface*/,
894 const FrameTimelineInfo& /*frameTimelineInfo*/) override {
895 return NO_ERROR;
896 }
897
addTransactionTraceListener(const sp<gui::ITransactionTraceListener> &)898 status_t addTransactionTraceListener(
899 const sp<gui::ITransactionTraceListener>& /*listener*/) override {
900 return NO_ERROR;
901 }
902
getGPUContextPriority()903 int getGPUContextPriority() override { return 0; };
904
getMaxAcquiredBufferCount(int *) const905 status_t getMaxAcquiredBufferCount(int* /*buffers*/) const override { return NO_ERROR; }
906
907 protected:
onAsBinder()908 IBinder* onAsBinder() override { return nullptr; }
909
910 private:
911 bool mSupportsPresent{true};
912 };
913
914 class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
915 public:
FakeProducerFrameEventHistory(FenceToFenceTimeMap * fenceMap)916 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
917
~FakeProducerFrameEventHistory()918 ~FakeProducerFrameEventHistory() {}
919
updateAcquireFence(uint64_t frameNumber,std::shared_ptr<FenceTime> && acquire)920 void updateAcquireFence(uint64_t frameNumber,
921 std::shared_ptr<FenceTime>&& acquire) override {
922 // Verify the acquire fence being added isn't the one from the consumer.
923 EXPECT_NE(mConsumerAcquireFence, acquire);
924 // Override the fence, so we can verify this was called by the
925 // producer after the frame is queued.
926 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
927 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
928 }
929
setAcquireFenceOverride(const std::shared_ptr<FenceTime> & acquireFenceOverride,const std::shared_ptr<FenceTime> & consumerAcquireFence)930 void setAcquireFenceOverride(
931 const std::shared_ptr<FenceTime>& acquireFenceOverride,
932 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
933 mAcquireFenceOverride = acquireFenceOverride;
934 mConsumerAcquireFence = consumerAcquireFence;
935 }
936
937 protected:
createFenceTime(const sp<Fence> & fence) const938 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
939 const override {
940 return mFenceMap->createFenceTimeForTest(fence);
941 }
942
943 FenceToFenceTimeMap* mFenceMap{nullptr};
944
945 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
946 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
947 };
948
949
950 class TestSurface : public Surface {
951 public:
TestSurface(const sp<IGraphicBufferProducer> & bufferProducer,FenceToFenceTimeMap * fenceMap)952 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer,
953 FenceToFenceTimeMap* fenceMap)
954 : Surface(bufferProducer),
955 mFakeSurfaceComposer(new FakeSurfaceComposer) {
956 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
957 mFrameEventHistory.reset(mFakeFrameEventHistory);
958 }
959
~TestSurface()960 ~TestSurface() override {}
961
composerService() const962 sp<ISurfaceComposer> composerService() const override {
963 return mFakeSurfaceComposer;
964 }
965
now() const966 nsecs_t now() const override {
967 return mNow;
968 }
969
setNow(nsecs_t now)970 void setNow(nsecs_t now) {
971 mNow = now;
972 }
973
974 public:
975 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
976 nsecs_t mNow = 0;
977
978 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
979 // but this raw pointer gives access to test functionality.
980 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
981 };
982
983
984 class GetFrameTimestampsTest : public ::testing::Test {
985 protected:
986 struct FenceAndFenceTime {
FenceAndFenceTimeandroid::GetFrameTimestampsTest::FenceAndFenceTime987 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
988 : mFence(new Fence),
989 mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
990 sp<Fence> mFence { nullptr };
991 std::shared_ptr<FenceTime> mFenceTime { nullptr };
992 };
993
994 struct RefreshEvents {
RefreshEventsandroid::GetFrameTimestampsTest::RefreshEvents995 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
996 : mFenceMap(fenceMap),
997 kCompositorTiming(
998 {refreshStart, refreshStart + 1, refreshStart + 2 }),
999 kStartTime(refreshStart + 3),
1000 kGpuCompositionDoneTime(refreshStart + 4),
1001 kPresentTime(refreshStart + 5) {}
1002
signalPostCompositeFencesandroid::GetFrameTimestampsTest::RefreshEvents1003 void signalPostCompositeFences() {
1004 mFenceMap.signalAllForTest(
1005 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1006 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1007 }
1008
1009 FenceToFenceTimeMap& mFenceMap;
1010
1011 FenceAndFenceTime mGpuCompositionDone { mFenceMap };
1012 FenceAndFenceTime mPresent { mFenceMap };
1013
1014 const CompositorTiming kCompositorTiming;
1015
1016 const nsecs_t kStartTime;
1017 const nsecs_t kGpuCompositionDoneTime;
1018 const nsecs_t kPresentTime;
1019 };
1020
1021 struct FrameEvents {
FrameEventsandroid::GetFrameTimestampsTest::FrameEvents1022 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1023 : mFenceMap(fenceMap),
1024 kPostedTime(frameStartTime + 100),
1025 kRequestedPresentTime(frameStartTime + 200),
1026 kProducerAcquireTime(frameStartTime + 300),
1027 kConsumerAcquireTime(frameStartTime + 301),
1028 kLatchTime(frameStartTime + 500),
1029 kDequeueReadyTime(frameStartTime + 600),
1030 kReleaseTime(frameStartTime + 700),
1031 mRefreshes {
1032 { mFenceMap, frameStartTime + 410 },
1033 { mFenceMap, frameStartTime + 420 },
1034 { mFenceMap, frameStartTime + 430 } } {}
1035
signalQueueFencesandroid::GetFrameTimestampsTest::FrameEvents1036 void signalQueueFences() {
1037 mFenceMap.signalAllForTest(
1038 mAcquireConsumer.mFence, kConsumerAcquireTime);
1039 mFenceMap.signalAllForTest(
1040 mAcquireProducer.mFence, kProducerAcquireTime);
1041 }
1042
signalRefreshFencesandroid::GetFrameTimestampsTest::FrameEvents1043 void signalRefreshFences() {
1044 for (auto& re : mRefreshes) {
1045 re.signalPostCompositeFences();
1046 }
1047 }
1048
signalReleaseFencesandroid::GetFrameTimestampsTest::FrameEvents1049 void signalReleaseFences() {
1050 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1051 }
1052
1053 FenceToFenceTimeMap& mFenceMap;
1054
1055 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1056 FenceAndFenceTime mAcquireProducer { mFenceMap };
1057 FenceAndFenceTime mRelease { mFenceMap };
1058
1059 const nsecs_t kPostedTime;
1060 const nsecs_t kRequestedPresentTime;
1061 const nsecs_t kProducerAcquireTime;
1062 const nsecs_t kConsumerAcquireTime;
1063 const nsecs_t kLatchTime;
1064 const nsecs_t kDequeueReadyTime;
1065 const nsecs_t kReleaseTime;
1066
1067 RefreshEvents mRefreshes[3];
1068 };
1069
GetFrameTimestampsTest()1070 GetFrameTimestampsTest() {}
1071
SetUp()1072 virtual void SetUp() {
1073 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1074 mFakeConsumer = new FakeConsumer;
1075 mCfeh = &mFakeConsumer->mFrameEventHistory;
1076 mConsumer->consumerConnect(mFakeConsumer, false);
1077 mConsumer->setConsumerName(String8("TestConsumer"));
1078 mSurface = new TestSurface(mProducer, &mFenceMap);
1079 mWindow = mSurface;
1080
1081 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1082 NATIVE_WINDOW_API_CPU));
1083 native_window_set_buffer_count(mWindow.get(), 4);
1084 }
1085
disableFrameTimestamps()1086 void disableFrameTimestamps() {
1087 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1088 native_window_enable_frame_timestamps(mWindow.get(), 0);
1089 mFrameTimestampsEnabled = false;
1090 }
1091
enableFrameTimestamps()1092 void enableFrameTimestamps() {
1093 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1094 native_window_enable_frame_timestamps(mWindow.get(), 1);
1095 mFrameTimestampsEnabled = true;
1096 }
1097
getAllFrameTimestamps(uint64_t frameId)1098 int getAllFrameTimestamps(uint64_t frameId) {
1099 return native_window_get_frame_timestamps(mWindow.get(), frameId,
1100 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1101 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1102 &outGpuCompositionDoneTime, &outDisplayPresentTime,
1103 &outDequeueReadyTime, &outReleaseTime);
1104 }
1105
resetTimestamps()1106 void resetTimestamps() {
1107 outRequestedPresentTime = -1;
1108 outAcquireTime = -1;
1109 outLatchTime = -1;
1110 outFirstRefreshStartTime = -1;
1111 outLastRefreshStartTime = -1;
1112 outGpuCompositionDoneTime = -1;
1113 outDisplayPresentTime = -1;
1114 outDequeueReadyTime = -1;
1115 outReleaseTime = -1;
1116 }
1117
getNextFrameId()1118 uint64_t getNextFrameId() {
1119 uint64_t frameId = -1;
1120 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1121 EXPECT_EQ(status, NO_ERROR);
1122 return frameId;
1123 }
1124
dequeueAndQueue(uint64_t frameIndex)1125 void dequeueAndQueue(uint64_t frameIndex) {
1126 int fence = -1;
1127 ANativeWindowBuffer* buffer = nullptr;
1128 ASSERT_EQ(NO_ERROR,
1129 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1130
1131 int oldAddFrameTimestampsCount =
1132 mFakeConsumer->mAddFrameTimestampsCount;
1133
1134 FrameEvents* frame = &mFrames[frameIndex];
1135 uint64_t frameNumber = frameIndex + 1;
1136
1137 NewFrameEventsEntry fe;
1138 fe.frameNumber = frameNumber;
1139 fe.postedTime = frame->kPostedTime;
1140 fe.requestedPresentTime = frame->kRequestedPresentTime;
1141 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1142 mFakeConsumer->mNewFrameEntryOverride = fe;
1143
1144 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1145 frame->mAcquireProducer.mFenceTime,
1146 frame->mAcquireConsumer.mFenceTime);
1147
1148 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1149
1150 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1151
1152 EXPECT_EQ(
1153 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1154 mFakeConsumer->mAddFrameTimestampsCount);
1155 }
1156
addFrameEvents(bool gpuComposited,uint64_t iOldFrame,int64_t iNewFrame)1157 void addFrameEvents(
1158 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1159 FrameEvents* oldFrame =
1160 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1161 FrameEvents* newFrame = &mFrames[iNewFrame];
1162
1163 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
1164 uint64_t nNewFrame = iNewFrame + 1;
1165
1166 // Latch, Composite, and Release the frames in a plausible order.
1167 // Note: The timestamps won't necessarily match the order, but
1168 // that's okay for the purposes of this test.
1169 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1170
1171 // Composite the previous frame one more time, which helps verify
1172 // LastRefresh is updated properly.
1173 if (oldFrame != nullptr) {
1174 mCfeh->addPreComposition(nOldFrame,
1175 oldFrame->mRefreshes[2].kStartTime);
1176 gpuDoneFenceTime = gpuComposited ?
1177 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1178 FenceTime::NO_FENCE;
1179 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
1180 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1181 oldFrame->mRefreshes[2].kCompositorTiming);
1182 }
1183
1184 // Latch the new frame.
1185 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1186
1187 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1188 gpuDoneFenceTime = gpuComposited ?
1189 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1190 FenceTime::NO_FENCE;
1191 // HWC2 releases the previous buffer after a new latch just before
1192 // calling postComposition.
1193 if (oldFrame != nullptr) {
1194 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
1195 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1196 }
1197 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1198 newFrame->mRefreshes[0].mPresent.mFenceTime,
1199 newFrame->mRefreshes[0].kCompositorTiming);
1200
1201 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1202 gpuDoneFenceTime = gpuComposited ?
1203 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1204 FenceTime::NO_FENCE;
1205 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1206 newFrame->mRefreshes[1].mPresent.mFenceTime,
1207 newFrame->mRefreshes[1].kCompositorTiming);
1208 }
1209
1210 sp<IGraphicBufferProducer> mProducer;
1211 sp<IGraphicBufferConsumer> mConsumer;
1212 sp<FakeConsumer> mFakeConsumer;
1213 ConsumerFrameEventHistory* mCfeh;
1214 sp<TestSurface> mSurface;
1215 sp<ANativeWindow> mWindow;
1216
1217 FenceToFenceTimeMap mFenceMap;
1218
1219 bool mFrameTimestampsEnabled = false;
1220
1221 int64_t outRequestedPresentTime = -1;
1222 int64_t outAcquireTime = -1;
1223 int64_t outLatchTime = -1;
1224 int64_t outFirstRefreshStartTime = -1;
1225 int64_t outLastRefreshStartTime = -1;
1226 int64_t outGpuCompositionDoneTime = -1;
1227 int64_t outDisplayPresentTime = -1;
1228 int64_t outDequeueReadyTime = -1;
1229 int64_t outReleaseTime = -1;
1230
1231 FrameEvents mFrames[3] {
1232 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
1233 };
1234
1235
1236 // This test verifies that the frame timestamps are not retrieved when not
1237 // explicitly enabled via native_window_enable_frame_timestamps.
1238 // We want to check this to make sure there's no overhead for users
1239 // that don't need the timestamp information.
TEST_F(GetFrameTimestampsTest,DefaultDisabled)1240 TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1241 int fence;
1242 ANativeWindowBuffer* buffer;
1243
1244 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1245 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1246
1247 const uint64_t fId = getNextFrameId();
1248
1249 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1250 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1251 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1252 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1253
1254 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1255 // It is okay that frame timestamps are added in the consumer since it is
1256 // still needed for SurfaceFlinger dumps.
1257 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1258 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1259 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1260
1261 // Verify attempts to get frame timestamps fail.
1262 int result = getAllFrameTimestamps(fId);
1263 EXPECT_EQ(INVALID_OPERATION, result);
1264 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1265
1266 // Verify compositor timing query fails.
1267 nsecs_t compositeDeadline = 0;
1268 nsecs_t compositeInterval = 0;
1269 nsecs_t compositeToPresentLatency = 0;
1270 result = native_window_get_compositor_timing(mWindow.get(),
1271 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1272 EXPECT_EQ(INVALID_OPERATION, result);
1273 }
1274
1275 // This test verifies that the frame timestamps are retrieved if explicitly
1276 // enabled via native_window_enable_frame_timestamps.
TEST_F(GetFrameTimestampsTest,EnabledSimple)1277 TEST_F(GetFrameTimestampsTest, EnabledSimple) {
1278 CompositorTiming initialCompositorTiming {
1279 1000000000, // 1s deadline
1280 16666667, // 16ms interval
1281 50000000, // 50ms present latency
1282 };
1283 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1284
1285 enableFrameTimestamps();
1286
1287 // Verify the compositor timing query gets the initial compositor values
1288 // after timststamps are enabled; even before the first frame is queued
1289 // or dequeued.
1290 nsecs_t compositeDeadline = 0;
1291 nsecs_t compositeInterval = 0;
1292 nsecs_t compositeToPresentLatency = 0;
1293 mSurface->setNow(initialCompositorTiming.deadline - 1);
1294 int result = native_window_get_compositor_timing(mWindow.get(),
1295 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1296 EXPECT_EQ(NO_ERROR, result);
1297 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1298 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1299 EXPECT_EQ(initialCompositorTiming.presentLatency,
1300 compositeToPresentLatency);
1301
1302 int fence;
1303 ANativeWindowBuffer* buffer;
1304
1305 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1306 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
1307
1308 const uint64_t fId1 = getNextFrameId();
1309
1310 // Verify getFrameTimestamps is piggybacked on dequeue.
1311 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1312 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1313 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
1314
1315 NewFrameEventsEntry f1;
1316 f1.frameNumber = 1;
1317 f1.postedTime = mFrames[0].kPostedTime;
1318 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1319 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1320 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1321 mFrames[0].mAcquireProducer.mFenceTime,
1322 mFrames[0].mAcquireConsumer.mFenceTime);
1323 mFakeConsumer->mNewFrameEntryOverride = f1;
1324 mFrames[0].signalQueueFences();
1325
1326 // Verify getFrameTimestamps is piggybacked on queue.
1327 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1328 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1329 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
1330 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
1331
1332 // Verify queries for timestamps that the producer doesn't know about
1333 // triggers a call to see if the consumer has any new timestamps.
1334 result = getAllFrameTimestamps(fId1);
1335 EXPECT_EQ(NO_ERROR, result);
1336 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
1337 }
1338
TEST_F(GetFrameTimestampsTest,QueryPresentSupported)1339 TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1340 bool displayPresentSupported = true;
1341 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
1342
1343 // Verify supported bits are forwarded.
1344 int supportsPresent = -1;
1345 mWindow.get()->query(mWindow.get(),
1346 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1347 EXPECT_EQ(displayPresentSupported, supportsPresent);
1348 }
1349
TEST_F(GetFrameTimestampsTest,QueryPresentNotSupported)1350 TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1351 bool displayPresentSupported = false;
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,SnapToNextTickBasic)1361 TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1362 nsecs_t phase = 4000;
1363 nsecs_t interval = 1000;
1364
1365 // Timestamp in previous interval.
1366 nsecs_t timestamp = 3500;
1367 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1368 timestamp, phase, interval));
1369
1370 // Timestamp in next interval.
1371 timestamp = 4500;
1372 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1373 timestamp, phase, interval));
1374
1375 // Timestamp multiple intervals before.
1376 timestamp = 2500;
1377 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1378 timestamp, phase, interval));
1379
1380 // Timestamp multiple intervals after.
1381 timestamp = 6500;
1382 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1383 timestamp, phase, interval));
1384
1385 // Timestamp on previous interval.
1386 timestamp = 3000;
1387 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1388 timestamp, phase, interval));
1389
1390 // Timestamp on next interval.
1391 timestamp = 5000;
1392 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1393 timestamp, phase, interval));
1394
1395 // Timestamp equal to phase.
1396 timestamp = 4000;
1397 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1398 timestamp, phase, interval));
1399 }
1400
1401 // int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1402 // if the number of intervals elapsed is internally stored in an int.
TEST_F(GetFrameTimestampsTest,SnapToNextTickOverflow)1403 TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1404 nsecs_t phase = 0;
1405 nsecs_t interval = 4000;
1406 nsecs_t big_timestamp = 8635916564000;
1407 int32_t intervals = big_timestamp / interval;
1408
1409 EXPECT_LT(intervals, 0);
1410 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1411 big_timestamp, phase, interval));
1412 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1413 big_timestamp, big_timestamp, interval));
1414 }
1415
1416 // This verifies the compositor timing is updated by refresh events
1417 // and piggy backed on a queue, dequeue, and enabling of timestamps..
TEST_F(GetFrameTimestampsTest,CompositorTimingUpdatesBasic)1418 TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
1419 CompositorTiming initialCompositorTiming {
1420 1000000000, // 1s deadline
1421 16666667, // 16ms interval
1422 50000000, // 50ms present latency
1423 };
1424 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1425
1426 enableFrameTimestamps();
1427
1428 // We get the initial values before any frames are submitted.
1429 nsecs_t compositeDeadline = 0;
1430 nsecs_t compositeInterval = 0;
1431 nsecs_t compositeToPresentLatency = 0;
1432 mSurface->setNow(initialCompositorTiming.deadline - 1);
1433 int result = native_window_get_compositor_timing(mWindow.get(),
1434 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1435 EXPECT_EQ(NO_ERROR, result);
1436 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1437 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1438 EXPECT_EQ(initialCompositorTiming.presentLatency,
1439 compositeToPresentLatency);
1440
1441 dequeueAndQueue(0);
1442 addFrameEvents(true, NO_FRAME_INDEX, 0);
1443
1444 // Still get the initial values because the frame events for frame 0
1445 // didn't get a chance to piggyback on a queue or dequeue yet.
1446 result = native_window_get_compositor_timing(mWindow.get(),
1447 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1448 EXPECT_EQ(NO_ERROR, result);
1449 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1450 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1451 EXPECT_EQ(initialCompositorTiming.presentLatency,
1452 compositeToPresentLatency);
1453
1454 dequeueAndQueue(1);
1455 addFrameEvents(true, 0, 1);
1456
1457 // Now expect the composite values associated with frame 1.
1458 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1459 result = native_window_get_compositor_timing(mWindow.get(),
1460 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1461 EXPECT_EQ(NO_ERROR, result);
1462 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1463 compositeDeadline);
1464 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1465 compositeInterval);
1466 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1467 compositeToPresentLatency);
1468
1469 dequeueAndQueue(2);
1470 addFrameEvents(true, 1, 2);
1471
1472 // Now expect the composite values associated with frame 2.
1473 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1474 result = native_window_get_compositor_timing(mWindow.get(),
1475 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1476 EXPECT_EQ(NO_ERROR, result);
1477 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1478 compositeDeadline);
1479 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1480 compositeInterval);
1481 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1482 compositeToPresentLatency);
1483
1484 // Re-enabling frame timestamps should get the latest values.
1485 disableFrameTimestamps();
1486 enableFrameTimestamps();
1487
1488 // Now expect the composite values associated with frame 3.
1489 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1490 result = native_window_get_compositor_timing(mWindow.get(),
1491 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1492 EXPECT_EQ(NO_ERROR, result);
1493 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1494 compositeDeadline);
1495 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1496 compositeInterval);
1497 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1498 compositeToPresentLatency);
1499 }
1500
1501 // This verifies the compositor deadline properly snaps to the the next
1502 // deadline based on the current time.
TEST_F(GetFrameTimestampsTest,CompositorTimingDeadlineSnaps)1503 TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
1504 CompositorTiming initialCompositorTiming {
1505 1000000000, // 1s deadline
1506 16666667, // 16ms interval
1507 50000000, // 50ms present latency
1508 };
1509 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1510
1511 enableFrameTimestamps();
1512
1513 nsecs_t compositeDeadline = 0;
1514 nsecs_t compositeInterval = 0;
1515 nsecs_t compositeToPresentLatency = 0;
1516
1517 // A "now" just before the deadline snaps to the deadline.
1518 mSurface->setNow(initialCompositorTiming.deadline - 1);
1519 int result = native_window_get_compositor_timing(mWindow.get(),
1520 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1521 EXPECT_EQ(NO_ERROR, result);
1522 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1523 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1524 EXPECT_EQ(expectedDeadline, compositeDeadline);
1525
1526 dequeueAndQueue(0);
1527 addFrameEvents(true, NO_FRAME_INDEX, 0);
1528
1529 // A "now" just after the deadline snaps properly.
1530 mSurface->setNow(initialCompositorTiming.deadline + 1);
1531 result = native_window_get_compositor_timing(mWindow.get(),
1532 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1533 EXPECT_EQ(NO_ERROR, result);
1534 expectedDeadline =
1535 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1536 EXPECT_EQ(expectedDeadline, compositeDeadline);
1537
1538 dequeueAndQueue(1);
1539 addFrameEvents(true, 0, 1);
1540
1541 // A "now" just after the next interval snaps properly.
1542 mSurface->setNow(
1543 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1544 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1545 result = native_window_get_compositor_timing(mWindow.get(),
1546 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1547 EXPECT_EQ(NO_ERROR, result);
1548 expectedDeadline =
1549 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1550 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1551 EXPECT_EQ(expectedDeadline, compositeDeadline);
1552
1553 dequeueAndQueue(2);
1554 addFrameEvents(true, 1, 2);
1555
1556 // A "now" over 1 interval before the deadline snaps properly.
1557 mSurface->setNow(
1558 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1559 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1560 result = native_window_get_compositor_timing(mWindow.get(),
1561 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1562 EXPECT_EQ(NO_ERROR, result);
1563 expectedDeadline =
1564 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1565 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1566 EXPECT_EQ(expectedDeadline, compositeDeadline);
1567
1568 // Re-enabling frame timestamps should get the latest values.
1569 disableFrameTimestamps();
1570 enableFrameTimestamps();
1571
1572 // A "now" over 2 intervals before the deadline snaps properly.
1573 mSurface->setNow(
1574 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1575 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1576 result = native_window_get_compositor_timing(mWindow.get(),
1577 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1578 EXPECT_EQ(NO_ERROR, result);
1579 expectedDeadline =
1580 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1581 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1582 EXPECT_EQ(expectedDeadline, compositeDeadline);
1583 }
1584
1585 // This verifies the timestamps recorded in the consumer's
1586 // FrameTimestampsHistory are properly retrieved by the producer for the
1587 // correct frames.
TEST_F(GetFrameTimestampsTest,TimestampsAssociatedWithCorrectFrame)1588 TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1589 enableFrameTimestamps();
1590
1591 const uint64_t fId1 = getNextFrameId();
1592 dequeueAndQueue(0);
1593 mFrames[0].signalQueueFences();
1594
1595 const uint64_t fId2 = getNextFrameId();
1596 dequeueAndQueue(1);
1597 mFrames[1].signalQueueFences();
1598
1599 addFrameEvents(true, NO_FRAME_INDEX, 0);
1600 mFrames[0].signalRefreshFences();
1601 addFrameEvents(true, 0, 1);
1602 mFrames[0].signalReleaseFences();
1603 mFrames[1].signalRefreshFences();
1604
1605 // Verify timestamps are correct for frame 1.
1606 resetTimestamps();
1607 int result = getAllFrameTimestamps(fId1);
1608 EXPECT_EQ(NO_ERROR, result);
1609 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1610 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1611 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1612 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1613 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1614 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1615 outGpuCompositionDoneTime);
1616 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1617 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1618 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1619
1620 // Verify timestamps are correct for frame 2.
1621 resetTimestamps();
1622 result = getAllFrameTimestamps(fId2);
1623 EXPECT_EQ(NO_ERROR, result);
1624 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1625 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1626 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1627 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1628 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1629 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1630 outGpuCompositionDoneTime);
1631 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1632 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1633 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1634 }
1635
1636 // This test verifies the acquire fence recorded by the consumer is not sent
1637 // back to the producer and the producer saves its own fence.
TEST_F(GetFrameTimestampsTest,QueueTimestampsNoSync)1638 TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1639 enableFrameTimestamps();
1640
1641 // Dequeue and queue frame 1.
1642 const uint64_t fId1 = getNextFrameId();
1643 dequeueAndQueue(0);
1644
1645 // Verify queue-related timestamps for f1 are available immediately in the
1646 // producer without asking the consumer again, even before signaling the
1647 // acquire fence.
1648 resetTimestamps();
1649 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1650 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1651 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1652 nullptr, nullptr, nullptr, nullptr, nullptr);
1653 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1654 EXPECT_EQ(NO_ERROR, result);
1655 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1656 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1657
1658 // Signal acquire fences. Verify a sync call still isn't necessary.
1659 mFrames[0].signalQueueFences();
1660
1661 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1662 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1663 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1664 nullptr, nullptr, nullptr, nullptr, nullptr);
1665 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1666 EXPECT_EQ(NO_ERROR, result);
1667 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1668 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1669
1670 // Dequeue and queue frame 2.
1671 const uint64_t fId2 = getNextFrameId();
1672 dequeueAndQueue(1);
1673
1674 // Verify queue-related timestamps for f2 are available immediately in the
1675 // producer without asking the consumer again, even before signaling the
1676 // acquire fence.
1677 resetTimestamps();
1678 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1679 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1680 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1681 nullptr, nullptr, nullptr, nullptr, nullptr);
1682 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1683 EXPECT_EQ(NO_ERROR, result);
1684 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1685 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1686
1687 // Signal acquire fences. Verify a sync call still isn't necessary.
1688 mFrames[1].signalQueueFences();
1689
1690 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1691 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1692 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1693 nullptr, nullptr, nullptr, nullptr, nullptr);
1694 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1695 EXPECT_EQ(NO_ERROR, result);
1696 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1697 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1698 }
1699
TEST_F(GetFrameTimestampsTest,ZeroRequestedTimestampsNoSync)1700 TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1701 enableFrameTimestamps();
1702
1703 // Dequeue and queue frame 1.
1704 dequeueAndQueue(0);
1705 mFrames[0].signalQueueFences();
1706
1707 // Dequeue and queue frame 2.
1708 const uint64_t fId2 = getNextFrameId();
1709 dequeueAndQueue(1);
1710 mFrames[1].signalQueueFences();
1711
1712 addFrameEvents(true, NO_FRAME_INDEX, 0);
1713 mFrames[0].signalRefreshFences();
1714 addFrameEvents(true, 0, 1);
1715 mFrames[0].signalReleaseFences();
1716 mFrames[1].signalRefreshFences();
1717
1718 // Verify a request for no timestamps doesn't result in a sync call.
1719 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1720 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1721 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1722 nullptr, nullptr);
1723 EXPECT_EQ(NO_ERROR, result);
1724 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1725 }
1726
1727 // This test verifies that fences can signal and update timestamps producer
1728 // side without an additional sync call to the consumer.
TEST_F(GetFrameTimestampsTest,FencesInProducerNoSync)1729 TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1730 enableFrameTimestamps();
1731
1732 // Dequeue and queue frame 1.
1733 const uint64_t fId1 = getNextFrameId();
1734 dequeueAndQueue(0);
1735 mFrames[0].signalQueueFences();
1736
1737 // Dequeue and queue frame 2.
1738 dequeueAndQueue(1);
1739 mFrames[1].signalQueueFences();
1740
1741 addFrameEvents(true, NO_FRAME_INDEX, 0);
1742 addFrameEvents(true, 0, 1);
1743
1744 // Verify available timestamps are correct for frame 1, before any
1745 // fence has been signaled.
1746 // Note: A sync call is necessary here since the events triggered by
1747 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1748 resetTimestamps();
1749 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1750 int result = getAllFrameTimestamps(fId1);
1751 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1752 EXPECT_EQ(NO_ERROR, result);
1753 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1754 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1755 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1756 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1757 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1758 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1759 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1760 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1761 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1762
1763 // Verify available timestamps are correct for frame 1 again, before any
1764 // fence has been signaled.
1765 // This time a sync call should not be necessary.
1766 resetTimestamps();
1767 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1768 result = getAllFrameTimestamps(fId1);
1769 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1770 EXPECT_EQ(NO_ERROR, result);
1771 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1772 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1773 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1774 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1775 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1776 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1777 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1778 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1779 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1780
1781 // Signal the fences for frame 1.
1782 mFrames[0].signalRefreshFences();
1783 mFrames[0].signalReleaseFences();
1784
1785 // Verify all timestamps are available without a sync call.
1786 resetTimestamps();
1787 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1788 result = getAllFrameTimestamps(fId1);
1789 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1790 EXPECT_EQ(NO_ERROR, result);
1791 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1792 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1793 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1794 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1795 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1796 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1797 outGpuCompositionDoneTime);
1798 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1799 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1800 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1801 }
1802
1803 // This test verifies that if the frame wasn't GPU composited but has a refresh
1804 // event a sync call isn't made to get the GPU composite done time since it will
1805 // never exist.
TEST_F(GetFrameTimestampsTest,NoGpuNoSync)1806 TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1807 enableFrameTimestamps();
1808
1809 // Dequeue and queue frame 1.
1810 const uint64_t fId1 = getNextFrameId();
1811 dequeueAndQueue(0);
1812 mFrames[0].signalQueueFences();
1813
1814 // Dequeue and queue frame 2.
1815 dequeueAndQueue(1);
1816 mFrames[1].signalQueueFences();
1817
1818 addFrameEvents(false, NO_FRAME_INDEX, 0);
1819 addFrameEvents(false, 0, 1);
1820
1821 // Verify available timestamps are correct for frame 1, before any
1822 // fence has been signaled.
1823 // Note: A sync call is necessary here since the events triggered by
1824 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1825 resetTimestamps();
1826 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1827 int result = getAllFrameTimestamps(fId1);
1828 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1829 EXPECT_EQ(NO_ERROR, result);
1830 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1831 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1832 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1833 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1834 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1835 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1836 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1837 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1838 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1839
1840 // Signal the fences for frame 1.
1841 mFrames[0].signalRefreshFences();
1842 mFrames[0].signalReleaseFences();
1843
1844 // Verify all timestamps, except GPU composition, are available without a
1845 // sync call.
1846 resetTimestamps();
1847 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1848 result = getAllFrameTimestamps(fId1);
1849 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1850 EXPECT_EQ(NO_ERROR, result);
1851 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1852 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1853 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1854 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1855 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1856 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1857 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1858 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1859 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1860 }
1861
1862 // This test verifies that if the certain timestamps can't possibly exist for
1863 // the most recent frame, then a sync call is not done.
TEST_F(GetFrameTimestampsTest,NoReleaseNoSync)1864 TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
1865 enableFrameTimestamps();
1866
1867 // Dequeue and queue frame 1.
1868 const uint64_t fId1 = getNextFrameId();
1869 dequeueAndQueue(0);
1870 mFrames[0].signalQueueFences();
1871
1872 // Dequeue and queue frame 2.
1873 const uint64_t fId2 = getNextFrameId();
1874 dequeueAndQueue(1);
1875 mFrames[1].signalQueueFences();
1876
1877 addFrameEvents(false, NO_FRAME_INDEX, 0);
1878 addFrameEvents(false, 0, 1);
1879
1880 // Verify available timestamps are correct for frame 1, before any
1881 // fence has been signaled.
1882 // Note: A sync call is necessary here since the events triggered by
1883 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1884 resetTimestamps();
1885 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1886 int result = getAllFrameTimestamps(fId1);
1887 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1888 EXPECT_EQ(NO_ERROR, result);
1889 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1890 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1891 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1892 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1893 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1894 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1895 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1896 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1897 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1898
1899 mFrames[0].signalRefreshFences();
1900 mFrames[0].signalReleaseFences();
1901 mFrames[1].signalRefreshFences();
1902
1903 // Verify querying for all timestmaps of f2 does not do a sync call. Even
1904 // though the lastRefresh, dequeueReady, and release times aren't
1905 // available, a sync call should not occur because it's not possible for f2
1906 // to encounter the final value for those events until another frame is
1907 // queued.
1908 resetTimestamps();
1909 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1910 result = getAllFrameTimestamps(fId2);
1911 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1912 EXPECT_EQ(NO_ERROR, result);
1913 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1914 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1915 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1916 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1917 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1918 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1919 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1920 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1921 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1922 }
1923
1924 // This test verifies there are no sync calls for present times
1925 // when they aren't supported and that an error is returned.
1926
TEST_F(GetFrameTimestampsTest,PresentUnsupportedNoSync)1927 TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
1928 enableFrameTimestamps();
1929 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
1930
1931 // Dequeue and queue frame 1.
1932 const uint64_t fId1 = getNextFrameId();
1933 dequeueAndQueue(0);
1934
1935 // Verify a query for the Present times do not trigger a sync call if they
1936 // are not supported.
1937 resetTimestamps();
1938 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1939 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1940 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1941 &outDisplayPresentTime, nullptr, nullptr);
1942 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1943 EXPECT_EQ(BAD_VALUE, result);
1944 EXPECT_EQ(-1, outDisplayPresentTime);
1945 }
1946
TEST_F(SurfaceTest,DequeueWithConsumerDrivenSize)1947 TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
1948 sp<IGraphicBufferProducer> producer;
1949 sp<IGraphicBufferConsumer> consumer;
1950 BufferQueue::createBufferQueue(&producer, &consumer);
1951
1952 sp<MockConsumer> mockConsumer(new MockConsumer);
1953 consumer->consumerConnect(mockConsumer, false);
1954 consumer->setDefaultBufferSize(10, 10);
1955
1956 sp<Surface> surface = new Surface(producer);
1957 sp<ANativeWindow> window(surface);
1958 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
1959 native_window_set_buffers_dimensions(window.get(), 0, 0);
1960
1961 int fence;
1962 ANativeWindowBuffer* buffer;
1963
1964 // Buffer size is driven by the consumer
1965 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1966 EXPECT_EQ(10, buffer->width);
1967 EXPECT_EQ(10, buffer->height);
1968 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1969
1970 // Buffer size is driven by the consumer
1971 consumer->setDefaultBufferSize(10, 20);
1972 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1973 EXPECT_EQ(10, buffer->width);
1974 EXPECT_EQ(20, buffer->height);
1975 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1976
1977 // Transform hint isn't synced to producer before queueBuffer or connect
1978 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
1979 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1980 EXPECT_EQ(10, buffer->width);
1981 EXPECT_EQ(20, buffer->height);
1982 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
1983
1984 // Transform hint is synced to producer but no auto prerotation
1985 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
1986 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1987 EXPECT_EQ(10, buffer->width);
1988 EXPECT_EQ(20, buffer->height);
1989 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1990
1991 // Prerotation is driven by the consumer with the transform hint used by producer
1992 native_window_set_auto_prerotation(window.get(), true);
1993 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
1994 EXPECT_EQ(20, buffer->width);
1995 EXPECT_EQ(10, buffer->height);
1996 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
1997
1998 // Turn off auto prerotaton
1999 native_window_set_auto_prerotation(window.get(), false);
2000 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2001 EXPECT_EQ(10, buffer->width);
2002 EXPECT_EQ(20, buffer->height);
2003 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2004
2005 // Test auto prerotation bit is disabled after disconnect
2006 native_window_set_auto_prerotation(window.get(), true);
2007 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2008 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2009 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2010 native_window_set_buffers_dimensions(window.get(), 0, 0);
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_F(SurfaceTest,DefaultMaxBufferCountSetAndUpdated)2017 TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2018 sp<IGraphicBufferProducer> producer;
2019 sp<IGraphicBufferConsumer> consumer;
2020 BufferQueue::createBufferQueue(&producer, &consumer);
2021
2022 sp<MockConsumer> mockConsumer(new MockConsumer);
2023 consumer->consumerConnect(mockConsumer, false);
2024
2025 sp<Surface> surface = new Surface(producer);
2026 sp<ANativeWindow> window(surface);
2027
2028 int count = -1;
2029 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2030 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2031
2032 consumer->setMaxBufferCount(10);
2033 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2034 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2035 EXPECT_EQ(10, count);
2036
2037 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2038 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2039 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2040 }
2041
TEST_F(SurfaceTest,BatchOperations)2042 TEST_F(SurfaceTest, BatchOperations) {
2043 const int BUFFER_COUNT = 16;
2044 const int BATCH_SIZE = 8;
2045 sp<IGraphicBufferProducer> producer;
2046 sp<IGraphicBufferConsumer> consumer;
2047 BufferQueue::createBufferQueue(&producer, &consumer);
2048
2049 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2050 sp<Surface> surface = new Surface(producer);
2051 sp<ANativeWindow> window(surface);
2052 sp<StubProducerListener> listener = new StubProducerListener();
2053
2054 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2055 /*reportBufferRemoval*/false));
2056
2057 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2058
2059 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2060
2061 // Batch dequeued buffers can be queued individually
2062 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2063 for (size_t i = 0; i < BATCH_SIZE; i++) {
2064 ANativeWindowBuffer* buffer = buffers[i].buffer;
2065 int fence = buffers[i].fenceFd;
2066 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2067 }
2068
2069 // Batch dequeued buffers can be canceled individually
2070 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2071 for (size_t i = 0; i < BATCH_SIZE; i++) {
2072 ANativeWindowBuffer* buffer = buffers[i].buffer;
2073 int fence = buffers[i].fenceFd;
2074 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2075 }
2076
2077 // Batch dequeued buffers can be batch cancelled
2078 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2079 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2080
2081 // Batch dequeued buffers can be batch queued
2082 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2083 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2084 for (size_t i = 0; i < BATCH_SIZE; i++) {
2085 queuedBuffers[i].buffer = buffers[i].buffer;
2086 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2087 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2088 }
2089 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2090
2091 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2092 }
2093
TEST_F(SurfaceTest,BatchIllegalOperations)2094 TEST_F(SurfaceTest, BatchIllegalOperations) {
2095 const int BUFFER_COUNT = 16;
2096 const int BATCH_SIZE = 8;
2097 sp<IGraphicBufferProducer> producer;
2098 sp<IGraphicBufferConsumer> consumer;
2099 BufferQueue::createBufferQueue(&producer, &consumer);
2100
2101 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
2102 sp<Surface> surface = new Surface(producer);
2103 sp<ANativeWindow> window(surface);
2104 sp<StubProducerListener> listener = new StubProducerListener();
2105
2106 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2107 /*reportBufferRemoval*/false));
2108
2109 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2110
2111 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2112 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2113
2114 // Batch operations are invalid in shared buffer mode
2115 surface->setSharedBufferMode(true);
2116 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2117 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2118 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2119 surface->setSharedBufferMode(false);
2120
2121 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2122 }
2123
2124 } // namespace android
2125