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