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