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 "DummyConsumer.h" 18 19#include <gtest/gtest.h> 20 21#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h> 22#include <binder/ProcessState.h> 23#include <configstore/Utils.h> 24#include <cutils/properties.h> 25#include <gui/BufferItemConsumer.h> 26#include <gui/IDisplayEventConnection.h> 27#include <gui/IProducerListener.h> 28#include <gui/ISurfaceComposer.h> 29#include <gui/Surface.h> 30#include <gui/SurfaceComposerClient.h> 31#include <private/gui/ComposerService.h> 32#include <ui/Rect.h> 33#include <utils/String8.h> 34 35#include <limits> 36#include <thread> 37 38namespace android { 39 40using namespace std::chrono_literals; 41// retrieve wide-color and hdr settings from configstore 42using namespace android::hardware::configstore; 43using namespace android::hardware::configstore::V1_0; 44 45static bool hasWideColorDisplay = 46 getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false); 47 48class FakeSurfaceComposer; 49class FakeProducerFrameEventHistory; 50 51static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max(); 52 53class SurfaceTest : public ::testing::Test { 54protected: 55 56 SurfaceTest() { 57 ProcessState::self()->startThreadPool(); 58 } 59 60 virtual void SetUp() { 61 mComposerClient = new SurfaceComposerClient; 62 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck()); 63 64 // TODO(brianderson): The following sometimes fails and is a source of 65 // test flakiness. 66 mSurfaceControl = mComposerClient->createSurface( 67 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0); 68 69 ASSERT_TRUE(mSurfaceControl != NULL); 70 ASSERT_TRUE(mSurfaceControl->isValid()); 71 72 SurfaceComposerClient::openGlobalTransaction(); 73 ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff)); 74 ASSERT_EQ(NO_ERROR, mSurfaceControl->show()); 75 SurfaceComposerClient::closeGlobalTransaction(); 76 77 mSurface = mSurfaceControl->getSurface(); 78 ASSERT_TRUE(mSurface != NULL); 79 } 80 81 virtual void TearDown() { 82 mComposerClient->dispose(); 83 } 84 85 sp<Surface> mSurface; 86 sp<SurfaceComposerClient> mComposerClient; 87 sp<SurfaceControl> mSurfaceControl; 88}; 89 90TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) { 91 sp<ANativeWindow> anw(mSurface); 92 int result = -123; 93 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, 94 &result); 95 EXPECT_EQ(NO_ERROR, err); 96 EXPECT_EQ(1, result); 97} 98 99TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) { 100 mSurfaceControl.clear(); 101 // Wait for the async clean-up to complete. 102 std::this_thread::sleep_for(50ms); 103 104 sp<ANativeWindow> anw(mSurface); 105 int result = -123; 106 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, 107 &result); 108 EXPECT_EQ(NO_ERROR, err); 109 EXPECT_EQ(1, result); 110} 111 112// This test probably doesn't belong here. 113TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) { 114 sp<ANativeWindow> anw(mSurface); 115 116 // Verify the screenshot works with no protected buffers. 117 sp<IGraphicBufferProducer> producer; 118 sp<IGraphicBufferConsumer> consumer; 119 BufferQueue::createBufferQueue(&producer, &consumer); 120 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 121 sp<ISurfaceComposer> sf(ComposerService::getComposerService()); 122 sp<IBinder> display(sf->getBuiltInDisplay( 123 ISurfaceComposer::eDisplayIdMain)); 124 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 125 64, 64, 0, 0x7fffffff, false)); 126 127 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), 128 NATIVE_WINDOW_API_CPU)); 129 // Set the PROTECTED usage bit and verify that the screenshot fails. Note 130 // that we need to dequeue a buffer in order for it to actually get 131 // allocated in SurfaceFlinger. 132 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 133 GRALLOC_USAGE_PROTECTED)); 134 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3)); 135 ANativeWindowBuffer* buf = 0; 136 137 status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf); 138 if (err) { 139 // we could fail if GRALLOC_USAGE_PROTECTED is not supported. 140 // that's okay as long as this is the reason for the failure. 141 // try again without the GRALLOC_USAGE_PROTECTED bit. 142 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0)); 143 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), 144 &buf)); 145 return; 146 } 147 ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1)); 148 149 for (int i = 0; i < 4; i++) { 150 // Loop to make sure SurfaceFlinger has retired a protected buffer. 151 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), 152 &buf)); 153 ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1)); 154 } 155 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 156 64, 64, 0, 0x7fffffff, false)); 157} 158 159TEST_F(SurfaceTest, ConcreteTypeIsSurface) { 160 sp<ANativeWindow> anw(mSurface); 161 int result = -123; 162 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result); 163 EXPECT_EQ(NO_ERROR, err); 164 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result); 165} 166 167TEST_F(SurfaceTest, LayerCountIsOne) { 168 sp<ANativeWindow> anw(mSurface); 169 int result = -123; 170 int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result); 171 EXPECT_EQ(NO_ERROR, err); 172 EXPECT_EQ(1, result); 173} 174 175TEST_F(SurfaceTest, QueryConsumerUsage) { 176 const int TEST_USAGE_FLAGS = 177 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER; 178 sp<IGraphicBufferProducer> producer; 179 sp<IGraphicBufferConsumer> consumer; 180 BufferQueue::createBufferQueue(&producer, &consumer); 181 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer, 182 TEST_USAGE_FLAGS); 183 sp<Surface> s = new Surface(producer); 184 185 sp<ANativeWindow> anw(s); 186 187 int flags = -1; 188 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags); 189 190 ASSERT_EQ(NO_ERROR, err); 191 ASSERT_EQ(TEST_USAGE_FLAGS, flags); 192} 193 194TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) { 195 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB; 196 sp<IGraphicBufferProducer> producer; 197 sp<IGraphicBufferConsumer> consumer; 198 BufferQueue::createBufferQueue(&producer, &consumer); 199 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 200 201 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE); 202 203 sp<Surface> s = new Surface(producer); 204 205 sp<ANativeWindow> anw(s); 206 207 android_dataspace dataSpace; 208 209 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE, 210 reinterpret_cast<int*>(&dataSpace)); 211 212 ASSERT_EQ(NO_ERROR, err); 213 ASSERT_EQ(TEST_DATASPACE, dataSpace); 214} 215 216TEST_F(SurfaceTest, SettingGenerationNumber) { 217 sp<IGraphicBufferProducer> producer; 218 sp<IGraphicBufferConsumer> consumer; 219 BufferQueue::createBufferQueue(&producer, &consumer); 220 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 221 sp<Surface> surface = new Surface(producer); 222 sp<ANativeWindow> window(surface); 223 224 // Allocate a buffer with a generation number of 0 225 ANativeWindowBuffer* buffer; 226 int fenceFd; 227 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), 228 NATIVE_WINDOW_API_CPU)); 229 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd)); 230 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd)); 231 232 // Detach the buffer and check its generation number 233 sp<GraphicBuffer> graphicBuffer; 234 sp<Fence> fence; 235 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence)); 236 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber()); 237 238 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1)); 239 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get()); 240 241 // This should change the generation number of the GraphicBuffer 242 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer)); 243 244 // Check that the new generation number sticks with the buffer 245 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1)); 246 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd)); 247 graphicBuffer = static_cast<GraphicBuffer*>(buffer); 248 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber()); 249} 250 251TEST_F(SurfaceTest, GetConsumerName) { 252 sp<IGraphicBufferProducer> producer; 253 sp<IGraphicBufferConsumer> consumer; 254 BufferQueue::createBufferQueue(&producer, &consumer); 255 256 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 257 consumer->consumerConnect(dummyConsumer, false); 258 consumer->setConsumerName(String8("TestConsumer")); 259 260 sp<Surface> surface = new Surface(producer); 261 sp<ANativeWindow> window(surface); 262 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU); 263 264 EXPECT_STREQ("TestConsumer", surface->getConsumerName().string()); 265} 266 267TEST_F(SurfaceTest, GetWideColorSupport) { 268 sp<IGraphicBufferProducer> producer; 269 sp<IGraphicBufferConsumer> consumer; 270 BufferQueue::createBufferQueue(&producer, &consumer); 271 272 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 273 consumer->consumerConnect(dummyConsumer, false); 274 consumer->setConsumerName(String8("TestConsumer")); 275 276 sp<Surface> surface = new Surface(producer); 277 sp<ANativeWindow> window(surface); 278 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU); 279 280 bool supported; 281 surface->getWideColorSupport(&supported); 282 283 // NOTE: This test assumes that device that supports 284 // wide-color (as indicated by BoardConfig) must also 285 // have a wide-color primary display. 286 // That assumption allows this test to cover devices 287 // that advertised a wide-color color mode without 288 // actually supporting wide-color to pass this test 289 // as well as the case of a device that does support 290 // wide-color (via BoardConfig) and has a wide-color 291 // primary display. 292 // NOT covered at this time is a device that supports 293 // wide color in the BoardConfig but does not support 294 // a wide-color color mode on the primary display. 295 ASSERT_EQ(hasWideColorDisplay, supported); 296} 297 298TEST_F(SurfaceTest, DynamicSetBufferCount) { 299 sp<IGraphicBufferProducer> producer; 300 sp<IGraphicBufferConsumer> consumer; 301 BufferQueue::createBufferQueue(&producer, &consumer); 302 303 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 304 consumer->consumerConnect(dummyConsumer, false); 305 consumer->setConsumerName(String8("TestConsumer")); 306 307 sp<Surface> surface = new Surface(producer); 308 sp<ANativeWindow> window(surface); 309 310 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), 311 NATIVE_WINDOW_API_CPU)); 312 native_window_set_buffer_count(window.get(), 4); 313 314 int fence; 315 ANativeWindowBuffer* buffer; 316 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence)); 317 native_window_set_buffer_count(window.get(), 3); 318 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence)); 319 native_window_set_buffer_count(window.get(), 2); 320 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence)); 321 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence)); 322} 323 324TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) { 325 sp<IGraphicBufferProducer> producer; 326 sp<IGraphicBufferConsumer> consumer; 327 BufferQueue::createBufferQueue(&producer, &consumer); 328 329 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 330 consumer->consumerConnect(dummyConsumer, false); 331 consumer->setConsumerName(String8("TestConsumer")); 332 333 sp<Surface> surface = new Surface(producer); 334 sp<ANativeWindow> window(surface); 335 sp<DummyProducerListener> listener = new DummyProducerListener(); 336 ASSERT_EQ(OK, surface->connect( 337 NATIVE_WINDOW_API_CPU, 338 /*listener*/listener, 339 /*reportBufferRemoval*/true)); 340 const int BUFFER_COUNT = 4; 341 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT)); 342 343 sp<GraphicBuffer> detachedBuffer; 344 sp<Fence> outFence; 345 int fences[BUFFER_COUNT]; 346 ANativeWindowBuffer* buffers[BUFFER_COUNT]; 347 // Allocate buffers because detachNextBuffer requires allocated buffers 348 for (int i = 0; i < BUFFER_COUNT; i++) { 349 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i])); 350 } 351 for (int i = 0; i < BUFFER_COUNT; i++) { 352 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i])); 353 } 354 355 // Test detached buffer is correctly reported 356 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence)); 357 std::vector<sp<GraphicBuffer>> removedBuffers; 358 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers)); 359 ASSERT_EQ(1u, removedBuffers.size()); 360 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle); 361 // Test the list is flushed one getAndFlushRemovedBuffers returns 362 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers)); 363 ASSERT_EQ(0u, removedBuffers.size()); 364 365 366 // Test removed buffer list is cleanup after next dequeueBuffer call 367 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence)); 368 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0])); 369 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers)); 370 ASSERT_EQ(0u, removedBuffers.size()); 371 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0])); 372 373 // Test removed buffer list is cleanup after next detachNextBuffer call 374 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence)); 375 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence)); 376 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers)); 377 ASSERT_EQ(1u, removedBuffers.size()); 378 ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle); 379 380 // Re-allocate buffers since all buffers are detached up to now 381 for (int i = 0; i < BUFFER_COUNT; i++) { 382 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i])); 383 } 384 for (int i = 0; i < BUFFER_COUNT; i++) { 385 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i])); 386 } 387 388 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence)); 389 ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get())); 390 ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers)); 391 // Depends on which slot GraphicBufferProducer impl pick, the attach call might 392 // get 0 or 1 buffer removed. 393 ASSERT_LE(removedBuffers.size(), 1u); 394} 395 396TEST_F(SurfaceTest, TestGetLastDequeueStartTime) { 397 sp<ANativeWindow> anw(mSurface); 398 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU)); 399 400 ANativeWindowBuffer* buffer = nullptr; 401 int32_t fenceFd = -1; 402 403 nsecs_t before = systemTime(CLOCK_MONOTONIC); 404 anw->dequeueBuffer(anw.get(), &buffer, &fenceFd); 405 nsecs_t after = systemTime(CLOCK_MONOTONIC); 406 407 nsecs_t lastDequeueTime = mSurface->getLastDequeueStartTime(); 408 ASSERT_LE(before, lastDequeueTime); 409 ASSERT_GE(after, lastDequeueTime); 410} 411 412class FakeConsumer : public BnConsumerListener { 413public: 414 void onFrameAvailable(const BufferItem& /*item*/) override {} 415 void onBuffersReleased() override {} 416 void onSidebandStreamChanged() override {} 417 418 void addAndGetFrameTimestamps( 419 const NewFrameEventsEntry* newTimestamps, 420 FrameEventHistoryDelta* outDelta) override { 421 if (newTimestamps) { 422 if (mGetFrameTimestampsEnabled) { 423 EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) << 424 "Test should set mNewFrameEntryOverride before queuing " 425 "a frame."; 426 EXPECT_EQ(newTimestamps->frameNumber, 427 mNewFrameEntryOverride.frameNumber) << 428 "Test attempting to add NewFrameEntryOverride with " 429 "incorrect frame number."; 430 mFrameEventHistory.addQueue(mNewFrameEntryOverride); 431 mNewFrameEntryOverride.frameNumber = 0; 432 } 433 mAddFrameTimestampsCount++; 434 mLastAddedFrameNumber = newTimestamps->frameNumber; 435 } 436 if (outDelta) { 437 mFrameEventHistory.getAndResetDelta(outDelta); 438 mGetFrameTimestampsCount++; 439 } 440 mAddAndGetFrameTimestampsCallCount++; 441 } 442 443 bool mGetFrameTimestampsEnabled = false; 444 445 ConsumerFrameEventHistory mFrameEventHistory; 446 int mAddAndGetFrameTimestampsCallCount = 0; 447 int mAddFrameTimestampsCount = 0; 448 int mGetFrameTimestampsCount = 0; 449 uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX; 450 451 NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr }; 452}; 453 454 455class FakeSurfaceComposer : public ISurfaceComposer{ 456public: 457 ~FakeSurfaceComposer() override {} 458 459 void setSupportsPresent(bool supportsPresent) { 460 mSupportsPresent = supportsPresent; 461 } 462 463 sp<ISurfaceComposerClient> createConnection() override { return nullptr; } 464 sp<ISurfaceComposerClient> createScopedConnection( 465 const sp<IGraphicBufferProducer>& /* parent */) override { 466 return nullptr; 467 } 468 sp<IDisplayEventConnection> createDisplayEventConnection(ISurfaceComposer::VsyncSource) 469 override { 470 return nullptr; 471 } 472 sp<IBinder> createDisplay(const String8& /*displayName*/, 473 bool /*secure*/) override { return nullptr; } 474 void destroyDisplay(const sp<IBinder>& /*display */) override {} 475 sp<IBinder> getBuiltInDisplay(int32_t /*id*/) override { return nullptr; } 476 void setTransactionState(const Vector<ComposerState>& /*state*/, 477 const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/) 478 override {} 479 void bootFinished() override {} 480 bool authenticateSurfaceTexture( 481 const sp<IGraphicBufferProducer>& /*surface*/) const override { 482 return false; 483 } 484 485 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) 486 const override { 487 *outSupported = { 488 FrameEvent::REQUESTED_PRESENT, 489 FrameEvent::ACQUIRE, 490 FrameEvent::LATCH, 491 FrameEvent::FIRST_REFRESH_START, 492 FrameEvent::LAST_REFRESH_START, 493 FrameEvent::GPU_COMPOSITION_DONE, 494 FrameEvent::DEQUEUE_READY, 495 FrameEvent::RELEASE 496 }; 497 if (mSupportsPresent) { 498 outSupported->push_back( 499 FrameEvent::DISPLAY_PRESENT); 500 } 501 return NO_ERROR; 502 } 503 504 void setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {} 505 status_t getDisplayConfigs(const sp<IBinder>& /*display*/, 506 Vector<DisplayInfo>* /*configs*/) override { return NO_ERROR; } 507 status_t getDisplayStats(const sp<IBinder>& /*display*/, 508 DisplayStatInfo* /*stats*/) override { return NO_ERROR; } 509 int getActiveConfig(const sp<IBinder>& /*display*/) override { return 0; } 510 status_t setActiveConfig(const sp<IBinder>& /*display*/, int /*id*/) 511 override { 512 return NO_ERROR; 513 } 514 status_t getDisplayColorModes(const sp<IBinder>& /*display*/, 515 Vector<android_color_mode_t>* /*outColorModes*/) override { 516 return NO_ERROR; 517 } 518 android_color_mode_t getActiveColorMode(const sp<IBinder>& /*display*/) 519 override { 520 return HAL_COLOR_MODE_NATIVE; 521 } 522 status_t setActiveColorMode(const sp<IBinder>& /*display*/, 523 android_color_mode_t /*colorMode*/) override { return NO_ERROR; } 524 status_t captureScreen(const sp<IBinder>& /*display*/, 525 const sp<IGraphicBufferProducer>& /*producer*/, 526 Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/, 527 int32_t /*minLayerZ*/, int32_t /*maxLayerZ*/, 528 bool /*useIdentityTransform*/, 529 Rotation /*rotation*/) override { return NO_ERROR; } 530 status_t clearAnimationFrameStats() override { return NO_ERROR; } 531 status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override { 532 return NO_ERROR; 533 } 534 status_t getHdrCapabilities(const sp<IBinder>& /*display*/, 535 HdrCapabilities* /*outCapabilities*/) const override { 536 return NO_ERROR; 537 } 538 status_t enableVSyncInjections(bool /*enable*/) override { 539 return NO_ERROR; 540 } 541 status_t injectVSync(nsecs_t /*when*/) override { return NO_ERROR; } 542 543protected: 544 IBinder* onAsBinder() override { return nullptr; } 545 546private: 547 bool mSupportsPresent{true}; 548}; 549 550class FakeProducerFrameEventHistory : public ProducerFrameEventHistory { 551public: 552 FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap) 553 : mFenceMap(fenceMap) {} 554 555 ~FakeProducerFrameEventHistory() {} 556 557 void updateAcquireFence(uint64_t frameNumber, 558 std::shared_ptr<FenceTime>&& acquire) override { 559 // Verify the acquire fence being added isn't the one from the consumer. 560 EXPECT_NE(mConsumerAcquireFence, acquire); 561 // Override the fence, so we can verify this was called by the 562 // producer after the frame is queued. 563 ProducerFrameEventHistory::updateAcquireFence(frameNumber, 564 std::shared_ptr<FenceTime>(mAcquireFenceOverride)); 565 } 566 567 void setAcquireFenceOverride( 568 const std::shared_ptr<FenceTime>& acquireFenceOverride, 569 const std::shared_ptr<FenceTime>& consumerAcquireFence) { 570 mAcquireFenceOverride = acquireFenceOverride; 571 mConsumerAcquireFence = consumerAcquireFence; 572 } 573 574protected: 575 std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence) 576 const override { 577 return mFenceMap->createFenceTimeForTest(fence); 578 } 579 580 FenceToFenceTimeMap* mFenceMap{nullptr}; 581 582 std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE}; 583 std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE}; 584}; 585 586 587class TestSurface : public Surface { 588public: 589 TestSurface(const sp<IGraphicBufferProducer>& bufferProducer, 590 FenceToFenceTimeMap* fenceMap) 591 : Surface(bufferProducer), 592 mFakeSurfaceComposer(new FakeSurfaceComposer) { 593 mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap); 594 mFrameEventHistory.reset(mFakeFrameEventHistory); 595 } 596 597 ~TestSurface() override {} 598 599 sp<ISurfaceComposer> composerService() const override { 600 return mFakeSurfaceComposer; 601 } 602 603 nsecs_t now() const override { 604 return mNow; 605 } 606 607 void setNow(nsecs_t now) { 608 mNow = now; 609 } 610 611public: 612 sp<FakeSurfaceComposer> mFakeSurfaceComposer; 613 nsecs_t mNow = 0; 614 615 // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory, 616 // but this raw pointer gives access to test functionality. 617 FakeProducerFrameEventHistory* mFakeFrameEventHistory; 618}; 619 620 621class GetFrameTimestampsTest : public ::testing::Test { 622protected: 623 struct FenceAndFenceTime { 624 explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap) 625 : mFence(new Fence), 626 mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {} 627 sp<Fence> mFence { nullptr }; 628 std::shared_ptr<FenceTime> mFenceTime { nullptr }; 629 }; 630 631 struct RefreshEvents { 632 RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart) 633 : mFenceMap(fenceMap), 634 kCompositorTiming( 635 {refreshStart, refreshStart + 1, refreshStart + 2 }), 636 kStartTime(refreshStart + 3), 637 kGpuCompositionDoneTime(refreshStart + 4), 638 kPresentTime(refreshStart + 5) {} 639 640 void signalPostCompositeFences() { 641 mFenceMap.signalAllForTest( 642 mGpuCompositionDone.mFence, kGpuCompositionDoneTime); 643 mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime); 644 } 645 646 FenceToFenceTimeMap& mFenceMap; 647 648 FenceAndFenceTime mGpuCompositionDone { mFenceMap }; 649 FenceAndFenceTime mPresent { mFenceMap }; 650 651 const CompositorTiming kCompositorTiming; 652 653 const nsecs_t kStartTime; 654 const nsecs_t kGpuCompositionDoneTime; 655 const nsecs_t kPresentTime; 656 }; 657 658 struct FrameEvents { 659 FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime) 660 : mFenceMap(fenceMap), 661 kPostedTime(frameStartTime + 100), 662 kRequestedPresentTime(frameStartTime + 200), 663 kProducerAcquireTime(frameStartTime + 300), 664 kConsumerAcquireTime(frameStartTime + 301), 665 kLatchTime(frameStartTime + 500), 666 kDequeueReadyTime(frameStartTime + 600), 667 kReleaseTime(frameStartTime + 700), 668 mRefreshes { 669 { mFenceMap, frameStartTime + 410 }, 670 { mFenceMap, frameStartTime + 420 }, 671 { mFenceMap, frameStartTime + 430 } } {} 672 673 void signalQueueFences() { 674 mFenceMap.signalAllForTest( 675 mAcquireConsumer.mFence, kConsumerAcquireTime); 676 mFenceMap.signalAllForTest( 677 mAcquireProducer.mFence, kProducerAcquireTime); 678 } 679 680 void signalRefreshFences() { 681 for (auto& re : mRefreshes) { 682 re.signalPostCompositeFences(); 683 } 684 } 685 686 void signalReleaseFences() { 687 mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime); 688 } 689 690 FenceToFenceTimeMap& mFenceMap; 691 692 FenceAndFenceTime mAcquireConsumer { mFenceMap }; 693 FenceAndFenceTime mAcquireProducer { mFenceMap }; 694 FenceAndFenceTime mRelease { mFenceMap }; 695 696 const nsecs_t kPostedTime; 697 const nsecs_t kRequestedPresentTime; 698 const nsecs_t kProducerAcquireTime; 699 const nsecs_t kConsumerAcquireTime; 700 const nsecs_t kLatchTime; 701 const nsecs_t kDequeueReadyTime; 702 const nsecs_t kReleaseTime; 703 704 RefreshEvents mRefreshes[3]; 705 }; 706 707 GetFrameTimestampsTest() {} 708 709 virtual void SetUp() { 710 BufferQueue::createBufferQueue(&mProducer, &mConsumer); 711 mFakeConsumer = new FakeConsumer; 712 mCfeh = &mFakeConsumer->mFrameEventHistory; 713 mConsumer->consumerConnect(mFakeConsumer, false); 714 mConsumer->setConsumerName(String8("TestConsumer")); 715 mSurface = new TestSurface(mProducer, &mFenceMap); 716 mWindow = mSurface; 717 718 ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(), 719 NATIVE_WINDOW_API_CPU)); 720 native_window_set_buffer_count(mWindow.get(), 4); 721 } 722 723 void disableFrameTimestamps() { 724 mFakeConsumer->mGetFrameTimestampsEnabled = false; 725 native_window_enable_frame_timestamps(mWindow.get(), 0); 726 mFrameTimestampsEnabled = false; 727 } 728 729 void enableFrameTimestamps() { 730 mFakeConsumer->mGetFrameTimestampsEnabled = true; 731 native_window_enable_frame_timestamps(mWindow.get(), 1); 732 mFrameTimestampsEnabled = true; 733 } 734 735 int getAllFrameTimestamps(uint64_t frameId) { 736 return native_window_get_frame_timestamps(mWindow.get(), frameId, 737 &outRequestedPresentTime, &outAcquireTime, &outLatchTime, 738 &outFirstRefreshStartTime, &outLastRefreshStartTime, 739 &outGpuCompositionDoneTime, &outDisplayPresentTime, 740 &outDequeueReadyTime, &outReleaseTime); 741 } 742 743 void resetTimestamps() { 744 outRequestedPresentTime = -1; 745 outAcquireTime = -1; 746 outLatchTime = -1; 747 outFirstRefreshStartTime = -1; 748 outLastRefreshStartTime = -1; 749 outGpuCompositionDoneTime = -1; 750 outDisplayPresentTime = -1; 751 outDequeueReadyTime = -1; 752 outReleaseTime = -1; 753 } 754 755 uint64_t getNextFrameId() { 756 uint64_t frameId = -1; 757 int status = native_window_get_next_frame_id(mWindow.get(), &frameId); 758 EXPECT_EQ(status, NO_ERROR); 759 return frameId; 760 } 761 762 void dequeueAndQueue(uint64_t frameIndex) { 763 int fence = -1; 764 ANativeWindowBuffer* buffer = nullptr; 765 ASSERT_EQ(NO_ERROR, 766 mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence)); 767 768 int oldAddFrameTimestampsCount = 769 mFakeConsumer->mAddFrameTimestampsCount; 770 771 FrameEvents* frame = &mFrames[frameIndex]; 772 uint64_t frameNumber = frameIndex + 1; 773 774 NewFrameEventsEntry fe; 775 fe.frameNumber = frameNumber; 776 fe.postedTime = frame->kPostedTime; 777 fe.requestedPresentTime = frame->kRequestedPresentTime; 778 fe.acquireFence = frame->mAcquireConsumer.mFenceTime; 779 mFakeConsumer->mNewFrameEntryOverride = fe; 780 781 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride( 782 frame->mAcquireProducer.mFenceTime, 783 frame->mAcquireConsumer.mFenceTime); 784 785 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence)); 786 787 EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber); 788 789 EXPECT_EQ( 790 oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0), 791 mFakeConsumer->mAddFrameTimestampsCount); 792 } 793 794 void addFrameEvents( 795 bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) { 796 FrameEvents* oldFrame = 797 (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame]; 798 FrameEvents* newFrame = &mFrames[iNewFrame]; 799 800 uint64_t nOldFrame = iOldFrame + 1; 801 uint64_t nNewFrame = iNewFrame + 1; 802 803 // Latch, Composite, and Release the frames in a plausible order. 804 // Note: The timestamps won't necessarily match the order, but 805 // that's okay for the purposes of this test. 806 std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE; 807 808 // Composite the previous frame one more time, which helps verify 809 // LastRefresh is updated properly. 810 if (oldFrame != nullptr) { 811 mCfeh->addPreComposition(nOldFrame, 812 oldFrame->mRefreshes[2].kStartTime); 813 gpuDoneFenceTime = gpuComposited ? 814 oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime : 815 FenceTime::NO_FENCE; 816 mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime, 817 oldFrame->mRefreshes[2].mPresent.mFenceTime, 818 oldFrame->mRefreshes[2].kCompositorTiming); 819 } 820 821 // Latch the new frame. 822 mCfeh->addLatch(nNewFrame, newFrame->kLatchTime); 823 824 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime); 825 gpuDoneFenceTime = gpuComposited ? 826 newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime : 827 FenceTime::NO_FENCE; 828 // HWC2 releases the previous buffer after a new latch just before 829 // calling postComposition. 830 if (oldFrame != nullptr) { 831 mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime, 832 std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime)); 833 } 834 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime, 835 newFrame->mRefreshes[0].mPresent.mFenceTime, 836 newFrame->mRefreshes[0].kCompositorTiming); 837 838 mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime); 839 gpuDoneFenceTime = gpuComposited ? 840 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime : 841 FenceTime::NO_FENCE; 842 mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime, 843 newFrame->mRefreshes[1].mPresent.mFenceTime, 844 newFrame->mRefreshes[1].kCompositorTiming); 845 } 846 847 sp<IGraphicBufferProducer> mProducer; 848 sp<IGraphicBufferConsumer> mConsumer; 849 sp<FakeConsumer> mFakeConsumer; 850 ConsumerFrameEventHistory* mCfeh; 851 sp<TestSurface> mSurface; 852 sp<ANativeWindow> mWindow; 853 854 FenceToFenceTimeMap mFenceMap; 855 856 bool mFrameTimestampsEnabled = false; 857 858 int64_t outRequestedPresentTime = -1; 859 int64_t outAcquireTime = -1; 860 int64_t outLatchTime = -1; 861 int64_t outFirstRefreshStartTime = -1; 862 int64_t outLastRefreshStartTime = -1; 863 int64_t outGpuCompositionDoneTime = -1; 864 int64_t outDisplayPresentTime = -1; 865 int64_t outDequeueReadyTime = -1; 866 int64_t outReleaseTime = -1; 867 868 FrameEvents mFrames[3] { 869 { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } }; 870}; 871 872 873// This test verifies that the frame timestamps are not retrieved when not 874// explicitly enabled via native_window_enable_frame_timestamps. 875// We want to check this to make sure there's no overhead for users 876// that don't need the timestamp information. 877TEST_F(GetFrameTimestampsTest, DefaultDisabled) { 878 int fence; 879 ANativeWindowBuffer* buffer; 880 881 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount); 882 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount); 883 884 const uint64_t fId = getNextFrameId(); 885 886 // Verify the producer doesn't get frame timestamps piggybacked on dequeue. 887 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence)); 888 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount); 889 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount); 890 891 // Verify the producer doesn't get frame timestamps piggybacked on queue. 892 // It is okay that frame timestamps are added in the consumer since it is 893 // still needed for SurfaceFlinger dumps. 894 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence)); 895 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount); 896 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount); 897 898 // Verify attempts to get frame timestamps fail. 899 int result = getAllFrameTimestamps(fId); 900 EXPECT_EQ(INVALID_OPERATION, result); 901 EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount); 902 903 // Verify compositor timing query fails. 904 nsecs_t compositeDeadline = 0; 905 nsecs_t compositeInterval = 0; 906 nsecs_t compositeToPresentLatency = 0; 907 result = native_window_get_compositor_timing(mWindow.get(), 908 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 909 EXPECT_EQ(INVALID_OPERATION, result); 910} 911 912// This test verifies that the frame timestamps are retrieved if explicitly 913// enabled via native_window_enable_frame_timestamps. 914TEST_F(GetFrameTimestampsTest, EnabledSimple) { 915 CompositorTiming initialCompositorTiming { 916 1000000000, // 1s deadline 917 16666667, // 16ms interval 918 50000000, // 50ms present latency 919 }; 920 mCfeh->initializeCompositorTiming(initialCompositorTiming); 921 922 enableFrameTimestamps(); 923 924 // Verify the compositor timing query gets the initial compositor values 925 // after timststamps are enabled; even before the first frame is queued 926 // or dequeued. 927 nsecs_t compositeDeadline = 0; 928 nsecs_t compositeInterval = 0; 929 nsecs_t compositeToPresentLatency = 0; 930 mSurface->setNow(initialCompositorTiming.deadline - 1); 931 int result = native_window_get_compositor_timing(mWindow.get(), 932 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 933 EXPECT_EQ(NO_ERROR, result); 934 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline); 935 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval); 936 EXPECT_EQ(initialCompositorTiming.presentLatency, 937 compositeToPresentLatency); 938 939 int fence; 940 ANativeWindowBuffer* buffer; 941 942 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount); 943 EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount); 944 945 const uint64_t fId1 = getNextFrameId(); 946 947 // Verify getFrameTimestamps is piggybacked on dequeue. 948 ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence)); 949 EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount); 950 EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount); 951 952 NewFrameEventsEntry f1; 953 f1.frameNumber = 1; 954 f1.postedTime = mFrames[0].kPostedTime; 955 f1.requestedPresentTime = mFrames[0].kRequestedPresentTime; 956 f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime; 957 mSurface->mFakeFrameEventHistory->setAcquireFenceOverride( 958 mFrames[0].mAcquireProducer.mFenceTime, 959 mFrames[0].mAcquireConsumer.mFenceTime); 960 mFakeConsumer->mNewFrameEntryOverride = f1; 961 mFrames[0].signalQueueFences(); 962 963 // Verify getFrameTimestamps is piggybacked on queue. 964 ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence)); 965 EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount); 966 EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber); 967 EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount); 968 969 // Verify queries for timestamps that the producer doesn't know about 970 // triggers a call to see if the consumer has any new timestamps. 971 result = getAllFrameTimestamps(fId1); 972 EXPECT_EQ(NO_ERROR, result); 973 EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount); 974} 975 976TEST_F(GetFrameTimestampsTest, QueryPresentSupported) { 977 bool displayPresentSupported = true; 978 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported); 979 980 // Verify supported bits are forwarded. 981 int supportsPresent = -1; 982 mWindow.get()->query(mWindow.get(), 983 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent); 984 EXPECT_EQ(displayPresentSupported, supportsPresent); 985} 986 987TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) { 988 bool displayPresentSupported = false; 989 mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported); 990 991 // Verify supported bits are forwarded. 992 int supportsPresent = -1; 993 mWindow.get()->query(mWindow.get(), 994 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent); 995 EXPECT_EQ(displayPresentSupported, supportsPresent); 996} 997 998TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) { 999 nsecs_t phase = 4000; 1000 nsecs_t interval = 1000; 1001 1002 // Timestamp in previous interval. 1003 nsecs_t timestamp = 3500; 1004 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick( 1005 timestamp, phase, interval)); 1006 1007 // Timestamp in next interval. 1008 timestamp = 4500; 1009 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick( 1010 timestamp, phase, interval)); 1011 1012 // Timestamp multiple intervals before. 1013 timestamp = 2500; 1014 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick( 1015 timestamp, phase, interval)); 1016 1017 // Timestamp multiple intervals after. 1018 timestamp = 6500; 1019 EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick( 1020 timestamp, phase, interval)); 1021 1022 // Timestamp on previous interval. 1023 timestamp = 3000; 1024 EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick( 1025 timestamp, phase, interval)); 1026 1027 // Timestamp on next interval. 1028 timestamp = 5000; 1029 EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick( 1030 timestamp, phase, interval)); 1031 1032 // Timestamp equal to phase. 1033 timestamp = 4000; 1034 EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick( 1035 timestamp, phase, interval)); 1036} 1037 1038// int(big_timestamp / interval) < 0, which can cause a crash or invalid result 1039// if the number of intervals elapsed is internally stored in an int. 1040TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) { 1041 nsecs_t phase = 0; 1042 nsecs_t interval = 4000; 1043 nsecs_t big_timestamp = 8635916564000; 1044 int32_t intervals = big_timestamp / interval; 1045 1046 EXPECT_LT(intervals, 0); 1047 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick( 1048 big_timestamp, phase, interval)); 1049 EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick( 1050 big_timestamp, big_timestamp, interval)); 1051} 1052 1053// This verifies the compositor timing is updated by refresh events 1054// and piggy backed on a queue, dequeue, and enabling of timestamps.. 1055TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) { 1056 CompositorTiming initialCompositorTiming { 1057 1000000000, // 1s deadline 1058 16666667, // 16ms interval 1059 50000000, // 50ms present latency 1060 }; 1061 mCfeh->initializeCompositorTiming(initialCompositorTiming); 1062 1063 enableFrameTimestamps(); 1064 1065 // We get the initial values before any frames are submitted. 1066 nsecs_t compositeDeadline = 0; 1067 nsecs_t compositeInterval = 0; 1068 nsecs_t compositeToPresentLatency = 0; 1069 mSurface->setNow(initialCompositorTiming.deadline - 1); 1070 int result = native_window_get_compositor_timing(mWindow.get(), 1071 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1072 EXPECT_EQ(NO_ERROR, result); 1073 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline); 1074 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval); 1075 EXPECT_EQ(initialCompositorTiming.presentLatency, 1076 compositeToPresentLatency); 1077 1078 const uint64_t fId1 = getNextFrameId(); 1079 dequeueAndQueue(0); 1080 addFrameEvents(true, NO_FRAME_INDEX, 0); 1081 1082 // Still get the initial values because the frame events for frame 0 1083 // didn't get a chance to piggyback on a queue or dequeue yet. 1084 result = native_window_get_compositor_timing(mWindow.get(), 1085 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1086 EXPECT_EQ(NO_ERROR, result); 1087 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline); 1088 EXPECT_EQ(initialCompositorTiming.interval, compositeInterval); 1089 EXPECT_EQ(initialCompositorTiming.presentLatency, 1090 compositeToPresentLatency); 1091 1092 const uint64_t fId2 = getNextFrameId(); 1093 dequeueAndQueue(1); 1094 addFrameEvents(true, 0, 1); 1095 1096 // Now expect the composite values associated with frame 1. 1097 mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline); 1098 result = native_window_get_compositor_timing(mWindow.get(), 1099 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1100 EXPECT_EQ(NO_ERROR, result); 1101 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline, 1102 compositeDeadline); 1103 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval, 1104 compositeInterval); 1105 EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency, 1106 compositeToPresentLatency); 1107 1108 dequeueAndQueue(2); 1109 addFrameEvents(true, 1, 2); 1110 1111 // Now expect the composite values associated with frame 2. 1112 mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline); 1113 result = native_window_get_compositor_timing(mWindow.get(), 1114 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1115 EXPECT_EQ(NO_ERROR, result); 1116 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline, 1117 compositeDeadline); 1118 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval, 1119 compositeInterval); 1120 EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency, 1121 compositeToPresentLatency); 1122 1123 // Re-enabling frame timestamps should get the latest values. 1124 disableFrameTimestamps(); 1125 enableFrameTimestamps(); 1126 1127 // Now expect the composite values associated with frame 3. 1128 mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline); 1129 result = native_window_get_compositor_timing(mWindow.get(), 1130 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1131 EXPECT_EQ(NO_ERROR, result); 1132 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline, 1133 compositeDeadline); 1134 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval, 1135 compositeInterval); 1136 EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency, 1137 compositeToPresentLatency); 1138} 1139 1140// This verifies the compositor deadline properly snaps to the the next 1141// deadline based on the current time. 1142TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) { 1143 CompositorTiming initialCompositorTiming { 1144 1000000000, // 1s deadline 1145 16666667, // 16ms interval 1146 50000000, // 50ms present latency 1147 }; 1148 mCfeh->initializeCompositorTiming(initialCompositorTiming); 1149 1150 enableFrameTimestamps(); 1151 1152 nsecs_t compositeDeadline = 0; 1153 nsecs_t compositeInterval = 0; 1154 nsecs_t compositeToPresentLatency = 0; 1155 1156 // A "now" just before the deadline snaps to the deadline. 1157 mSurface->setNow(initialCompositorTiming.deadline - 1); 1158 int result = native_window_get_compositor_timing(mWindow.get(), 1159 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1160 EXPECT_EQ(NO_ERROR, result); 1161 EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline); 1162 nsecs_t expectedDeadline = initialCompositorTiming.deadline; 1163 EXPECT_EQ(expectedDeadline, compositeDeadline); 1164 1165 const uint64_t fId1 = getNextFrameId(); 1166 dequeueAndQueue(0); 1167 addFrameEvents(true, NO_FRAME_INDEX, 0); 1168 1169 // A "now" just after the deadline snaps properly. 1170 mSurface->setNow(initialCompositorTiming.deadline + 1); 1171 result = native_window_get_compositor_timing(mWindow.get(), 1172 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1173 EXPECT_EQ(NO_ERROR, result); 1174 expectedDeadline = 1175 initialCompositorTiming.deadline +initialCompositorTiming.interval; 1176 EXPECT_EQ(expectedDeadline, compositeDeadline); 1177 1178 const uint64_t fId2 = getNextFrameId(); 1179 dequeueAndQueue(1); 1180 addFrameEvents(true, 0, 1); 1181 1182 // A "now" just after the next interval snaps properly. 1183 mSurface->setNow( 1184 mFrames[0].mRefreshes[1].kCompositorTiming.deadline + 1185 mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1); 1186 result = native_window_get_compositor_timing(mWindow.get(), 1187 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1188 EXPECT_EQ(NO_ERROR, result); 1189 expectedDeadline = 1190 mFrames[0].mRefreshes[1].kCompositorTiming.deadline + 1191 mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2; 1192 EXPECT_EQ(expectedDeadline, compositeDeadline); 1193 1194 dequeueAndQueue(2); 1195 addFrameEvents(true, 1, 2); 1196 1197 // A "now" over 1 interval before the deadline snaps properly. 1198 mSurface->setNow( 1199 mFrames[1].mRefreshes[1].kCompositorTiming.deadline - 1200 mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1); 1201 result = native_window_get_compositor_timing(mWindow.get(), 1202 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1203 EXPECT_EQ(NO_ERROR, result); 1204 expectedDeadline = 1205 mFrames[1].mRefreshes[1].kCompositorTiming.deadline - 1206 mFrames[1].mRefreshes[1].kCompositorTiming.interval; 1207 EXPECT_EQ(expectedDeadline, compositeDeadline); 1208 1209 // Re-enabling frame timestamps should get the latest values. 1210 disableFrameTimestamps(); 1211 enableFrameTimestamps(); 1212 1213 // A "now" over 2 intervals before the deadline snaps properly. 1214 mSurface->setNow( 1215 mFrames[2].mRefreshes[1].kCompositorTiming.deadline - 1216 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1); 1217 result = native_window_get_compositor_timing(mWindow.get(), 1218 &compositeDeadline, &compositeInterval, &compositeToPresentLatency); 1219 EXPECT_EQ(NO_ERROR, result); 1220 expectedDeadline = 1221 mFrames[2].mRefreshes[1].kCompositorTiming.deadline - 1222 mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2; 1223 EXPECT_EQ(expectedDeadline, compositeDeadline); 1224} 1225 1226// This verifies the timestamps recorded in the consumer's 1227// FrameTimestampsHistory are properly retrieved by the producer for the 1228// correct frames. 1229TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) { 1230 enableFrameTimestamps(); 1231 1232 const uint64_t fId1 = getNextFrameId(); 1233 dequeueAndQueue(0); 1234 mFrames[0].signalQueueFences(); 1235 1236 const uint64_t fId2 = getNextFrameId(); 1237 dequeueAndQueue(1); 1238 mFrames[1].signalQueueFences(); 1239 1240 addFrameEvents(true, NO_FRAME_INDEX, 0); 1241 mFrames[0].signalRefreshFences(); 1242 addFrameEvents(true, 0, 1); 1243 mFrames[0].signalReleaseFences(); 1244 mFrames[1].signalRefreshFences(); 1245 1246 // Verify timestamps are correct for frame 1. 1247 resetTimestamps(); 1248 int result = getAllFrameTimestamps(fId1); 1249 EXPECT_EQ(NO_ERROR, result); 1250 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1251 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1252 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1253 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1254 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1255 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime, 1256 outGpuCompositionDoneTime); 1257 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime); 1258 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1259 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime); 1260 1261 // Verify timestamps are correct for frame 2. 1262 resetTimestamps(); 1263 result = getAllFrameTimestamps(fId2); 1264 EXPECT_EQ(NO_ERROR, result); 1265 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime); 1266 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime); 1267 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime); 1268 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1269 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime); 1270 EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime, 1271 outGpuCompositionDoneTime); 1272 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime); 1273 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime); 1274 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1275} 1276 1277// This test verifies the acquire fence recorded by the consumer is not sent 1278// back to the producer and the producer saves its own fence. 1279TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) { 1280 enableFrameTimestamps(); 1281 1282 // Dequeue and queue frame 1. 1283 const uint64_t fId1 = getNextFrameId(); 1284 dequeueAndQueue(0); 1285 1286 // Verify queue-related timestamps for f1 are available immediately in the 1287 // producer without asking the consumer again, even before signaling the 1288 // acquire fence. 1289 resetTimestamps(); 1290 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1291 int result = native_window_get_frame_timestamps(mWindow.get(), fId1, 1292 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr, 1293 nullptr, nullptr, nullptr, nullptr, nullptr); 1294 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1295 EXPECT_EQ(NO_ERROR, result); 1296 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1297 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime); 1298 1299 // Signal acquire fences. Verify a sync call still isn't necessary. 1300 mFrames[0].signalQueueFences(); 1301 1302 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1303 result = native_window_get_frame_timestamps(mWindow.get(), fId1, 1304 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr, 1305 nullptr, nullptr, nullptr, nullptr, nullptr); 1306 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1307 EXPECT_EQ(NO_ERROR, result); 1308 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1309 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1310 1311 // Dequeue and queue frame 2. 1312 const uint64_t fId2 = getNextFrameId(); 1313 dequeueAndQueue(1); 1314 1315 // Verify queue-related timestamps for f2 are available immediately in the 1316 // producer without asking the consumer again, even before signaling the 1317 // acquire fence. 1318 resetTimestamps(); 1319 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1320 result = native_window_get_frame_timestamps(mWindow.get(), fId2, 1321 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr, 1322 nullptr, nullptr, nullptr, nullptr, nullptr); 1323 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1324 EXPECT_EQ(NO_ERROR, result); 1325 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime); 1326 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime); 1327 1328 // Signal acquire fences. Verify a sync call still isn't necessary. 1329 mFrames[1].signalQueueFences(); 1330 1331 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1332 result = native_window_get_frame_timestamps(mWindow.get(), fId2, 1333 &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr, 1334 nullptr, nullptr, nullptr, nullptr, nullptr); 1335 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1336 EXPECT_EQ(NO_ERROR, result); 1337 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime); 1338 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime); 1339} 1340 1341TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) { 1342 enableFrameTimestamps(); 1343 1344 // Dequeue and queue frame 1. 1345 dequeueAndQueue(0); 1346 mFrames[0].signalQueueFences(); 1347 1348 // Dequeue and queue frame 2. 1349 const uint64_t fId2 = getNextFrameId(); 1350 dequeueAndQueue(1); 1351 mFrames[1].signalQueueFences(); 1352 1353 addFrameEvents(true, NO_FRAME_INDEX, 0); 1354 mFrames[0].signalRefreshFences(); 1355 addFrameEvents(true, 0, 1); 1356 mFrames[0].signalReleaseFences(); 1357 mFrames[1].signalRefreshFences(); 1358 1359 // Verify a request for no timestamps doesn't result in a sync call. 1360 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1361 int result = native_window_get_frame_timestamps(mWindow.get(), fId2, 1362 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 1363 nullptr, nullptr); 1364 EXPECT_EQ(NO_ERROR, result); 1365 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1366} 1367 1368// This test verifies that fences can signal and update timestamps producer 1369// side without an additional sync call to the consumer. 1370TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) { 1371 enableFrameTimestamps(); 1372 1373 // Dequeue and queue frame 1. 1374 const uint64_t fId1 = getNextFrameId(); 1375 dequeueAndQueue(0); 1376 mFrames[0].signalQueueFences(); 1377 1378 // Dequeue and queue frame 2. 1379 dequeueAndQueue(1); 1380 mFrames[1].signalQueueFences(); 1381 1382 addFrameEvents(true, NO_FRAME_INDEX, 0); 1383 addFrameEvents(true, 0, 1); 1384 1385 // Verify available timestamps are correct for frame 1, before any 1386 // fence has been signaled. 1387 // Note: A sync call is necessary here since the events triggered by 1388 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues. 1389 resetTimestamps(); 1390 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1391 int result = getAllFrameTimestamps(fId1); 1392 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount); 1393 EXPECT_EQ(NO_ERROR, result); 1394 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1395 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1396 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1397 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1398 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1399 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime); 1400 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime); 1401 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1402 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1403 1404 // Verify available timestamps are correct for frame 1 again, before any 1405 // fence has been signaled. 1406 // This time a sync call should not be necessary. 1407 resetTimestamps(); 1408 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1409 result = getAllFrameTimestamps(fId1); 1410 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1411 EXPECT_EQ(NO_ERROR, result); 1412 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1413 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1414 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1415 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1416 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1417 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime); 1418 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime); 1419 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1420 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1421 1422 // Signal the fences for frame 1. 1423 mFrames[0].signalRefreshFences(); 1424 mFrames[0].signalReleaseFences(); 1425 1426 // Verify all timestamps are available without a sync call. 1427 resetTimestamps(); 1428 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1429 result = getAllFrameTimestamps(fId1); 1430 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1431 EXPECT_EQ(NO_ERROR, result); 1432 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1433 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1434 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1435 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1436 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1437 EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime, 1438 outGpuCompositionDoneTime); 1439 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime); 1440 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1441 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime); 1442} 1443 1444// This test verifies that if the frame wasn't GPU composited but has a refresh 1445// event a sync call isn't made to get the GPU composite done time since it will 1446// never exist. 1447TEST_F(GetFrameTimestampsTest, NoGpuNoSync) { 1448 enableFrameTimestamps(); 1449 1450 // Dequeue and queue frame 1. 1451 const uint64_t fId1 = getNextFrameId(); 1452 dequeueAndQueue(0); 1453 mFrames[0].signalQueueFences(); 1454 1455 // Dequeue and queue frame 2. 1456 dequeueAndQueue(1); 1457 mFrames[1].signalQueueFences(); 1458 1459 addFrameEvents(false, NO_FRAME_INDEX, 0); 1460 addFrameEvents(false, 0, 1); 1461 1462 // Verify available timestamps are correct for frame 1, before any 1463 // fence has been signaled. 1464 // Note: A sync call is necessary here since the events triggered by 1465 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues. 1466 resetTimestamps(); 1467 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1468 int result = getAllFrameTimestamps(fId1); 1469 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount); 1470 EXPECT_EQ(NO_ERROR, result); 1471 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1472 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1473 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1474 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1475 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1476 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime); 1477 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime); 1478 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1479 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1480 1481 // Signal the fences for frame 1. 1482 mFrames[0].signalRefreshFences(); 1483 mFrames[0].signalReleaseFences(); 1484 1485 // Verify all timestamps, except GPU composition, are available without a 1486 // sync call. 1487 resetTimestamps(); 1488 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1489 result = getAllFrameTimestamps(fId1); 1490 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1491 EXPECT_EQ(NO_ERROR, result); 1492 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1493 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1494 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1495 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1496 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1497 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime); 1498 EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime); 1499 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1500 EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime); 1501} 1502 1503// This test verifies that if the certain timestamps can't possibly exist for 1504// the most recent frame, then a sync call is not done. 1505TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) { 1506 enableFrameTimestamps(); 1507 1508 // Dequeue and queue frame 1. 1509 const uint64_t fId1 = getNextFrameId(); 1510 dequeueAndQueue(0); 1511 mFrames[0].signalQueueFences(); 1512 1513 // Dequeue and queue frame 2. 1514 const uint64_t fId2 = getNextFrameId(); 1515 dequeueAndQueue(1); 1516 mFrames[1].signalQueueFences(); 1517 1518 addFrameEvents(false, NO_FRAME_INDEX, 0); 1519 addFrameEvents(false, 0, 1); 1520 1521 // Verify available timestamps are correct for frame 1, before any 1522 // fence has been signaled. 1523 // Note: A sync call is necessary here since the events triggered by 1524 // addFrameEvents didn't get to piggyback on the earlier queues/dequeues. 1525 resetTimestamps(); 1526 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1527 int result = getAllFrameTimestamps(fId1); 1528 EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount); 1529 EXPECT_EQ(NO_ERROR, result); 1530 EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime); 1531 EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime); 1532 EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime); 1533 EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1534 EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime); 1535 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime); 1536 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime); 1537 EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime); 1538 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1539 1540 mFrames[0].signalRefreshFences(); 1541 mFrames[0].signalReleaseFences(); 1542 mFrames[1].signalRefreshFences(); 1543 1544 // Verify querying for all timestmaps of f2 does not do a sync call. Even 1545 // though the lastRefresh, dequeueReady, and release times aren't 1546 // available, a sync call should not occur because it's not possible for f2 1547 // to encounter the final value for those events until another frame is 1548 // queued. 1549 resetTimestamps(); 1550 oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1551 result = getAllFrameTimestamps(fId2); 1552 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1553 EXPECT_EQ(NO_ERROR, result); 1554 EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime); 1555 EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime); 1556 EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime); 1557 EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime); 1558 EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime); 1559 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime); 1560 EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime); 1561 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime); 1562 EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime); 1563} 1564 1565// This test verifies there are no sync calls for present times 1566// when they aren't supported and that an error is returned. 1567 1568TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) { 1569 enableFrameTimestamps(); 1570 mSurface->mFakeSurfaceComposer->setSupportsPresent(false); 1571 1572 // Dequeue and queue frame 1. 1573 const uint64_t fId1 = getNextFrameId(); 1574 dequeueAndQueue(0); 1575 1576 // Verify a query for the Present times do not trigger a sync call if they 1577 // are not supported. 1578 resetTimestamps(); 1579 int oldCount = mFakeConsumer->mGetFrameTimestampsCount; 1580 int result = native_window_get_frame_timestamps(mWindow.get(), fId1, 1581 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 1582 &outDisplayPresentTime, nullptr, nullptr); 1583 EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount); 1584 EXPECT_EQ(BAD_VALUE, result); 1585 EXPECT_EQ(-1, outDisplayPresentTime); 1586} 1587 1588} // namespace android 1589