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 "gui/view/Surface.h"
18 #include "Constants.h"
19 #include "MockConsumer.h"
20
21 #include <gtest/gtest.h>
22
23 #include <SurfaceFlingerProperties.h>
24 #include <android/gui/IActivePictureListener.h>
25 #include <android/gui/IDisplayEventConnection.h>
26 #include <android/gui/ISurfaceComposer.h>
27 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
28 #include <android/hardware_buffer.h>
29 #include <binder/ProcessState.h>
30 #include <com_android_graphics_libgui_flags.h>
31 #include <configstore/Utils.h>
32 #include <gui/AidlUtil.h>
33 #include <gui/BufferItemConsumer.h>
34 #include <gui/BufferQueue.h>
35 #include <gui/CpuConsumer.h>
36 #include <gui/IConsumerListener.h>
37 #include <gui/IGraphicBufferConsumer.h>
38 #include <gui/IGraphicBufferProducer.h>
39 #include <gui/ISurfaceComposer.h>
40 #include <gui/Surface.h>
41 #include <gui/SurfaceComposerClient.h>
42 #include <gui/SyncScreenCaptureListener.h>
43 #include <private/gui/ComposerService.h>
44 #include <private/gui/ComposerServiceAIDL.h>
45 #include <sys/types.h>
46 #include <system/window.h>
47 #include <ui/BufferQueueDefs.h>
48 #include <ui/DisplayMode.h>
49 #include <ui/GraphicBuffer.h>
50 #include <ui/Rect.h>
51 #include <utils/Errors.h>
52 #include <utils/String8.h>
53
54 #include <chrono>
55 #include <cstddef>
56 #include <cstdint>
57 #include <future>
58 #include <limits>
59 #include <thread>
60
61 #include "testserver/TestServerClient.h"
62
63 namespace android {
64
65 using namespace std::chrono_literals;
66 // retrieve wide-color and hdr settings from configstore
67 using namespace android::hardware::configstore;
68 using namespace android::hardware::configstore::V1_0;
69 using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
70 using gui::IDisplayEventConnection;
71 using gui::IRegionSamplingListener;
72 using ui::ColorMode;
73
74 using Transaction = SurfaceComposerClient::Transaction;
75
76 static bool hasWideColorDisplay = android::sysprop::has_wide_color_display(false);
77
78 static bool hasHdrDisplay = android::sysprop::has_HDR_display(false);
79
80 class FakeSurfaceComposer;
81 class FakeProducerFrameEventHistory;
82
83 static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
84
85 class FakeSurfaceListener : public SurfaceListener {
86 public:
FakeSurfaceListener(bool enableReleasedCb=false)87 FakeSurfaceListener(bool enableReleasedCb = false)
88 : mEnableReleaseCb(enableReleasedCb), mBuffersReleased(0) {}
89 virtual ~FakeSurfaceListener() = default;
90
onBufferReleased()91 virtual void onBufferReleased() {
92 mBuffersReleased++;
93 }
needsReleaseNotify()94 virtual bool needsReleaseNotify() {
95 return mEnableReleaseCb;
96 }
onBuffersDiscarded(const std::vector<sp<GraphicBuffer>> & buffers)97 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers) {
98 mDiscardedBuffers.insert(mDiscardedBuffers.end(), buffers.begin(), buffers.end());
99 }
onBufferDetached(int)100 virtual void onBufferDetached(int /*slot*/) {}
getReleaseNotifyCount() const101 int getReleaseNotifyCount() const {
102 return mBuffersReleased;
103 }
getDiscardedBuffers() const104 const std::vector<sp<GraphicBuffer>>& getDiscardedBuffers() const {
105 return mDiscardedBuffers;
106 }
107 private:
108 // No need to use lock given the test triggers the listener in the same
109 // thread context.
110 bool mEnableReleaseCb;
111 int32_t mBuffersReleased;
112 std::vector<sp<GraphicBuffer>> mDiscardedBuffers;
113 };
114
115 class DeathWatcherListener : public StubSurfaceListener {
116 public:
onRemoteDied()117 virtual void onRemoteDied() { mDiedPromise.set_value(true); }
118
needsDeathNotify()119 virtual bool needsDeathNotify() { return true; }
120
getDiedFuture()121 std::future<bool> getDiedFuture() { return mDiedPromise.get_future(); }
122
123 private:
124 std::promise<bool> mDiedPromise;
125 };
126
127 class SurfaceTest : public ::testing::Test {
128 protected:
SurfaceTest()129 SurfaceTest() {
130 ProcessState::self()->startThreadPool();
131 }
132
SetUp()133 virtual void SetUp() {
134 mComposerClient = new SurfaceComposerClient;
135 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
136
137 // TODO(brianderson): The following sometimes fails and is a source of
138 // test flakiness.
139 mSurfaceControl = mComposerClient->createSurface(
140 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
141 SurfaceComposerClient::Transaction().apply(true);
142
143 ASSERT_TRUE(mSurfaceControl != nullptr);
144 ASSERT_TRUE(mSurfaceControl->isValid());
145
146 Transaction t;
147 ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff).show(mSurfaceControl).apply());
148
149 mSurface = mSurfaceControl->getSurface();
150 ASSERT_TRUE(mSurface != nullptr);
151 }
152
TearDown()153 virtual void TearDown() {
154 mComposerClient->dispose();
155 }
156
testSurfaceListener(bool hasSurfaceListener,bool enableReleasedCb,int32_t extraDiscardedBuffers)157 void testSurfaceListener(bool hasSurfaceListener, bool enableReleasedCb,
158 int32_t extraDiscardedBuffers) {
159 sp<IGraphicBufferProducer> producer;
160 sp<IGraphicBufferConsumer> consumer;
161 BufferQueue::createBufferQueue(&producer, &consumer);
162
163 sp<MockConsumer> mockConsumer(new MockConsumer);
164 consumer->consumerConnect(mockConsumer, false);
165 consumer->setConsumerName(String8("TestConsumer"));
166
167 sp<Surface> surface = new Surface(producer);
168 sp<ANativeWindow> window(surface);
169 sp<FakeSurfaceListener> listener;
170 if (hasSurfaceListener) {
171 listener = new FakeSurfaceListener(enableReleasedCb);
172 }
173 ASSERT_EQ(OK,
174 surface->connect(NATIVE_WINDOW_API_CPU,
175 /*listener*/ listener,
176 /*reportBufferRemoval*/ true));
177 const int BUFFER_COUNT = 4 + extraDiscardedBuffers;
178 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
179 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
180
181 ANativeWindowBuffer* buffers[BUFFER_COUNT];
182 // Dequeue first to allocate a number of buffers
183 for (int i = 0; i < BUFFER_COUNT; i++) {
184 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffers[i]));
185 }
186 for (int i = 0; i < BUFFER_COUNT; i++) {
187 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], -1));
188 }
189
190 ANativeWindowBuffer* buffer;
191 // Fill BUFFER_COUNT-1 buffers
192 for (int i = 0; i < BUFFER_COUNT-1; i++) {
193 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
194 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, -1));
195 }
196
197 // Dequeue 1 buffer
198 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(window.get(), &buffer));
199
200 // Acquire and free 1+extraDiscardedBuffers buffer, check onBufferReleased is called.
201 std::vector<BufferItem> releasedItems;
202 releasedItems.resize(1+extraDiscardedBuffers);
203 for (size_t i = 0; i < releasedItems.size(); i++) {
204 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&releasedItems[i], 0));
205 ASSERT_EQ(NO_ERROR,
206 consumer->releaseBuffer(releasedItems[i].mSlot, releasedItems[i].mFrameNumber,
207 Fence::NO_FENCE));
208 }
209 int32_t expectedReleaseCb = (enableReleasedCb ? releasedItems.size() : 0);
210 if (hasSurfaceListener) {
211 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
212 }
213
214 // Acquire 1 buffer, leaving 1+extraDiscardedBuffers filled buffer in queue
215 BufferItem item;
216 ASSERT_EQ(NO_ERROR, consumer->acquireBuffer(&item, 0));
217
218 // Discard free buffers
219 ASSERT_EQ(NO_ERROR, consumer->discardFreeBuffers());
220
221 if (hasSurfaceListener) {
222 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
223
224 // Check onBufferDiscarded is called with correct buffer
225 auto discardedBuffers = listener->getDiscardedBuffers();
226 ASSERT_EQ(discardedBuffers.size(), releasedItems.size());
227 for (size_t i = 0; i < releasedItems.size(); i++) {
228 ASSERT_EQ(discardedBuffers[i], releasedItems[i].mGraphicBuffer);
229 }
230
231 ASSERT_EQ(expectedReleaseCb, listener->getReleaseNotifyCount());
232 }
233
234 // Disconnect the surface
235 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
236 }
237
238 sp<Surface> mSurface;
239 sp<SurfaceComposerClient> mComposerClient;
240 sp<SurfaceControl> mSurfaceControl;
241 };
242
TEST_F(SurfaceTest,CreateSurfaceReturnsErrorBadClient)243 TEST_F(SurfaceTest, CreateSurfaceReturnsErrorBadClient) {
244 mComposerClient->dispose();
245 ASSERT_EQ(NO_INIT, mComposerClient->initCheck());
246
247 sp<SurfaceControl> sc;
248 status_t err = mComposerClient->createSurfaceChecked(
249 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, &sc, 0);
250 ASSERT_EQ(NO_INIT, err);
251 }
252
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenVisible)253 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
254 sp<ANativeWindow> anw(mSurface);
255 int result = -123;
256 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
257 &result);
258 EXPECT_EQ(NO_ERROR, err);
259 EXPECT_EQ(1, result);
260 }
261
TEST_F(SurfaceTest,QueuesToWindowComposerIsTrueWhenPurgatorized)262 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
263 mSurfaceControl.clear();
264 // Wait for the async clean-up to complete.
265 std::this_thread::sleep_for(50ms);
266
267 sp<ANativeWindow> anw(mSurface);
268 int result = -123;
269 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
270 &result);
271 EXPECT_EQ(NO_ERROR, err);
272 EXPECT_EQ(1, result);
273 }
274
TEST_F(SurfaceTest,ConcreteTypeIsSurface)275 TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
276 sp<ANativeWindow> anw(mSurface);
277 int result = -123;
278 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
279 EXPECT_EQ(NO_ERROR, err);
280 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
281 }
282
TEST_F(SurfaceTest,LayerCountIsOne)283 TEST_F(SurfaceTest, LayerCountIsOne) {
284 sp<ANativeWindow> anw(mSurface);
285 int result = -123;
286 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
287 EXPECT_EQ(NO_ERROR, err);
288 EXPECT_EQ(1, result);
289 }
290
TEST_F(SurfaceTest,QueryConsumerUsage)291 TEST_F(SurfaceTest, QueryConsumerUsage) {
292 const int TEST_USAGE_FLAGS =
293 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
294 sp<BufferItemConsumer> c = new BufferItemConsumer(TEST_USAGE_FLAGS);
295
296 sp<Surface> s = c->getSurface();
297 sp<ANativeWindow> anw(s);
298
299 int flags = -1;
300 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
301
302 ASSERT_EQ(NO_ERROR, err);
303 ASSERT_EQ(TEST_USAGE_FLAGS, flags);
304 }
305
TEST_F(SurfaceTest,QueryDefaultBuffersDataSpace)306 TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
307 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_V0_SRGB;
308
309 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
310 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
311
312 sp<Surface> s = cpuConsumer->getSurface();
313 sp<ANativeWindow> anw(s);
314
315 android_dataspace dataSpace;
316
317 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
318 reinterpret_cast<int*>(&dataSpace));
319
320 ASSERT_EQ(NO_ERROR, err);
321 ASSERT_EQ(TEST_DATASPACE, dataSpace);
322 }
323
TEST_F(SurfaceTest,SettingGenerationNumber)324 TEST_F(SurfaceTest, SettingGenerationNumber) {
325 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
326 sp<Surface> surface = cpuConsumer->getSurface();
327 sp<ANativeWindow> window(surface);
328
329 // Allocate a buffer with a generation number of 0
330 ANativeWindowBuffer* buffer;
331 int fenceFd;
332 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
333 NATIVE_WINDOW_API_CPU));
334 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
335 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
336
337 // Detach the buffer and check its generation number
338 sp<GraphicBuffer> graphicBuffer;
339 sp<Fence> fence;
340 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
341 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
342
343 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
344 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
345
346 // This should change the generation number of the GraphicBuffer
347 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
348
349 // Check that the new generation number sticks with the buffer
350 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
351 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
352 graphicBuffer = static_cast<GraphicBuffer*>(buffer);
353 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
354 }
355
TEST_F(SurfaceTest,GetConsumerName)356 TEST_F(SurfaceTest, GetConsumerName) {
357 sp<IGraphicBufferProducer> producer;
358 sp<IGraphicBufferConsumer> consumer;
359 BufferQueue::createBufferQueue(&producer, &consumer);
360
361 sp<MockConsumer> mockConsumer(new MockConsumer);
362 consumer->consumerConnect(mockConsumer, false);
363 consumer->setConsumerName(String8("TestConsumer"));
364
365 sp<Surface> surface = new Surface(producer);
366 sp<ANativeWindow> window(surface);
367 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
368
369 EXPECT_STREQ("TestConsumer", surface->getConsumerName().c_str());
370 }
371
TEST_F(SurfaceTest,GetWideColorSupport)372 TEST_F(SurfaceTest, GetWideColorSupport) {
373 sp<IGraphicBufferProducer> producer;
374 sp<IGraphicBufferConsumer> consumer;
375 BufferQueue::createBufferQueue(&producer, &consumer);
376
377 sp<MockConsumer> mockConsumer(new MockConsumer);
378 consumer->consumerConnect(mockConsumer, false);
379 consumer->setConsumerName(String8("TestConsumer"));
380
381 sp<Surface> surface = new Surface(producer);
382 sp<ANativeWindow> window(surface);
383 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
384
385 bool supported;
386 surface->getWideColorSupport(&supported);
387
388 // NOTE: This test assumes that device that supports
389 // wide-color (as indicated by BoardConfig) must also
390 // have a wide-color primary display.
391 // That assumption allows this test to cover devices
392 // that advertised a wide-color color mode without
393 // actually supporting wide-color to pass this test
394 // as well as the case of a device that does support
395 // wide-color (via BoardConfig) and has a wide-color
396 // primary display.
397 // NOT covered at this time is a device that supports
398 // wide color in the BoardConfig but does not support
399 // a wide-color color mode on the primary display.
400 ASSERT_EQ(hasWideColorDisplay, supported);
401 }
402
TEST_F(SurfaceTest,GetHdrSupport)403 TEST_F(SurfaceTest, GetHdrSupport) {
404 sp<IGraphicBufferProducer> producer;
405 sp<IGraphicBufferConsumer> consumer;
406 BufferQueue::createBufferQueue(&producer, &consumer);
407
408 sp<MockConsumer> mockConsumer(new MockConsumer);
409 consumer->consumerConnect(mockConsumer, false);
410 consumer->setConsumerName(String8("TestConsumer"));
411
412 sp<Surface> surface = new Surface(producer);
413 sp<ANativeWindow> window(surface);
414 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
415
416 bool supported;
417 status_t result = surface->getHdrSupport(&supported);
418 ASSERT_EQ(NO_ERROR, result);
419
420 // NOTE: This is not a CTS test.
421 // This test verifies that when the BoardConfig TARGET_HAS_HDR_DISPLAY
422 // is TRUE, getHdrSupport is also true.
423 // TODO: Add check for an HDR color mode on the primary display.
424 ASSERT_EQ(hasHdrDisplay, supported);
425 }
426
TEST_F(SurfaceTest,SetHdrMetadata)427 TEST_F(SurfaceTest, SetHdrMetadata) {
428 sp<IGraphicBufferProducer> producer;
429 sp<IGraphicBufferConsumer> consumer;
430 BufferQueue::createBufferQueue(&producer, &consumer);
431
432 sp<MockConsumer> mockConsumer(new MockConsumer);
433 consumer->consumerConnect(mockConsumer, false);
434 consumer->setConsumerName(String8("TestConsumer"));
435
436 sp<Surface> surface = new Surface(producer);
437 sp<ANativeWindow> window(surface);
438 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
439
440 bool supported;
441 status_t result = surface->getHdrSupport(&supported);
442 ASSERT_EQ(NO_ERROR, result);
443
444 if (!hasHdrDisplay || !supported) {
445 return;
446 }
447 const android_smpte2086_metadata smpte2086 = {
448 {0.680, 0.320},
449 {0.265, 0.690},
450 {0.150, 0.060},
451 {0.3127, 0.3290},
452 100.0,
453 0.1,
454 };
455 const android_cta861_3_metadata cta861_3 = {
456 78.0,
457 62.0,
458 };
459
460 std::vector<uint8_t> hdr10plus;
461 hdr10plus.push_back(0xff);
462
463 int error = native_window_set_buffers_smpte2086_metadata(window.get(), &smpte2086);
464 ASSERT_EQ(error, NO_ERROR);
465 error = native_window_set_buffers_cta861_3_metadata(window.get(), &cta861_3);
466 ASSERT_EQ(error, NO_ERROR);
467 error = native_window_set_buffers_hdr10_plus_metadata(window.get(), hdr10plus.size(),
468 hdr10plus.data());
469 ASSERT_EQ(error, NO_ERROR);
470 }
471
TEST_F(SurfaceTest,DynamicSetBufferCount)472 TEST_F(SurfaceTest, DynamicSetBufferCount) {
473 sp<IGraphicBufferProducer> producer;
474 sp<IGraphicBufferConsumer> consumer;
475 BufferQueue::createBufferQueue(&producer, &consumer);
476
477 sp<MockConsumer> mockConsumer(new MockConsumer);
478 consumer->consumerConnect(mockConsumer, false);
479 consumer->setConsumerName(String8("TestConsumer"));
480
481 sp<Surface> surface = new Surface(producer);
482 sp<ANativeWindow> window(surface);
483
484 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
485 NATIVE_WINDOW_API_CPU));
486 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), 4));
487 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
488
489 int fence;
490 ANativeWindowBuffer* buffer;
491 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
492 native_window_set_buffer_count(window.get(), 3);
493 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
494 native_window_set_buffer_count(window.get(), 2);
495 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
496 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
497 }
498
TEST_F(SurfaceTest,GetAndFlushRemovedBuffers)499 TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
500 sp<IGraphicBufferProducer> producer;
501 sp<IGraphicBufferConsumer> consumer;
502 BufferQueue::createBufferQueue(&producer, &consumer);
503
504 sp<MockConsumer> mockConsumer(new MockConsumer);
505 consumer->consumerConnect(mockConsumer, false);
506 consumer->setConsumerName(String8("TestConsumer"));
507
508 sp<Surface> surface = new Surface(producer);
509 sp<ANativeWindow> window(surface);
510 sp<StubSurfaceListener> listener = new StubSurfaceListener();
511 ASSERT_EQ(OK,
512 surface->connect(NATIVE_WINDOW_API_CPU,
513 /*listener*/ listener,
514 /*reportBufferRemoval*/ true));
515 const int BUFFER_COUNT = 4;
516 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
517 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
518
519 sp<GraphicBuffer> detachedBuffer;
520 sp<Fence> outFence;
521 int fences[BUFFER_COUNT];
522 ANativeWindowBuffer* buffers[BUFFER_COUNT];
523 // Allocate buffers because detachNextBuffer requires allocated buffers
524 for (int i = 0; i < BUFFER_COUNT; i++) {
525 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
526 }
527 for (int i = 0; i < BUFFER_COUNT; i++) {
528 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
529 }
530
531 // Test detached buffer is correctly reported
532 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
533 std::vector<sp<GraphicBuffer>> removedBuffers;
534 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
535 ASSERT_EQ(1u, removedBuffers.size());
536 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
537 // Test the list is flushed one getAndFlushRemovedBuffers returns
538 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
539 ASSERT_EQ(0u, removedBuffers.size());
540
541
542 // Test removed buffer list is cleanup after next dequeueBuffer call
543 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
544 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
545 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
546 ASSERT_EQ(0u, removedBuffers.size());
547 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
548
549 // Test removed buffer list is cleanup after next detachNextBuffer call
550 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
551 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
552 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
553 ASSERT_EQ(1u, removedBuffers.size());
554 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
555
556 // Re-allocate buffers since all buffers are detached up to now
557 for (int i = 0; i < BUFFER_COUNT; i++) {
558 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
559 }
560 for (int i = 0; i < BUFFER_COUNT; i++) {
561 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
562 }
563
564 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
565 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
566 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
567 // Depends on which slot GraphicBufferProducer impl pick, the attach call might
568 // get 0 or 1 buffer removed.
569 ASSERT_LE(removedBuffers.size(), 1u);
570 }
571
TEST_F(SurfaceTest,SurfaceListenerTest)572 TEST_F(SurfaceTest, SurfaceListenerTest) {
573 // Test discarding 1 free buffers with no listener
574 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/0);
575 // Test discarding 2 free buffers with no listener
576 testSurfaceListener(/*hasListener*/false, /*enableReleaseCb*/false, /*extraDiscardedBuffers*/1);
577 // Test discarding 1 free buffers with a listener, disabling onBufferReleased
578 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/0);
579 // Test discarding 2 free buffers with a listener, disabling onBufferReleased
580 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/false, /*extraDiscardedBuffers*/1);
581 // Test discarding 1 free buffers with a listener, enabling onBufferReleased
582 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/0);
583 // Test discarding 3 free buffers with a listener, enabling onBufferReleased
584 testSurfaceListener(/*hasListener*/true, /*enableReleasedCb*/true, /*extraDiscardedBuffers*/2);
585 }
586
TEST_F(SurfaceTest,TestGetLastDequeueStartTime)587 TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
588 sp<ANativeWindow> anw(mSurface);
589 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
590
591 ANativeWindowBuffer* buffer = nullptr;
592 int32_t fenceFd = -1;
593
594 nsecs_t before = systemTime(CLOCK_MONOTONIC);
595 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
596 nsecs_t after = systemTime(CLOCK_MONOTONIC);
597
598 nsecs_t lastDequeueTime = ANativeWindow_getLastDequeueStartTime(anw.get());
599 ASSERT_LE(before, lastDequeueTime);
600 ASSERT_GE(after, lastDequeueTime);
601 }
602
603 class FakeConsumer : public BnConsumerListener {
604 public:
onFrameAvailable(const BufferItem &)605 void onFrameAvailable(const BufferItem& /*item*/) override {}
onBuffersReleased()606 void onBuffersReleased() override {}
onSidebandStreamChanged()607 void onSidebandStreamChanged() override {}
608
addAndGetFrameTimestamps(const NewFrameEventsEntry * newTimestamps,FrameEventHistoryDelta * outDelta)609 void addAndGetFrameTimestamps(
610 const NewFrameEventsEntry* newTimestamps,
611 FrameEventHistoryDelta* outDelta) override {
612 if (newTimestamps) {
613 if (mGetFrameTimestampsEnabled) {
614 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
615 "Test should set mNewFrameEntryOverride before queuing "
616 "a frame.";
617 EXPECT_EQ(newTimestamps->frameNumber,
618 mNewFrameEntryOverride.frameNumber) <<
619 "Test attempting to add NewFrameEntryOverride with "
620 "incorrect frame number.";
621 mFrameEventHistory.addQueue(mNewFrameEntryOverride);
622 mNewFrameEntryOverride.frameNumber = 0;
623 }
624 mAddFrameTimestampsCount++;
625 mLastAddedFrameNumber = newTimestamps->frameNumber;
626 }
627 if (outDelta) {
628 mFrameEventHistory.getAndResetDelta(outDelta);
629 mGetFrameTimestampsCount++;
630 }
631 mAddAndGetFrameTimestampsCallCount++;
632 }
633
634 bool mGetFrameTimestampsEnabled = false;
635
636 ConsumerFrameEventHistory mFrameEventHistory;
637 int mAddAndGetFrameTimestampsCallCount = 0;
638 int mAddFrameTimestampsCount = 0;
639 int mGetFrameTimestampsCount = 0;
640 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
641
642 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
643 };
644
645 class FakeSurfaceComposer : public ISurfaceComposer {
646 public:
~FakeSurfaceComposer()647 ~FakeSurfaceComposer() override {}
648
setSupportsPresent(bool supportsPresent)649 void setSupportsPresent(bool supportsPresent) {
650 mSupportsPresent = supportsPresent;
651 }
652
setTransactionState(const FrameTimelineInfo &,Vector<ComposerState> &,Vector<DisplayState> &,uint32_t,const sp<IBinder> &,InputWindowCommands,int64_t,bool,const std::vector<client_cache_t> &,bool,const std::vector<ListenerCallbacks> &,uint64_t,const std::vector<uint64_t> &)653 status_t setTransactionState(
654 const FrameTimelineInfo& /*frameTimelineInfo*/, Vector<ComposerState>& /*state*/,
655 Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
656 const sp<IBinder>& /*applyToken*/, InputWindowCommands /*inputWindowCommands*/,
657 int64_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
658 const std::vector<client_cache_t>& /*cachedBuffer*/, bool /*hasListenerCallbacks*/,
659 const std::vector<ListenerCallbacks>& /*listenerCallbacks*/, uint64_t /*transactionId*/,
660 const std::vector<uint64_t>& /*mergedTransactionIds*/) override {
661 return NO_ERROR;
662 }
663
664 protected:
onAsBinder()665 IBinder* onAsBinder() override { return nullptr; }
666
667 private:
668 bool mSupportsPresent{true};
669 };
670
671 class FakeSurfaceComposerAIDL : public gui::ISurfaceComposer {
672 public:
~FakeSurfaceComposerAIDL()673 ~FakeSurfaceComposerAIDL() override {}
674
setSupportsPresent(bool supportsPresent)675 void setSupportsPresent(bool supportsPresent) { mSupportsPresent = supportsPresent; }
676
bootFinished()677 binder::Status bootFinished() override { return binder::Status::ok(); }
678
createDisplayEventConnection(VsyncSource,EventRegistration,const sp<IBinder> &,sp<gui::IDisplayEventConnection> * outConnection)679 binder::Status createDisplayEventConnection(
680 VsyncSource /*vsyncSource*/, EventRegistration /*eventRegistration*/,
681 const sp<IBinder>& /*layerHandle*/,
682 sp<gui::IDisplayEventConnection>* outConnection) override {
683 *outConnection = nullptr;
684 return binder::Status::ok();
685 }
686
createConnection(sp<gui::ISurfaceComposerClient> * outClient)687 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override {
688 *outClient = nullptr;
689 return binder::Status::ok();
690 }
691
createVirtualDisplay(const std::string &,bool,const std::string &,float,sp<IBinder> *)692 binder::Status createVirtualDisplay(const std::string& /*displayName*/, bool /*isSecure*/,
693 const std::string& /*uniqueId*/,
694 float /*requestedRefreshRate*/,
695 sp<IBinder>* /*outDisplay*/) override {
696 return binder::Status::ok();
697 }
698
destroyVirtualDisplay(const sp<IBinder> &)699 binder::Status destroyVirtualDisplay(const sp<IBinder>& /*displayToken*/) override {
700 return binder::Status::ok();
701 }
702
getPhysicalDisplayIds(std::vector<int64_t> *)703 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* /*outDisplayIds*/) override {
704 return binder::Status::ok();
705 }
706
getPhysicalDisplayToken(int64_t,sp<IBinder> *)707 binder::Status getPhysicalDisplayToken(int64_t /*displayId*/,
708 sp<IBinder>* /*outDisplay*/) override {
709 return binder::Status::ok();
710 }
711
setPowerMode(const sp<IBinder> &,int)712 binder::Status setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {
713 return binder::Status::ok();
714 }
715
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported)716 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override {
717 *outSupported = {FrameEvent::REQUESTED_PRESENT,
718 FrameEvent::ACQUIRE,
719 FrameEvent::LATCH,
720 FrameEvent::FIRST_REFRESH_START,
721 FrameEvent::LAST_REFRESH_START,
722 FrameEvent::GPU_COMPOSITION_DONE,
723 FrameEvent::DEQUEUE_READY,
724 FrameEvent::RELEASE};
725 if (mSupportsPresent) {
726 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
727 }
728 return binder::Status::ok();
729 }
730
getDisplayStats(const sp<IBinder> &,gui::DisplayStatInfo *)731 binder::Status getDisplayStats(const sp<IBinder>& /*display*/,
732 gui::DisplayStatInfo* /*outStatInfo*/) override {
733 return binder::Status::ok();
734 }
735
getDisplayState(const sp<IBinder> &,gui::DisplayState *)736 binder::Status getDisplayState(const sp<IBinder>& /*display*/,
737 gui::DisplayState* /*outState*/) override {
738 return binder::Status::ok();
739 }
740
getStaticDisplayInfo(int64_t,gui::StaticDisplayInfo *)741 binder::Status getStaticDisplayInfo(int64_t /*displayId*/,
742 gui::StaticDisplayInfo* /*outInfo*/) override {
743 return binder::Status::ok();
744 }
745
getDynamicDisplayInfoFromId(int64_t,gui::DynamicDisplayInfo *)746 binder::Status getDynamicDisplayInfoFromId(int64_t /*displayId*/,
747 gui::DynamicDisplayInfo* /*outInfo*/) override {
748 return binder::Status::ok();
749 }
750
getDynamicDisplayInfoFromToken(const sp<IBinder> &,gui::DynamicDisplayInfo *)751 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& /*display*/,
752 gui::DynamicDisplayInfo* /*outInfo*/) override {
753 return binder::Status::ok();
754 }
755
getDisplayNativePrimaries(const sp<IBinder> &,gui::DisplayPrimaries *)756 binder::Status getDisplayNativePrimaries(const sp<IBinder>& /*display*/,
757 gui::DisplayPrimaries* /*outPrimaries*/) override {
758 return binder::Status::ok();
759 }
760
setActiveColorMode(const sp<IBinder> &,int)761 binder::Status setActiveColorMode(const sp<IBinder>& /*display*/, int /*colorMode*/) override {
762 return binder::Status::ok();
763 }
764
setBootDisplayMode(const sp<IBinder> &,int)765 binder::Status setBootDisplayMode(const sp<IBinder>& /*display*/,
766 int /*displayModeId*/) override {
767 return binder::Status::ok();
768 }
769
clearBootDisplayMode(const sp<IBinder> &)770 binder::Status clearBootDisplayMode(const sp<IBinder>& /*display*/) override {
771 return binder::Status::ok();
772 }
773
getBootDisplayModeSupport(bool *)774 binder::Status getBootDisplayModeSupport(bool* /*outMode*/) override {
775 return binder::Status::ok();
776 }
777
getHdrConversionCapabilities(std::vector<gui::HdrConversionCapability> *)778 binder::Status getHdrConversionCapabilities(
779 std::vector<gui::HdrConversionCapability>*) override {
780 return binder::Status::ok();
781 }
782
setHdrConversionStrategy(const gui::HdrConversionStrategy &,int32_t *)783 binder::Status setHdrConversionStrategy(
784 const gui::HdrConversionStrategy& /*hdrConversionStrategy*/,
785 int32_t* /*outPreferredHdrOutputType*/) override {
786 return binder::Status::ok();
787 }
788
getHdrOutputConversionSupport(bool *)789 binder::Status getHdrOutputConversionSupport(bool* /*outSupport*/) override {
790 return binder::Status::ok();
791 }
792
setAutoLowLatencyMode(const sp<IBinder> &,bool)793 binder::Status setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {
794 return binder::Status::ok();
795 }
796
setGameContentType(const sp<IBinder> &,bool)797 binder::Status setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {
798 return binder::Status::ok();
799 }
800
captureDisplay(const DisplayCaptureArgs &,const sp<IScreenCaptureListener> &)801 binder::Status captureDisplay(const DisplayCaptureArgs&,
802 const sp<IScreenCaptureListener>&) override {
803 return binder::Status::ok();
804 }
805
captureDisplayById(int64_t,const gui::CaptureArgs &,const sp<IScreenCaptureListener> &)806 binder::Status captureDisplayById(int64_t, const gui::CaptureArgs&,
807 const sp<IScreenCaptureListener>&) override {
808 return binder::Status::ok();
809 }
810
captureLayersSync(const LayerCaptureArgs &,ScreenCaptureResults *)811 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults*) override {
812 return binder::Status::ok();
813 }
814
captureLayers(const LayerCaptureArgs &,const sp<IScreenCaptureListener> &)815 binder::Status captureLayers(const LayerCaptureArgs&,
816 const sp<IScreenCaptureListener>&) override {
817 return binder::Status::ok();
818 }
819
clearAnimationFrameStats()820 binder::Status clearAnimationFrameStats() override { return binder::Status::ok(); }
821
getAnimationFrameStats(gui::FrameStats *)822 binder::Status getAnimationFrameStats(gui::FrameStats* /*outStats*/) override {
823 return binder::Status::ok();
824 }
825
overrideHdrTypes(const sp<IBinder> &,const std::vector<int32_t> &)826 binder::Status overrideHdrTypes(const sp<IBinder>& /*display*/,
827 const std::vector<int32_t>& /*hdrTypes*/) override {
828 return binder::Status::ok();
829 }
830
onPullAtom(int32_t,gui::PullAtomData *)831 binder::Status onPullAtom(int32_t /*atomId*/, gui::PullAtomData* /*outPullData*/) override {
832 return binder::Status::ok();
833 }
834
getCompositionPreference(gui::CompositionPreference *)835 binder::Status getCompositionPreference(gui::CompositionPreference* /*outPref*/) override {
836 return binder::Status::ok();
837 }
838
getDisplayedContentSamplingAttributes(const sp<IBinder> &,gui::ContentSamplingAttributes *)839 binder::Status getDisplayedContentSamplingAttributes(
840 const sp<IBinder>& /*display*/, gui::ContentSamplingAttributes* /*outAttrs*/) override {
841 return binder::Status::ok();
842 }
843
setDisplayContentSamplingEnabled(const sp<IBinder> &,bool,int8_t,int64_t)844 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& /*display*/, bool /*enable*/,
845 int8_t /*componentMask*/,
846 int64_t /*maxFrames*/) override {
847 return binder::Status::ok();
848 }
849
getProtectedContentSupport(bool *)850 binder::Status getProtectedContentSupport(bool* /*outSupporte*/) override {
851 return binder::Status::ok();
852 }
853
getDisplayedContentSample(const sp<IBinder> &,int64_t,int64_t,gui::DisplayedFrameStats *)854 binder::Status getDisplayedContentSample(const sp<IBinder>& /*display*/, int64_t /*maxFrames*/,
855 int64_t /*timestamp*/,
856 gui::DisplayedFrameStats* /*outStats*/) override {
857 return binder::Status::ok();
858 }
859
isWideColorDisplay(const sp<IBinder> &,bool *)860 binder::Status isWideColorDisplay(const sp<IBinder>& /*token*/,
861 bool* /*outIsWideColorDisplay*/) override {
862 return binder::Status::ok();
863 }
864
addRegionSamplingListener(const gui::ARect &,const sp<IBinder> &,const sp<gui::IRegionSamplingListener> &)865 binder::Status addRegionSamplingListener(
866 const gui::ARect& /*samplingArea*/, const sp<IBinder>& /*stopLayerHandle*/,
867 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
868 return binder::Status::ok();
869 }
870
removeRegionSamplingListener(const sp<gui::IRegionSamplingListener> &)871 binder::Status removeRegionSamplingListener(
872 const sp<gui::IRegionSamplingListener>& /*listener*/) override {
873 return binder::Status::ok();
874 }
875
addFpsListener(int32_t,const sp<gui::IFpsListener> &)876 binder::Status addFpsListener(int32_t /*taskId*/,
877 const sp<gui::IFpsListener>& /*listener*/) override {
878 return binder::Status::ok();
879 }
880
removeFpsListener(const sp<gui::IFpsListener> &)881 binder::Status removeFpsListener(const sp<gui::IFpsListener>& /*listener*/) override {
882 return binder::Status::ok();
883 }
884
addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)885 binder::Status addTunnelModeEnabledListener(
886 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
887 return binder::Status::ok();
888 }
889
removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener> &)890 binder::Status removeTunnelModeEnabledListener(
891 const sp<gui::ITunnelModeEnabledListener>& /*listener*/) override {
892 return binder::Status::ok();
893 }
894
setDesiredDisplayModeSpecs(const sp<IBinder> &,const gui::DisplayModeSpecs &)895 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
896 const gui::DisplayModeSpecs&) override {
897 return binder::Status::ok();
898 }
899
getDesiredDisplayModeSpecs(const sp<IBinder> &,gui::DisplayModeSpecs *)900 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& /*displayToken*/,
901 gui::DisplayModeSpecs*) override {
902 return binder::Status::ok();
903 }
904
getDisplayBrightnessSupport(const sp<IBinder> &,bool *)905 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& /*displayToken*/,
906 bool* /*outSupport*/) override {
907 return binder::Status::ok();
908 }
909
setDisplayBrightness(const sp<IBinder> &,const gui::DisplayBrightness &)910 binder::Status setDisplayBrightness(const sp<IBinder>& /*displayToken*/,
911 const gui::DisplayBrightness& /*brightness*/) override {
912 return binder::Status::ok();
913 }
914
addHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)915 binder::Status addHdrLayerInfoListener(
916 const sp<IBinder>& /*displayToken*/,
917 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
918 return binder::Status::ok();
919 }
920
removeHdrLayerInfoListener(const sp<IBinder> &,const sp<gui::IHdrLayerInfoListener> &)921 binder::Status removeHdrLayerInfoListener(
922 const sp<IBinder>& /*displayToken*/,
923 const sp<gui::IHdrLayerInfoListener>& /*listener*/) override {
924 return binder::Status::ok();
925 }
926
notifyPowerBoost(int)927 binder::Status notifyPowerBoost(int /*boostId*/) override { return binder::Status::ok(); }
928
setGlobalShadowSettings(const gui::Color &,const gui::Color &,float,float,float)929 binder::Status setGlobalShadowSettings(const gui::Color& /*ambientColor*/,
930 const gui::Color& /*spotColor*/, float /*lightPosY*/,
931 float /*lightPosZ*/, float /*lightRadius*/) override {
932 return binder::Status::ok();
933 }
934
getDisplayDecorationSupport(const sp<IBinder> &,std::optional<gui::DisplayDecorationSupport> *)935 binder::Status getDisplayDecorationSupport(
936 const sp<IBinder>& /*displayToken*/,
937 std::optional<gui::DisplayDecorationSupport>* /*outSupport*/) override {
938 return binder::Status::ok();
939 }
940
setGameModeFrameRateOverride(int32_t,float)941 binder::Status setGameModeFrameRateOverride(int32_t /*uid*/, float /*frameRate*/) override {
942 return binder::Status::ok();
943 }
944
setGameDefaultFrameRateOverride(int32_t,float)945 binder::Status setGameDefaultFrameRateOverride(int32_t /*uid*/, float /*frameRate*/) override {
946 return binder::Status::ok();
947 }
948
enableRefreshRateOverlay(bool)949 binder::Status enableRefreshRateOverlay(bool /*active*/) override {
950 return binder::Status::ok();
951 }
952
setDebugFlash(int)953 binder::Status setDebugFlash(int /*delay*/) override { return binder::Status::ok(); }
954
scheduleComposite()955 binder::Status scheduleComposite() override { return binder::Status::ok(); }
956
scheduleCommit()957 binder::Status scheduleCommit() override { return binder::Status::ok(); }
958
forceClientComposition(bool)959 binder::Status forceClientComposition(bool /*enabled*/) override {
960 return binder::Status::ok();
961 }
962
updateSmallAreaDetection(const std::vector<int32_t> &,const std::vector<float> &)963 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& /*appIds*/,
964 const std::vector<float>& /*thresholds*/) {
965 return binder::Status::ok();
966 }
967
setSmallAreaDetectionThreshold(int32_t,float)968 binder::Status setSmallAreaDetectionThreshold(int32_t /*appId*/, float /*threshold*/) {
969 return binder::Status::ok();
970 }
971
getGpuContextPriority(int32_t *)972 binder::Status getGpuContextPriority(int32_t* /*outPriority*/) override {
973 return binder::Status::ok();
974 }
975
getMaxAcquiredBufferCount(int32_t *)976 binder::Status getMaxAcquiredBufferCount(int32_t* /*buffers*/) override {
977 return binder::Status::ok();
978 }
979
addWindowInfosListener(const sp<gui::IWindowInfosListener> &,gui::WindowInfosListenerInfo *)980 binder::Status addWindowInfosListener(
981 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/,
982 gui::WindowInfosListenerInfo* /*outInfo*/) override {
983 return binder::Status::ok();
984 }
985
removeWindowInfosListener(const sp<gui::IWindowInfosListener> &)986 binder::Status removeWindowInfosListener(
987 const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
988 return binder::Status::ok();
989 }
990
getOverlaySupport(gui::OverlayProperties *)991 binder::Status getOverlaySupport(gui::OverlayProperties* /*properties*/) override {
992 return binder::Status::ok();
993 }
994
getStalledTransactionInfo(int32_t,std::optional<gui::StalledTransactionInfo> *)995 binder::Status getStalledTransactionInfo(
996 int32_t /*pid*/, std::optional<gui::StalledTransactionInfo>* /*result*/) override {
997 return binder::Status::ok();
998 }
999
getSchedulingPolicy(gui::SchedulingPolicy *)1000 binder::Status getSchedulingPolicy(gui::SchedulingPolicy*) override {
1001 return binder::Status::ok();
1002 }
1003
notifyShutdown()1004 binder::Status notifyShutdown() override { return binder::Status::ok(); }
1005
addJankListener(const sp<IBinder> &,const sp<gui::IJankListener> &)1006 binder::Status addJankListener(const sp<IBinder>& /*layer*/,
1007 const sp<gui::IJankListener>& /*listener*/) override {
1008 return binder::Status::ok();
1009 }
1010
flushJankData(int32_t)1011 binder::Status flushJankData(int32_t /*layerId*/) override { return binder::Status::ok(); }
1012
removeJankListener(int32_t,const sp<gui::IJankListener> &,int64_t)1013 binder::Status removeJankListener(int32_t /*layerId*/,
1014 const sp<gui::IJankListener>& /*listener*/,
1015 int64_t /*afterVsync*/) override {
1016 return binder::Status::ok();
1017 }
1018
setActivePictureListener(const sp<gui::IActivePictureListener> &)1019 binder::Status setActivePictureListener(const sp<gui::IActivePictureListener>&) {
1020 return binder::Status::ok();
1021 }
1022
getMaxLayerPictureProfiles(const sp<IBinder> &,int32_t *)1023 binder::Status getMaxLayerPictureProfiles(const sp<IBinder>& /*display*/,
1024 int32_t* /*outMaxProfiles*/) {
1025 return binder::Status::ok();
1026 }
1027
1028 protected:
onAsBinder()1029 IBinder* onAsBinder() override { return nullptr; }
1030
1031 private:
1032 bool mSupportsPresent{true};
1033 };
1034
1035 class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
1036 public:
FakeProducerFrameEventHistory(FenceToFenceTimeMap * fenceMap)1037 explicit FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) : mFenceMap(fenceMap) {}
1038
~FakeProducerFrameEventHistory()1039 ~FakeProducerFrameEventHistory() {}
1040
updateAcquireFence(uint64_t frameNumber,std::shared_ptr<FenceTime> && acquire)1041 void updateAcquireFence(uint64_t frameNumber,
1042 std::shared_ptr<FenceTime>&& acquire) override {
1043 // Verify the acquire fence being added isn't the one from the consumer.
1044 EXPECT_NE(mConsumerAcquireFence, acquire);
1045 // Override the fence, so we can verify this was called by the
1046 // producer after the frame is queued.
1047 ProducerFrameEventHistory::updateAcquireFence(frameNumber,
1048 std::shared_ptr<FenceTime>(mAcquireFenceOverride));
1049 }
1050
setAcquireFenceOverride(const std::shared_ptr<FenceTime> & acquireFenceOverride,const std::shared_ptr<FenceTime> & consumerAcquireFence)1051 void setAcquireFenceOverride(
1052 const std::shared_ptr<FenceTime>& acquireFenceOverride,
1053 const std::shared_ptr<FenceTime>& consumerAcquireFence) {
1054 mAcquireFenceOverride = acquireFenceOverride;
1055 mConsumerAcquireFence = consumerAcquireFence;
1056 }
1057
1058 protected:
createFenceTime(const sp<Fence> & fence) const1059 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
1060 const override {
1061 return mFenceMap->createFenceTimeForTest(fence);
1062 }
1063
1064 FenceToFenceTimeMap* mFenceMap{nullptr};
1065
1066 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
1067 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
1068 };
1069
1070
1071 class TestSurface : public Surface {
1072 public:
TestSurface(const sp<IGraphicBufferProducer> & bufferProducer,FenceToFenceTimeMap * fenceMap)1073 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer, FenceToFenceTimeMap* fenceMap)
1074 : Surface(bufferProducer),
1075 mFakeSurfaceComposer(new FakeSurfaceComposer),
1076 mFakeSurfaceComposerAIDL(new FakeSurfaceComposerAIDL) {
1077 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
1078 mFrameEventHistory.reset(mFakeFrameEventHistory);
1079 }
1080
~TestSurface()1081 ~TestSurface() override {}
1082
composerService() const1083 sp<ISurfaceComposer> composerService() const override {
1084 return mFakeSurfaceComposer;
1085 }
1086
composerServiceAIDL() const1087 sp<gui::ISurfaceComposer> composerServiceAIDL() const override {
1088 return mFakeSurfaceComposerAIDL;
1089 }
1090
now() const1091 nsecs_t now() const override {
1092 return mNow;
1093 }
1094
setNow(nsecs_t now)1095 void setNow(nsecs_t now) {
1096 mNow = now;
1097 }
1098
1099 public:
1100 sp<FakeSurfaceComposer> mFakeSurfaceComposer;
1101 sp<FakeSurfaceComposerAIDL> mFakeSurfaceComposerAIDL;
1102 nsecs_t mNow = 0;
1103
1104 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
1105 // but this raw pointer gives access to test functionality.
1106 FakeProducerFrameEventHistory* mFakeFrameEventHistory;
1107 };
1108
1109
1110 class GetFrameTimestampsTest : public ::testing::Test {
1111 protected:
1112 struct FenceAndFenceTime {
FenceAndFenceTimeandroid::GetFrameTimestampsTest::FenceAndFenceTime1113 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
1114 : mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
1115
1116 sp<Fence> mFence = sp<Fence>::make();
1117 std::shared_ptr<FenceTime> mFenceTime;
1118 };
1119
makeCompositorTiming(nsecs_t deadline=1000000000,nsecs_t interval=16666667,nsecs_t presentLatency=50000000)1120 static CompositorTiming makeCompositorTiming(nsecs_t deadline = 1'000'000'000,
1121 nsecs_t interval = 16'666'667,
1122 nsecs_t presentLatency = 50'000'000) {
1123 CompositorTiming timing;
1124 timing.deadline = deadline;
1125 timing.interval = interval;
1126 timing.presentLatency = presentLatency;
1127 return timing;
1128 }
1129
1130 struct RefreshEvents {
RefreshEventsandroid::GetFrameTimestampsTest::RefreshEvents1131 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
1132 : mFenceMap(fenceMap),
1133 kCompositorTiming(
1134 makeCompositorTiming(refreshStart, refreshStart + 1, refreshStart + 2)),
1135 kStartTime(refreshStart + 3),
1136 kGpuCompositionDoneTime(refreshStart + 4),
1137 kPresentTime(refreshStart + 5) {}
1138
signalPostCompositeFencesandroid::GetFrameTimestampsTest::RefreshEvents1139 void signalPostCompositeFences() {
1140 mFenceMap.signalAllForTest(
1141 mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
1142 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
1143 }
1144
1145 FenceToFenceTimeMap& mFenceMap;
1146
1147 FenceAndFenceTime mGpuCompositionDone{mFenceMap};
1148 FenceAndFenceTime mPresent{mFenceMap};
1149
1150 const CompositorTiming kCompositorTiming;
1151
1152 const nsecs_t kStartTime;
1153 const nsecs_t kGpuCompositionDoneTime;
1154 const nsecs_t kPresentTime;
1155 };
1156
1157 struct FrameEvents {
FrameEventsandroid::GetFrameTimestampsTest::FrameEvents1158 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
1159 : mFenceMap(fenceMap),
1160 kPostedTime(frameStartTime + 100),
1161 kRequestedPresentTime(frameStartTime + 200),
1162 kProducerAcquireTime(frameStartTime + 300),
1163 kConsumerAcquireTime(frameStartTime + 301),
1164 kLatchTime(frameStartTime + 500),
1165 kDequeueReadyTime(frameStartTime + 600),
1166 kReleaseTime(frameStartTime + 700),
1167 mRefreshes {
1168 { mFenceMap, frameStartTime + 410 },
1169 { mFenceMap, frameStartTime + 420 },
1170 { mFenceMap, frameStartTime + 430 } } {}
1171
signalQueueFencesandroid::GetFrameTimestampsTest::FrameEvents1172 void signalQueueFences() {
1173 mFenceMap.signalAllForTest(
1174 mAcquireConsumer.mFence, kConsumerAcquireTime);
1175 mFenceMap.signalAllForTest(
1176 mAcquireProducer.mFence, kProducerAcquireTime);
1177 }
1178
signalRefreshFencesandroid::GetFrameTimestampsTest::FrameEvents1179 void signalRefreshFences() {
1180 for (auto& re : mRefreshes) {
1181 re.signalPostCompositeFences();
1182 }
1183 }
1184
signalReleaseFencesandroid::GetFrameTimestampsTest::FrameEvents1185 void signalReleaseFences() {
1186 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
1187 }
1188
1189 FenceToFenceTimeMap& mFenceMap;
1190
1191 FenceAndFenceTime mAcquireConsumer { mFenceMap };
1192 FenceAndFenceTime mAcquireProducer { mFenceMap };
1193 FenceAndFenceTime mRelease { mFenceMap };
1194
1195 const nsecs_t kPostedTime;
1196 const nsecs_t kRequestedPresentTime;
1197 const nsecs_t kProducerAcquireTime;
1198 const nsecs_t kConsumerAcquireTime;
1199 const nsecs_t kLatchTime;
1200 const nsecs_t kDequeueReadyTime;
1201 const nsecs_t kReleaseTime;
1202
1203 RefreshEvents mRefreshes[3];
1204 };
1205
GetFrameTimestampsTest()1206 GetFrameTimestampsTest() {}
1207
SetUp()1208 virtual void SetUp() {
1209 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
1210 mFakeConsumer = new FakeConsumer;
1211 mCfeh = &mFakeConsumer->mFrameEventHistory;
1212 mConsumer->consumerConnect(mFakeConsumer, false);
1213 mConsumer->setConsumerName(String8("TestConsumer"));
1214 mSurface = new TestSurface(mProducer, &mFenceMap);
1215 mWindow = mSurface;
1216
1217 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
1218 NATIVE_WINDOW_API_CPU));
1219 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(mWindow.get(), 4));
1220 ASSERT_EQ(NO_ERROR, native_window_set_usage(mWindow.get(), TEST_PRODUCER_USAGE_BITS));
1221 }
1222
disableFrameTimestamps()1223 void disableFrameTimestamps() {
1224 mFakeConsumer->mGetFrameTimestampsEnabled = false;
1225 native_window_enable_frame_timestamps(mWindow.get(), 0);
1226 mFrameTimestampsEnabled = false;
1227 }
1228
enableFrameTimestamps()1229 void enableFrameTimestamps() {
1230 mFakeConsumer->mGetFrameTimestampsEnabled = true;
1231 native_window_enable_frame_timestamps(mWindow.get(), 1);
1232 mFrameTimestampsEnabled = true;
1233 }
1234
getAllFrameTimestamps(uint64_t frameId)1235 int getAllFrameTimestamps(uint64_t frameId) {
1236 return native_window_get_frame_timestamps(mWindow.get(), frameId,
1237 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
1238 &outFirstRefreshStartTime, &outLastRefreshStartTime,
1239 &outGpuCompositionDoneTime, &outDisplayPresentTime,
1240 &outDequeueReadyTime, &outReleaseTime);
1241 }
1242
resetTimestamps()1243 void resetTimestamps() {
1244 outRequestedPresentTime = -1;
1245 outAcquireTime = -1;
1246 outLatchTime = -1;
1247 outFirstRefreshStartTime = -1;
1248 outLastRefreshStartTime = -1;
1249 outGpuCompositionDoneTime = -1;
1250 outDisplayPresentTime = -1;
1251 outDequeueReadyTime = -1;
1252 outReleaseTime = -1;
1253 }
1254
getNextFrameId()1255 uint64_t getNextFrameId() {
1256 uint64_t frameId = -1;
1257 int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
1258 EXPECT_EQ(status, NO_ERROR);
1259 return frameId;
1260 }
1261
dequeueAndQueue(uint64_t frameIndex)1262 void dequeueAndQueue(uint64_t frameIndex) {
1263 int fence = -1;
1264 ANativeWindowBuffer* buffer = nullptr;
1265 ASSERT_EQ(NO_ERROR,
1266 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1267
1268 int oldAddFrameTimestampsCount =
1269 mFakeConsumer->mAddFrameTimestampsCount;
1270
1271 FrameEvents* frame = &mFrames[frameIndex];
1272 uint64_t frameNumber = frameIndex + 1;
1273
1274 NewFrameEventsEntry fe;
1275 fe.frameNumber = frameNumber;
1276 fe.postedTime = frame->kPostedTime;
1277 fe.requestedPresentTime = frame->kRequestedPresentTime;
1278 fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
1279 mFakeConsumer->mNewFrameEntryOverride = fe;
1280
1281 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1282 frame->mAcquireProducer.mFenceTime,
1283 frame->mAcquireConsumer.mFenceTime);
1284
1285 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1286
1287 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
1288
1289 EXPECT_EQ(
1290 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
1291 mFakeConsumer->mAddFrameTimestampsCount);
1292 }
1293
addFrameEvents(bool gpuComposited,uint64_t iOldFrame,int64_t iNewFrame)1294 void addFrameEvents(
1295 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
1296 FrameEvents* oldFrame =
1297 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
1298 FrameEvents* newFrame = &mFrames[iNewFrame];
1299
1300 uint64_t nOldFrame = (iOldFrame == NO_FRAME_INDEX) ? 0 : iOldFrame + 1;
1301 uint64_t nNewFrame = iNewFrame + 1;
1302
1303 // Latch, Composite, and Release the frames in a plausible order.
1304 // Note: The timestamps won't necessarily match the order, but
1305 // that's okay for the purposes of this test.
1306 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
1307
1308 // Composite the previous frame one more time, which helps verify
1309 // LastRefresh is updated properly.
1310 if (oldFrame != nullptr) {
1311 mCfeh->addPreComposition(nOldFrame,
1312 oldFrame->mRefreshes[2].kStartTime);
1313 gpuDoneFenceTime = gpuComposited ?
1314 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
1315 FenceTime::NO_FENCE;
1316 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
1317 oldFrame->mRefreshes[2].mPresent.mFenceTime,
1318 oldFrame->mRefreshes[2].kCompositorTiming);
1319 }
1320
1321 // Latch the new frame.
1322 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
1323
1324 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
1325 gpuDoneFenceTime = gpuComposited ?
1326 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
1327 FenceTime::NO_FENCE;
1328 // HWC2 releases the previous buffer after a new latch just before
1329 // calling onCompositionPresented.
1330 if (oldFrame != nullptr) {
1331 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
1332 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
1333 }
1334 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1335 newFrame->mRefreshes[0].mPresent.mFenceTime,
1336 newFrame->mRefreshes[0].kCompositorTiming);
1337
1338 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
1339 gpuDoneFenceTime = gpuComposited ?
1340 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
1341 FenceTime::NO_FENCE;
1342 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
1343 newFrame->mRefreshes[1].mPresent.mFenceTime,
1344 newFrame->mRefreshes[1].kCompositorTiming);
1345 }
1346
1347 sp<IGraphicBufferProducer> mProducer;
1348 sp<IGraphicBufferConsumer> mConsumer;
1349 sp<FakeConsumer> mFakeConsumer;
1350 ConsumerFrameEventHistory* mCfeh;
1351 sp<TestSurface> mSurface;
1352 sp<ANativeWindow> mWindow;
1353
1354 FenceToFenceTimeMap mFenceMap;
1355
1356 bool mFrameTimestampsEnabled = false;
1357
1358 int64_t outRequestedPresentTime = -1;
1359 int64_t outAcquireTime = -1;
1360 int64_t outLatchTime = -1;
1361 int64_t outFirstRefreshStartTime = -1;
1362 int64_t outLastRefreshStartTime = -1;
1363 int64_t outGpuCompositionDoneTime = -1;
1364 int64_t outDisplayPresentTime = -1;
1365 int64_t outDequeueReadyTime = -1;
1366 int64_t outReleaseTime = -1;
1367
1368 FrameEvents mFrames[3] {
1369 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
1370 };
1371
1372
1373 // This test verifies that the frame timestamps are not retrieved when not
1374 // explicitly enabled via native_window_enable_frame_timestamps.
1375 // We want to check this to make sure there's no overhead for users
1376 // that don't need the timestamp information.
TEST_F(GetFrameTimestampsTest,DefaultDisabled)1377 TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
1378 int fence;
1379 ANativeWindowBuffer* buffer;
1380
1381 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1382 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1383
1384 const uint64_t fId = getNextFrameId();
1385
1386 // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
1387 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1388 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1389 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1390
1391 // Verify the producer doesn't get frame timestamps piggybacked on queue.
1392 // It is okay that frame timestamps are added in the consumer since it is
1393 // still needed for SurfaceFlinger dumps.
1394 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1395 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1396 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1397
1398 // Verify attempts to get frame timestamps fail.
1399 int result = getAllFrameTimestamps(fId);
1400 EXPECT_EQ(INVALID_OPERATION, result);
1401 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
1402
1403 // Verify compositor timing query fails.
1404 nsecs_t compositeDeadline = 0;
1405 nsecs_t compositeInterval = 0;
1406 nsecs_t compositeToPresentLatency = 0;
1407 result = native_window_get_compositor_timing(mWindow.get(),
1408 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1409 EXPECT_EQ(INVALID_OPERATION, result);
1410 }
1411
1412 // This test verifies that the frame timestamps are retrieved if explicitly
1413 // enabled via native_window_enable_frame_timestamps.
TEST_F(GetFrameTimestampsTest,EnabledSimple)1414 TEST_F(GetFrameTimestampsTest, EnabledSimple) {
1415 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
1416 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1417
1418 enableFrameTimestamps();
1419
1420 // Verify the compositor timing query gets the initial compositor values
1421 // after timststamps are enabled; even before the first frame is queued
1422 // or dequeued.
1423 nsecs_t compositeDeadline = 0;
1424 nsecs_t compositeInterval = 0;
1425 nsecs_t compositeToPresentLatency = 0;
1426 mSurface->setNow(initialCompositorTiming.deadline - 1);
1427 int result = native_window_get_compositor_timing(mWindow.get(),
1428 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1429 EXPECT_EQ(NO_ERROR, result);
1430 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1431 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1432 EXPECT_EQ(initialCompositorTiming.presentLatency,
1433 compositeToPresentLatency);
1434
1435 int fence;
1436 ANativeWindowBuffer* buffer;
1437
1438 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1439 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
1440
1441 const uint64_t fId1 = getNextFrameId();
1442
1443 // Verify getFrameTimestamps is piggybacked on dequeue.
1444 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
1445 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
1446 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
1447
1448 NewFrameEventsEntry f1;
1449 f1.frameNumber = 1;
1450 f1.postedTime = mFrames[0].kPostedTime;
1451 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
1452 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
1453 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
1454 mFrames[0].mAcquireProducer.mFenceTime,
1455 mFrames[0].mAcquireConsumer.mFenceTime);
1456 mFakeConsumer->mNewFrameEntryOverride = f1;
1457 mFrames[0].signalQueueFences();
1458
1459 // Verify getFrameTimestamps is piggybacked on queue.
1460 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
1461 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
1462 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
1463 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
1464
1465 // Verify queries for timestamps that the producer doesn't know about
1466 // triggers a call to see if the consumer has any new timestamps.
1467 result = getAllFrameTimestamps(fId1);
1468 EXPECT_EQ(NO_ERROR, result);
1469 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
1470 }
1471
TEST_F(GetFrameTimestampsTest,QueryPresentSupported)1472 TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
1473 bool displayPresentSupported = true;
1474 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
1475 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
1476
1477 // Verify supported bits are forwarded.
1478 int supportsPresent = -1;
1479 mWindow.get()->query(mWindow.get(),
1480 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1481 EXPECT_EQ(displayPresentSupported, supportsPresent);
1482 }
1483
TEST_F(GetFrameTimestampsTest,QueryPresentNotSupported)1484 TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
1485 bool displayPresentSupported = false;
1486 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
1487 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(displayPresentSupported);
1488
1489 // Verify supported bits are forwarded.
1490 int supportsPresent = -1;
1491 mWindow.get()->query(mWindow.get(),
1492 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
1493 EXPECT_EQ(displayPresentSupported, supportsPresent);
1494 }
1495
TEST_F(GetFrameTimestampsTest,SnapToNextTickBasic)1496 TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
1497 nsecs_t phase = 4000;
1498 nsecs_t interval = 1000;
1499
1500 // Timestamp in previous interval.
1501 nsecs_t timestamp = 3500;
1502 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1503 timestamp, phase, interval));
1504
1505 // Timestamp in next interval.
1506 timestamp = 4500;
1507 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1508 timestamp, phase, interval));
1509
1510 // Timestamp multiple intervals before.
1511 timestamp = 2500;
1512 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1513 timestamp, phase, interval));
1514
1515 // Timestamp multiple intervals after.
1516 timestamp = 6500;
1517 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1518 timestamp, phase, interval));
1519
1520 // Timestamp on previous interval.
1521 timestamp = 3000;
1522 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1523 timestamp, phase, interval));
1524
1525 // Timestamp on next interval.
1526 timestamp = 5000;
1527 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1528 timestamp, phase, interval));
1529
1530 // Timestamp equal to phase.
1531 timestamp = 4000;
1532 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1533 timestamp, phase, interval));
1534 }
1535
1536 // int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1537 // if the number of intervals elapsed is internally stored in an int.
TEST_F(GetFrameTimestampsTest,SnapToNextTickOverflow)1538 TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1539 nsecs_t phase = 0;
1540 nsecs_t interval = 4000;
1541 nsecs_t big_timestamp = 8635916564000;
1542 int32_t intervals = big_timestamp / interval;
1543
1544 EXPECT_LT(intervals, 0);
1545 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1546 big_timestamp, phase, interval));
1547 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1548 big_timestamp, big_timestamp, interval));
1549 }
1550
1551 // This verifies the compositor timing is updated by refresh events
1552 // and piggy backed on a queue, dequeue, and enabling of timestamps..
TEST_F(GetFrameTimestampsTest,CompositorTimingUpdatesBasic)1553 TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
1554 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
1555 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1556
1557 enableFrameTimestamps();
1558
1559 // We get the initial values before any frames are submitted.
1560 nsecs_t compositeDeadline = 0;
1561 nsecs_t compositeInterval = 0;
1562 nsecs_t compositeToPresentLatency = 0;
1563 mSurface->setNow(initialCompositorTiming.deadline - 1);
1564 int result = native_window_get_compositor_timing(mWindow.get(),
1565 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1566 EXPECT_EQ(NO_ERROR, result);
1567 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1568 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1569 EXPECT_EQ(initialCompositorTiming.presentLatency,
1570 compositeToPresentLatency);
1571
1572 dequeueAndQueue(0);
1573 addFrameEvents(true, NO_FRAME_INDEX, 0);
1574
1575 // Still get the initial values because the frame events for frame 0
1576 // didn't get a chance to piggyback on a queue or dequeue yet.
1577 result = native_window_get_compositor_timing(mWindow.get(),
1578 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1579 EXPECT_EQ(NO_ERROR, result);
1580 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1581 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1582 EXPECT_EQ(initialCompositorTiming.presentLatency,
1583 compositeToPresentLatency);
1584
1585 dequeueAndQueue(1);
1586 addFrameEvents(true, 0, 1);
1587
1588 // Now expect the composite values associated with frame 1.
1589 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1590 result = native_window_get_compositor_timing(mWindow.get(),
1591 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1592 EXPECT_EQ(NO_ERROR, result);
1593 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1594 compositeDeadline);
1595 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1596 compositeInterval);
1597 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1598 compositeToPresentLatency);
1599
1600 dequeueAndQueue(2);
1601 addFrameEvents(true, 1, 2);
1602
1603 // Now expect the composite values associated with frame 2.
1604 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1605 result = native_window_get_compositor_timing(mWindow.get(),
1606 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1607 EXPECT_EQ(NO_ERROR, result);
1608 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1609 compositeDeadline);
1610 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1611 compositeInterval);
1612 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1613 compositeToPresentLatency);
1614
1615 // Re-enabling frame timestamps should get the latest values.
1616 disableFrameTimestamps();
1617 enableFrameTimestamps();
1618
1619 // Now expect the composite values associated with frame 3.
1620 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1621 result = native_window_get_compositor_timing(mWindow.get(),
1622 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1623 EXPECT_EQ(NO_ERROR, result);
1624 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1625 compositeDeadline);
1626 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1627 compositeInterval);
1628 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1629 compositeToPresentLatency);
1630 }
1631
1632 // This verifies the compositor deadline properly snaps to the the next
1633 // deadline based on the current time.
TEST_F(GetFrameTimestampsTest,CompositorTimingDeadlineSnaps)1634 TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
1635 const CompositorTiming initialCompositorTiming = makeCompositorTiming();
1636 mCfeh->initializeCompositorTiming(initialCompositorTiming);
1637
1638 enableFrameTimestamps();
1639
1640 nsecs_t compositeDeadline = 0;
1641 nsecs_t compositeInterval = 0;
1642 nsecs_t compositeToPresentLatency = 0;
1643
1644 // A "now" just before the deadline snaps to the deadline.
1645 mSurface->setNow(initialCompositorTiming.deadline - 1);
1646 int result = native_window_get_compositor_timing(mWindow.get(),
1647 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1648 EXPECT_EQ(NO_ERROR, result);
1649 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1650 nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1651 EXPECT_EQ(expectedDeadline, compositeDeadline);
1652
1653 dequeueAndQueue(0);
1654 addFrameEvents(true, NO_FRAME_INDEX, 0);
1655
1656 // A "now" just after the deadline snaps properly.
1657 mSurface->setNow(initialCompositorTiming.deadline + 1);
1658 result = native_window_get_compositor_timing(mWindow.get(),
1659 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1660 EXPECT_EQ(NO_ERROR, result);
1661 expectedDeadline =
1662 initialCompositorTiming.deadline +initialCompositorTiming.interval;
1663 EXPECT_EQ(expectedDeadline, compositeDeadline);
1664
1665 dequeueAndQueue(1);
1666 addFrameEvents(true, 0, 1);
1667
1668 // A "now" just after the next interval snaps properly.
1669 mSurface->setNow(
1670 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1671 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1672 result = native_window_get_compositor_timing(mWindow.get(),
1673 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1674 EXPECT_EQ(NO_ERROR, result);
1675 expectedDeadline =
1676 mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1677 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1678 EXPECT_EQ(expectedDeadline, compositeDeadline);
1679
1680 dequeueAndQueue(2);
1681 addFrameEvents(true, 1, 2);
1682
1683 // A "now" over 1 interval before the deadline snaps properly.
1684 mSurface->setNow(
1685 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1686 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1687 result = native_window_get_compositor_timing(mWindow.get(),
1688 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1689 EXPECT_EQ(NO_ERROR, result);
1690 expectedDeadline =
1691 mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1692 mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1693 EXPECT_EQ(expectedDeadline, compositeDeadline);
1694
1695 // Re-enabling frame timestamps should get the latest values.
1696 disableFrameTimestamps();
1697 enableFrameTimestamps();
1698
1699 // A "now" over 2 intervals before the deadline snaps properly.
1700 mSurface->setNow(
1701 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1702 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1703 result = native_window_get_compositor_timing(mWindow.get(),
1704 &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1705 EXPECT_EQ(NO_ERROR, result);
1706 expectedDeadline =
1707 mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1708 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1709 EXPECT_EQ(expectedDeadline, compositeDeadline);
1710 }
1711
1712 // This verifies the timestamps recorded in the consumer's
1713 // FrameTimestampsHistory are properly retrieved by the producer for the
1714 // correct frames.
TEST_F(GetFrameTimestampsTest,TimestampsAssociatedWithCorrectFrame)1715 TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1716 enableFrameTimestamps();
1717
1718 const uint64_t fId1 = getNextFrameId();
1719 dequeueAndQueue(0);
1720 mFrames[0].signalQueueFences();
1721
1722 const uint64_t fId2 = getNextFrameId();
1723 dequeueAndQueue(1);
1724 mFrames[1].signalQueueFences();
1725
1726 addFrameEvents(true, NO_FRAME_INDEX, 0);
1727 mFrames[0].signalRefreshFences();
1728 addFrameEvents(true, 0, 1);
1729 mFrames[0].signalReleaseFences();
1730 mFrames[1].signalRefreshFences();
1731
1732 // Verify timestamps are correct for frame 1.
1733 resetTimestamps();
1734 int result = getAllFrameTimestamps(fId1);
1735 EXPECT_EQ(NO_ERROR, result);
1736 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1737 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1738 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1739 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1740 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1741 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1742 outGpuCompositionDoneTime);
1743 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1744 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1745 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1746
1747 // Verify timestamps are correct for frame 2.
1748 resetTimestamps();
1749 result = getAllFrameTimestamps(fId2);
1750 EXPECT_EQ(NO_ERROR, result);
1751 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1752 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1753 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1754 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1755 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1756 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1757 outGpuCompositionDoneTime);
1758 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1759 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1760 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1761 }
1762
1763 // This test verifies the acquire fence recorded by the consumer is not sent
1764 // back to the producer and the producer saves its own fence.
TEST_F(GetFrameTimestampsTest,QueueTimestampsNoSync)1765 TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1766 enableFrameTimestamps();
1767
1768 // Dequeue and queue frame 1.
1769 const uint64_t fId1 = getNextFrameId();
1770 dequeueAndQueue(0);
1771
1772 // Verify queue-related timestamps for f1 are available immediately in the
1773 // producer without asking the consumer again, even before signaling the
1774 // acquire fence.
1775 resetTimestamps();
1776 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1777 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1778 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1779 nullptr, nullptr, nullptr, nullptr, nullptr);
1780 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1781 EXPECT_EQ(NO_ERROR, result);
1782 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1783 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1784
1785 // Signal acquire fences. Verify a sync call still isn't necessary.
1786 mFrames[0].signalQueueFences();
1787
1788 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1789 result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1790 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1791 nullptr, nullptr, nullptr, nullptr, nullptr);
1792 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1793 EXPECT_EQ(NO_ERROR, result);
1794 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1795 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1796
1797 // Dequeue and queue frame 2.
1798 const uint64_t fId2 = getNextFrameId();
1799 dequeueAndQueue(1);
1800
1801 // Verify queue-related timestamps for f2 are available immediately in the
1802 // producer without asking the consumer again, even before signaling the
1803 // acquire fence.
1804 resetTimestamps();
1805 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1806 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1807 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1808 nullptr, nullptr, nullptr, nullptr, nullptr);
1809 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1810 EXPECT_EQ(NO_ERROR, result);
1811 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1812 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1813
1814 // Signal acquire fences. Verify a sync call still isn't necessary.
1815 mFrames[1].signalQueueFences();
1816
1817 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1818 result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1819 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1820 nullptr, nullptr, nullptr, nullptr, nullptr);
1821 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1822 EXPECT_EQ(NO_ERROR, result);
1823 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1824 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1825 }
1826
TEST_F(GetFrameTimestampsTest,ZeroRequestedTimestampsNoSync)1827 TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1828 enableFrameTimestamps();
1829
1830 // Dequeue and queue frame 1.
1831 dequeueAndQueue(0);
1832 mFrames[0].signalQueueFences();
1833
1834 // Dequeue and queue frame 2.
1835 const uint64_t fId2 = getNextFrameId();
1836 dequeueAndQueue(1);
1837 mFrames[1].signalQueueFences();
1838
1839 addFrameEvents(true, NO_FRAME_INDEX, 0);
1840 mFrames[0].signalRefreshFences();
1841 addFrameEvents(true, 0, 1);
1842 mFrames[0].signalReleaseFences();
1843 mFrames[1].signalRefreshFences();
1844
1845 // Verify a request for no timestamps doesn't result in a sync call.
1846 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1847 int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1848 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1849 nullptr, nullptr);
1850 EXPECT_EQ(NO_ERROR, result);
1851 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1852 }
1853
1854 // This test verifies that fences can signal and update timestamps producer
1855 // side without an additional sync call to the consumer.
TEST_F(GetFrameTimestampsTest,FencesInProducerNoSync)1856 TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1857 enableFrameTimestamps();
1858
1859 // Dequeue and queue frame 1.
1860 const uint64_t fId1 = getNextFrameId();
1861 dequeueAndQueue(0);
1862 mFrames[0].signalQueueFences();
1863
1864 // Dequeue and queue frame 2.
1865 dequeueAndQueue(1);
1866 mFrames[1].signalQueueFences();
1867
1868 addFrameEvents(true, NO_FRAME_INDEX, 0);
1869 addFrameEvents(true, 0, 1);
1870
1871 // Verify available timestamps are correct for frame 1, before any
1872 // fence has been signaled.
1873 // Note: A sync call is necessary here since the events triggered by
1874 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1875 resetTimestamps();
1876 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1877 int result = getAllFrameTimestamps(fId1);
1878 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1879 EXPECT_EQ(NO_ERROR, result);
1880 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1881 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1882 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1883 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1884 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1885 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1886 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1887 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1888 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1889
1890 // Verify available timestamps are correct for frame 1 again, before any
1891 // fence has been signaled.
1892 // This time a sync call should not be necessary.
1893 resetTimestamps();
1894 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1895 result = getAllFrameTimestamps(fId1);
1896 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1897 EXPECT_EQ(NO_ERROR, result);
1898 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1899 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1900 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1901 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1902 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1903 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1904 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1905 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1906 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1907
1908 // Signal the fences for frame 1.
1909 mFrames[0].signalRefreshFences();
1910 mFrames[0].signalReleaseFences();
1911
1912 // Verify all timestamps are available without a sync call.
1913 resetTimestamps();
1914 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1915 result = getAllFrameTimestamps(fId1);
1916 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1917 EXPECT_EQ(NO_ERROR, result);
1918 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1919 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1920 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1921 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1922 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1923 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1924 outGpuCompositionDoneTime);
1925 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1926 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1927 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1928 }
1929
1930 // This test verifies that if the frame wasn't GPU composited but has a refresh
1931 // event a sync call isn't made to get the GPU composite done time since it will
1932 // never exist.
TEST_F(GetFrameTimestampsTest,NoGpuNoSync)1933 TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1934 enableFrameTimestamps();
1935
1936 // Dequeue and queue frame 1.
1937 const uint64_t fId1 = getNextFrameId();
1938 dequeueAndQueue(0);
1939 mFrames[0].signalQueueFences();
1940
1941 // Dequeue and queue frame 2.
1942 dequeueAndQueue(1);
1943 mFrames[1].signalQueueFences();
1944
1945 addFrameEvents(false, NO_FRAME_INDEX, 0);
1946 addFrameEvents(false, 0, 1);
1947
1948 // Verify available timestamps are correct for frame 1, before any
1949 // fence has been signaled.
1950 // Note: A sync call is necessary here since the events triggered by
1951 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1952 resetTimestamps();
1953 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1954 int result = getAllFrameTimestamps(fId1);
1955 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1956 EXPECT_EQ(NO_ERROR, result);
1957 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1958 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1959 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1960 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1961 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1962 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1963 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1964 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1965 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1966
1967 // Signal the fences for frame 1.
1968 mFrames[0].signalRefreshFences();
1969 mFrames[0].signalReleaseFences();
1970
1971 // Verify all timestamps, except GPU composition, are available without a
1972 // sync call.
1973 resetTimestamps();
1974 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1975 result = getAllFrameTimestamps(fId1);
1976 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1977 EXPECT_EQ(NO_ERROR, result);
1978 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1979 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1980 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1981 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1982 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1983 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1984 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1985 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1986 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1987 }
1988
1989 // This test verifies that if the certain timestamps can't possibly exist for
1990 // the most recent frame, then a sync call is not done.
TEST_F(GetFrameTimestampsTest,NoReleaseNoSync)1991 TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
1992 enableFrameTimestamps();
1993
1994 // Dequeue and queue frame 1.
1995 const uint64_t fId1 = getNextFrameId();
1996 dequeueAndQueue(0);
1997 mFrames[0].signalQueueFences();
1998
1999 // Dequeue and queue frame 2.
2000 const uint64_t fId2 = getNextFrameId();
2001 dequeueAndQueue(1);
2002 mFrames[1].signalQueueFences();
2003
2004 addFrameEvents(false, NO_FRAME_INDEX, 0);
2005 addFrameEvents(false, 0, 1);
2006
2007 // Verify available timestamps are correct for frame 1, before any
2008 // fence has been signaled.
2009 // Note: A sync call is necessary here since the events triggered by
2010 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
2011 resetTimestamps();
2012 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2013 int result = getAllFrameTimestamps(fId1);
2014 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
2015 EXPECT_EQ(NO_ERROR, result);
2016 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
2017 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
2018 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
2019 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2020 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
2021 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
2022 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
2023 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
2024 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
2025
2026 mFrames[0].signalRefreshFences();
2027 mFrames[0].signalReleaseFences();
2028 mFrames[1].signalRefreshFences();
2029
2030 // Verify querying for all timestmaps of f2 does not do a sync call. Even
2031 // though the lastRefresh, dequeueReady, and release times aren't
2032 // available, a sync call should not occur because it's not possible for f2
2033 // to encounter the final value for those events until another frame is
2034 // queued.
2035 resetTimestamps();
2036 oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2037 result = getAllFrameTimestamps(fId2);
2038 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2039 EXPECT_EQ(NO_ERROR, result);
2040 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
2041 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
2042 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
2043 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
2044 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
2045 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
2046 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
2047 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
2048 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
2049 }
2050
2051 // This test verifies there are no sync calls for present times
2052 // when they aren't supported and that an error is returned.
2053
TEST_F(GetFrameTimestampsTest,PresentUnsupportedNoSync)2054 TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
2055 enableFrameTimestamps();
2056 mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
2057 mSurface->mFakeSurfaceComposerAIDL->setSupportsPresent(false);
2058
2059 // Dequeue and queue frame 1.
2060 const uint64_t fId1 = getNextFrameId();
2061 dequeueAndQueue(0);
2062
2063 // Verify a query for the Present times do not trigger a sync call if they
2064 // are not supported.
2065 resetTimestamps();
2066 int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
2067 int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
2068 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
2069 &outDisplayPresentTime, nullptr, nullptr);
2070 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
2071 EXPECT_EQ(BAD_VALUE, result);
2072 EXPECT_EQ(-1, outDisplayPresentTime);
2073 }
2074
TEST_F(SurfaceTest,DequeueWithConsumerDrivenSize)2075 TEST_F(SurfaceTest, DequeueWithConsumerDrivenSize) {
2076 sp<IGraphicBufferProducer> producer;
2077 sp<IGraphicBufferConsumer> consumer;
2078 BufferQueue::createBufferQueue(&producer, &consumer);
2079
2080 sp<MockConsumer> mockConsumer(new MockConsumer);
2081 consumer->consumerConnect(mockConsumer, false);
2082 consumer->setDefaultBufferSize(10, 10);
2083
2084 sp<Surface> surface = new Surface(producer);
2085 sp<ANativeWindow> window(surface);
2086 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2087 ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(window.get(), 0, 0));
2088 ASSERT_EQ(NO_ERROR, native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS));
2089
2090 int fence;
2091 ANativeWindowBuffer* buffer;
2092
2093 // Buffer size is driven by the consumer
2094 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2095 EXPECT_EQ(10, buffer->width);
2096 EXPECT_EQ(10, buffer->height);
2097 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2098
2099 // Buffer size is driven by the consumer
2100 consumer->setDefaultBufferSize(10, 20);
2101 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2102 EXPECT_EQ(10, buffer->width);
2103 EXPECT_EQ(20, buffer->height);
2104 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2105
2106 // Transform hint isn't synced to producer before queueBuffer or connect
2107 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2108 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2109 EXPECT_EQ(10, buffer->width);
2110 EXPECT_EQ(20, buffer->height);
2111 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2112
2113 // Transform hint is synced to producer but no auto prerotation
2114 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2115 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2116 EXPECT_EQ(10, buffer->width);
2117 EXPECT_EQ(20, buffer->height);
2118 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2119
2120 // Prerotation is driven by the consumer with the transform hint used by producer
2121 native_window_set_auto_prerotation(window.get(), true);
2122 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2123 EXPECT_EQ(20, buffer->width);
2124 EXPECT_EQ(10, buffer->height);
2125 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2126
2127 // Turn off auto prerotaton
2128 native_window_set_auto_prerotation(window.get(), false);
2129 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2130 EXPECT_EQ(10, buffer->width);
2131 EXPECT_EQ(20, buffer->height);
2132 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2133
2134 // Test auto prerotation bit is disabled after disconnect
2135 native_window_set_auto_prerotation(window.get(), true);
2136 native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU);
2137 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
2138 consumer->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_270);
2139 native_window_set_buffers_dimensions(window.get(), 0, 0);
2140 native_window_set_usage(window.get(), TEST_PRODUCER_USAGE_BITS);
2141 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
2142 EXPECT_EQ(10, buffer->width);
2143 EXPECT_EQ(20, buffer->height);
2144 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2145 }
2146
TEST_F(SurfaceTest,DefaultMaxBufferCountSetAndUpdated)2147 TEST_F(SurfaceTest, DefaultMaxBufferCountSetAndUpdated) {
2148 sp<IGraphicBufferProducer> producer;
2149 sp<IGraphicBufferConsumer> consumer;
2150 BufferQueue::createBufferQueue(&producer, &consumer);
2151
2152 sp<MockConsumer> mockConsumer(new MockConsumer);
2153 consumer->consumerConnect(mockConsumer, false);
2154
2155 sp<Surface> surface = new Surface(producer);
2156 sp<ANativeWindow> window(surface);
2157
2158 int count = -1;
2159 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2160 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2161
2162 consumer->setMaxBufferCount(10);
2163 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU));
2164 EXPECT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2165 EXPECT_EQ(10, count);
2166
2167 ASSERT_EQ(NO_ERROR, native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_CPU));
2168 ASSERT_EQ(NO_ERROR, window->query(window.get(), NATIVE_WINDOW_MAX_BUFFER_COUNT, &count));
2169 EXPECT_EQ(BufferQueueDefs::NUM_BUFFER_SLOTS, count);
2170 }
2171
TEST_F(SurfaceTest,BatchOperations)2172 TEST_F(SurfaceTest, BatchOperations) {
2173 const int BUFFER_COUNT = 16;
2174 const int BATCH_SIZE = 8;
2175
2176 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
2177 sp<Surface> surface = cpuConsumer->getSurface();
2178 sp<ANativeWindow> window(surface);
2179 sp<StubSurfaceListener> listener = new StubSurfaceListener();
2180
2181 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2182 /*reportBufferRemoval*/false));
2183
2184 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2185
2186 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2187
2188 // Batch dequeued buffers can be queued individually
2189 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2190 for (size_t i = 0; i < BATCH_SIZE; i++) {
2191 ANativeWindowBuffer* buffer = buffers[i].buffer;
2192 int fence = buffers[i].fenceFd;
2193 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
2194 }
2195
2196 // Batch dequeued buffers can be canceled individually
2197 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2198 for (size_t i = 0; i < BATCH_SIZE; i++) {
2199 ANativeWindowBuffer* buffer = buffers[i].buffer;
2200 int fence = buffers[i].fenceFd;
2201 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fence));
2202 }
2203
2204 // Batch dequeued buffers can be batch cancelled
2205 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2206 ASSERT_EQ(NO_ERROR, surface->cancelBuffers(buffers));
2207
2208 // Batch dequeued buffers can be batch queued
2209 ASSERT_EQ(NO_ERROR, surface->dequeueBuffers(&buffers));
2210 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2211 for (size_t i = 0; i < BATCH_SIZE; i++) {
2212 queuedBuffers[i].buffer = buffers[i].buffer;
2213 queuedBuffers[i].fenceFd = buffers[i].fenceFd;
2214 queuedBuffers[i].timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2215 }
2216 ASSERT_EQ(NO_ERROR, surface->queueBuffers(queuedBuffers));
2217
2218 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2219 }
2220
TEST_F(SurfaceTest,BatchIllegalOperations)2221 TEST_F(SurfaceTest, BatchIllegalOperations) {
2222 const int BUFFER_COUNT = 16;
2223 const int BATCH_SIZE = 8;
2224
2225 sp<CpuConsumer> cpuConsumer = new CpuConsumer(1);
2226 sp<Surface> surface = cpuConsumer->getSurface();
2227 sp<ANativeWindow> window(surface);
2228 sp<StubSurfaceListener> listener = new StubSurfaceListener();
2229
2230 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, /*listener*/listener,
2231 /*reportBufferRemoval*/false));
2232
2233 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
2234
2235 std::vector<Surface::BatchBuffer> buffers(BATCH_SIZE);
2236 std::vector<Surface::BatchQueuedBuffer> queuedBuffers(BATCH_SIZE);
2237
2238 // Batch operations are invalid in shared buffer mode
2239 surface->setSharedBufferMode(true);
2240 ASSERT_EQ(INVALID_OPERATION, surface->dequeueBuffers(&buffers));
2241 ASSERT_EQ(INVALID_OPERATION, surface->cancelBuffers(buffers));
2242 ASSERT_EQ(INVALID_OPERATION, surface->queueBuffers(queuedBuffers));
2243 surface->setSharedBufferMode(false);
2244
2245 ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
2246 }
2247
2248 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
2249
TEST_F(SurfaceTest,PlatformBufferMethods)2250 TEST_F(SurfaceTest, PlatformBufferMethods) {
2251 sp<CpuConsumer> cpuConsumer = sp<CpuConsumer>::make(1);
2252 sp<Surface> surface = cpuConsumer->getSurface();
2253 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2254 sp<GraphicBuffer> buffer;
2255 sp<Fence> fence;
2256
2257 EXPECT_EQ(OK,
2258 surface->connect(NATIVE_WINDOW_API_CPU, listener, /* reportBufferRemoval */ false));
2259
2260 //
2261 // Verify nullptrs are handled safely:
2262 //
2263
2264 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer((sp<GraphicBuffer>*)nullptr, nullptr));
2265 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer((sp<GraphicBuffer>*)nullptr, &fence));
2266 EXPECT_EQ(BAD_VALUE, surface->dequeueBuffer(&buffer, nullptr));
2267 EXPECT_EQ(BAD_VALUE, surface->queueBuffer(nullptr, nullptr));
2268 EXPECT_EQ(BAD_VALUE, surface->detachBuffer(nullptr));
2269
2270 //
2271 // Verify dequeue/queue:
2272 //
2273
2274 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2275 EXPECT_NE(nullptr, buffer);
2276 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2277
2278 //
2279 // Verify dequeue/detach:
2280 //
2281
2282 wp<GraphicBuffer> weakBuffer;
2283 {
2284 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2285
2286 EXPECT_EQ(OK, surface->detachBuffer(buffer));
2287
2288 weakBuffer = buffer;
2289 buffer = nullptr;
2290 }
2291 EXPECT_EQ(nullptr, weakBuffer.promote()) << "Weak buffer still held by Surface.";
2292
2293 //
2294 // Verify detach without borrowing the buffer does not work:
2295 //
2296
2297 sp<GraphicBuffer> heldTooLongBuffer;
2298 EXPECT_EQ(OK, surface->dequeueBuffer(&heldTooLongBuffer, &fence));
2299 EXPECT_EQ(OK, surface->queueBuffer(heldTooLongBuffer));
2300 EXPECT_EQ(BAD_VALUE, surface->detachBuffer(heldTooLongBuffer));
2301 }
2302
TEST_F(SurfaceTest,AllowAllocation)2303 TEST_F(SurfaceTest, AllowAllocation) {
2304 // controlledByApp must be true to disable blocking
2305 sp<CpuConsumer> cpuConsumer = sp<CpuConsumer>::make(1, /*controlledByApp*/ true);
2306 sp<Surface> surface = cpuConsumer->getSurface();
2307 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2308 sp<GraphicBuffer> buffer;
2309 sp<Fence> fence;
2310
2311 EXPECT_EQ(OK,
2312 surface->connect(NATIVE_WINDOW_API_CPU, listener, /* reportBufferRemoval */ false));
2313 EXPECT_EQ(OK, surface->allowAllocation(false));
2314
2315 EXPECT_EQ(OK, surface->setDequeueTimeout(-1));
2316 EXPECT_EQ(WOULD_BLOCK, surface->dequeueBuffer(&buffer, &fence));
2317
2318 EXPECT_EQ(OK, surface->setDequeueTimeout(10));
2319 EXPECT_EQ(TIMED_OUT, surface->dequeueBuffer(&buffer, &fence));
2320
2321 EXPECT_EQ(OK, surface->allowAllocation(true));
2322 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2323 }
2324
TEST_F(SurfaceTest,QueueAcquireReleaseDequeue_CalledInStack_DoesNotDeadlock)2325 TEST_F(SurfaceTest, QueueAcquireReleaseDequeue_CalledInStack_DoesNotDeadlock) {
2326 class DequeuingSurfaceListener : public SurfaceListener {
2327 public:
2328 DequeuingSurfaceListener(const wp<Surface>& surface) : mSurface(surface) {}
2329
2330 virtual void onBufferReleased() override {
2331 sp<Surface> surface = mSurface.promote();
2332 ASSERT_NE(nullptr, surface);
2333 EXPECT_EQ(OK, surface->dequeueBuffer(&mBuffer, &mFence));
2334 }
2335
2336 virtual bool needsReleaseNotify() override { return true; }
2337 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>&) override {}
2338 virtual void onBufferDetached(int) override {}
2339
2340 sp<GraphicBuffer> mBuffer;
2341 sp<Fence> mFence;
2342
2343 private:
2344 wp<Surface> mSurface;
2345 };
2346
2347 class ImmediateReleaseConsumerListener : public BufferItemConsumer::FrameAvailableListener {
2348 public:
2349 ImmediateReleaseConsumerListener(const wp<BufferItemConsumer>& consumer)
2350 : mConsumer(consumer) {}
2351
2352 virtual void onFrameAvailable(const BufferItem&) override {
2353 sp<BufferItemConsumer> consumer = mConsumer.promote();
2354 ASSERT_NE(nullptr, consumer);
2355
2356 mCalls += 1;
2357
2358 BufferItem buffer;
2359 EXPECT_EQ(OK, consumer->acquireBuffer(&buffer, 0));
2360 EXPECT_EQ(OK, consumer->releaseBuffer(buffer));
2361 }
2362
2363 size_t mCalls = 0;
2364
2365 private:
2366 wp<BufferItemConsumer> mConsumer;
2367 };
2368
2369 sp<IGraphicBufferProducer> bqProducer;
2370 sp<IGraphicBufferConsumer> bqConsumer;
2371 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
2372
2373 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(bqConsumer, 3);
2374 sp<Surface> surface = sp<Surface>::make(bqProducer);
2375 sp<ImmediateReleaseConsumerListener> consumerListener =
2376 sp<ImmediateReleaseConsumerListener>::make(consumer);
2377 consumer->setFrameAvailableListener(consumerListener);
2378
2379 sp<DequeuingSurfaceListener> surfaceListener = sp<DequeuingSurfaceListener>::make(surface);
2380 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, surfaceListener, false));
2381
2382 EXPECT_EQ(OK, surface->setMaxDequeuedBufferCount(2));
2383
2384 sp<GraphicBuffer> buffer;
2385 sp<Fence> fence;
2386 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2387 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2388
2389 EXPECT_EQ(1u, consumerListener->mCalls);
2390 EXPECT_NE(nullptr, surfaceListener->mBuffer);
2391
2392 EXPECT_EQ(OK, surface->disconnect(NATIVE_WINDOW_API_CPU));
2393 }
2394
TEST_F(SurfaceTest,ViewSurface_toString)2395 TEST_F(SurfaceTest, ViewSurface_toString) {
2396 view::Surface surface{};
2397 EXPECT_EQ("", surface.toString());
2398
2399 surface.name = String16("name");
2400 EXPECT_EQ("name", surface.toString());
2401 }
2402
TEST_F(SurfaceTest,TestRemoteSurfaceDied_CallbackCalled)2403 TEST_F(SurfaceTest, TestRemoteSurfaceDied_CallbackCalled) {
2404 sp<TestServerClient> testServer = TestServerClient::Create();
2405 sp<IGraphicBufferProducer> producer = testServer->CreateProducer();
2406 EXPECT_NE(nullptr, producer);
2407
2408 sp<Surface> surface = sp<Surface>::make(producer);
2409 sp<DeathWatcherListener> deathWatcher = sp<DeathWatcherListener>::make();
2410 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, deathWatcher));
2411
2412 auto diedFuture = deathWatcher->getDiedFuture();
2413 EXPECT_EQ(OK, testServer->Kill());
2414
2415 diedFuture.wait();
2416 EXPECT_TRUE(diedFuture.get());
2417 }
2418
TEST_F(SurfaceTest,TestRemoteSurfaceDied_Disconnect_CallbackNotCalled)2419 TEST_F(SurfaceTest, TestRemoteSurfaceDied_Disconnect_CallbackNotCalled) {
2420 sp<TestServerClient> testServer = TestServerClient::Create();
2421 sp<IGraphicBufferProducer> producer = testServer->CreateProducer();
2422 EXPECT_NE(nullptr, producer);
2423
2424 sp<Surface> surface = sp<Surface>::make(producer);
2425 sp<DeathWatcherListener> deathWatcher = sp<DeathWatcherListener>::make();
2426 EXPECT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, deathWatcher));
2427 EXPECT_EQ(OK, surface->disconnect(NATIVE_WINDOW_API_CPU));
2428
2429 auto watcherDiedFuture = deathWatcher->getDiedFuture();
2430 EXPECT_EQ(OK, testServer->Kill());
2431
2432 std::future_status status = watcherDiedFuture.wait_for(std::chrono::seconds(1));
2433 EXPECT_EQ(std::future_status::timeout, status);
2434 }
2435
TEST_F(SurfaceTest,QueueBufferOutput_TracksReplacements)2436 TEST_F(SurfaceTest, QueueBufferOutput_TracksReplacements) {
2437 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(GRALLOC_USAGE_SW_READ_OFTEN);
2438 ASSERT_EQ(OK, consumer->setMaxBufferCount(3));
2439 ASSERT_EQ(OK, consumer->setMaxAcquiredBufferCount(1));
2440
2441 sp<Surface> surface = consumer->getSurface();
2442 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2443
2444 // Async mode sets up an extra buffer so the surface can queue it without waiting.
2445 ASSERT_EQ(OK, surface->setMaxDequeuedBufferCount(1));
2446 ASSERT_EQ(OK, surface->setAsyncMode(true));
2447 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, listener));
2448
2449 sp<GraphicBuffer> buffer;
2450 sp<Fence> fence;
2451 SurfaceQueueBufferOutput output;
2452 BufferItem item;
2453
2454 // We can queue directly, without an output arg.
2455 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2456 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence));
2457 EXPECT_EQ(OK, consumer->acquireBuffer(&item, 0));
2458 EXPECT_EQ(OK, consumer->releaseBuffer(item));
2459
2460 // We can queue with an output arg, and that we don't expect to see a replacement.
2461 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2462 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence, &output));
2463 EXPECT_FALSE(output.bufferReplaced);
2464
2465 // We expect see a replacement when we queue a second buffer in async mode, and the consumer
2466 // hasn't acquired the first one yet.
2467 EXPECT_EQ(OK, surface->dequeueBuffer(&buffer, &fence));
2468 EXPECT_EQ(OK, surface->queueBuffer(buffer, fence, &output));
2469 EXPECT_TRUE(output.bufferReplaced);
2470 }
2471
TEST_F(SurfaceTest,QueueBufferOutput_TracksReplacements_Plural)2472 TEST_F(SurfaceTest, QueueBufferOutput_TracksReplacements_Plural) {
2473 sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(GRALLOC_USAGE_SW_READ_OFTEN);
2474 ASSERT_EQ(OK, consumer->setMaxBufferCount(4));
2475 ASSERT_EQ(OK, consumer->setMaxAcquiredBufferCount(1));
2476
2477 sp<Surface> surface = consumer->getSurface();
2478 consumer->setName(String8("TRPTest"));
2479 sp<StubSurfaceListener> listener = sp<StubSurfaceListener>::make();
2480
2481 // Async mode sets up an extra buffer so the surface can queue it without waiting.
2482 ASSERT_EQ(OK, surface->setMaxDequeuedBufferCount(2));
2483 ASSERT_EQ(OK, surface->setAsyncMode(true));
2484 ASSERT_EQ(OK, surface->connect(NATIVE_WINDOW_API_CPU, listener));
2485
2486 // dequeueBuffers requires a vector of a certain size:
2487 std::vector<Surface::BatchBuffer> buffers(2);
2488 std::vector<Surface::BatchQueuedBuffer> queuedBuffers;
2489 std::vector<SurfaceQueueBufferOutput> outputs;
2490 BufferItem item;
2491
2492 auto moveBuffersToQueuedBuffers = [&]() {
2493 EXPECT_EQ(2u, buffers.size());
2494 EXPECT_NE(nullptr, buffers[0].buffer);
2495 EXPECT_NE(nullptr, buffers[1].buffer);
2496
2497 queuedBuffers.clear();
2498 for (auto& buffer : buffers) {
2499 auto& queuedBuffer = queuedBuffers.emplace_back();
2500 queuedBuffer.buffer = buffer.buffer;
2501 queuedBuffer.fenceFd = buffer.fenceFd;
2502 queuedBuffer.timestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
2503 }
2504 buffers = {{}, {}};
2505 };
2506
2507 // We can queue directly, without an output arg.
2508 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2509 moveBuffersToQueuedBuffers();
2510 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers));
2511 EXPECT_EQ(OK, consumer->acquireBuffer(&item, 0));
2512 EXPECT_EQ(OK, consumer->releaseBuffer(item));
2513
2514 // We can queue with an output arg. Only the second one should be replaced.
2515 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2516 moveBuffersToQueuedBuffers();
2517 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers, &outputs));
2518 EXPECT_EQ(2u, outputs.size());
2519 EXPECT_FALSE(outputs[0].bufferReplaced);
2520 EXPECT_TRUE(outputs[1].bufferReplaced);
2521
2522 // Since we haven't acquired anything, both queued buffers will replace the original one.
2523 EXPECT_EQ(OK, surface->dequeueBuffers(&buffers));
2524 moveBuffersToQueuedBuffers();
2525 EXPECT_EQ(OK, surface->queueBuffers(queuedBuffers, &outputs));
2526 EXPECT_EQ(2u, outputs.size());
2527 EXPECT_TRUE(outputs[0].bufferReplaced);
2528 EXPECT_TRUE(outputs[1].bufferReplaced);
2529 }
2530 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
2531
2532 } // namespace android
2533