Merge "Fix sensor permission"
diff --git a/include/android/native_window.h b/include/android/native_window.h
index b60b9f1..b017a25 100644
--- a/include/android/native_window.h
+++ b/include/android/native_window.h
@@ -38,12 +38,18 @@
* Pixel formats that a window can use.
*/
enum {
+ // NOTE: these values must match the values from graphics/common/x.x/types.hal
+
/** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Alpha: 8 bits. **/
WINDOW_FORMAT_RGBA_8888 = 1,
/** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Unused: 8 bits. **/
WINDOW_FORMAT_RGBX_8888 = 2,
/** Red: 5 bits, Green: 6 bits, Blue: 5 bits. **/
WINDOW_FORMAT_RGB_565 = 4,
+ /** Red: 16 bits, Green: 16 bits, Blue: 16 bits, Alpha: 16 bits. **/
+ WINDOW_FORMAT_RGBA_FP16 = 0x16,
+ /** Red: 16 bits, Green: 16 bits, Blue: 16 bits, Unused: 16 bits. **/
+ WINDOW_FORMAT_RGBX_FP16 = 0x17,
};
struct ANativeWindow;
diff --git a/include/gui/BufferItem.h b/include/gui/BufferItem.h
index 5232d0f..ab676cc 100644
--- a/include/gui/BufferItem.h
+++ b/include/gui/BufferItem.h
@@ -20,6 +20,7 @@
#include <EGL/egl.h>
#include <EGL/eglext.h>
+#include <ui/FenceTime.h>
#include <ui/Rect.h>
#include <ui/Region.h>
@@ -59,6 +60,9 @@
// mFence is a fence that will signal when the buffer is idle.
sp<Fence> mFence;
+ // The std::shared_ptr<FenceTime> wrapper around mFence.
+ std::shared_ptr<FenceTime> mFenceTime{FenceTime::NO_FENCE};
+
// mCrop is the current crop rectangle for this buffer slot.
Rect mCrop;
diff --git a/include/gui/FrameTimestamps.h b/include/gui/FrameTimestamps.h
index 0e95ec3..a1d4e07 100644
--- a/include/gui/FrameTimestamps.h
+++ b/include/gui/FrameTimestamps.h
@@ -17,7 +17,7 @@
#ifndef ANDROID_GUI_FRAMETIMESTAMPS_H
#define ANDROID_GUI_FRAMETIMESTAMPS_H
-#include <ui/Fence.h>
+#include <ui/FenceTime.h>
#include <utils/Flattenable.h>
#include <utils/StrongPointer.h>
#include <utils/Timers.h>
@@ -28,12 +28,12 @@
namespace android {
-
struct FrameEvents;
class FrameEventHistoryDelta;
class String8;
+// Identifiers for all the events that may be recorded or reported.
enum class FrameEvent {
POSTED,
REQUESTED_PRESENT,
@@ -79,23 +79,17 @@
bool addRetireCalled{false};
bool addReleaseCalled{false};
- nsecs_t postedTime{0};
- nsecs_t requestedPresentTime{0};
- nsecs_t latchTime{0};
- nsecs_t firstRefreshStartTime{0};
- nsecs_t lastRefreshStartTime{0};
+ nsecs_t postedTime{-1};
+ nsecs_t requestedPresentTime{-1};
+ nsecs_t latchTime{-1};
+ nsecs_t firstRefreshStartTime{-1};
+ nsecs_t lastRefreshStartTime{-1};
- nsecs_t acquireTime{0};
- nsecs_t gpuCompositionDoneTime{0};
- nsecs_t displayPresentTime{0};
- nsecs_t displayRetireTime{0};
- nsecs_t releaseTime{0};
-
- sp<Fence> acquireFence{Fence::NO_FENCE};
- sp<Fence> gpuCompositionDoneFence{Fence::NO_FENCE};
- sp<Fence> displayPresentFence{Fence::NO_FENCE};
- sp<Fence> displayRetireFence{Fence::NO_FENCE};
- sp<Fence> releaseFence{Fence::NO_FENCE};
+ std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
+ std::shared_ptr<FenceTime> gpuCompositionDoneFence{FenceTime::NO_FENCE};
+ std::shared_ptr<FenceTime> displayPresentFence{FenceTime::NO_FENCE};
+ std::shared_ptr<FenceTime> displayRetireFence{FenceTime::NO_FENCE};
+ std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
};
@@ -122,11 +116,23 @@
public:
~ProducerFrameEventHistory() override;
- void updateAcquireFence(uint64_t frameNumber, sp<Fence> acquire);
+ void updateAcquireFence(
+ uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
void applyDelta(const FrameEventHistoryDelta& delta);
+ void updateSignalTimes();
+
private:
size_t mAcquireOffset{0};
+
+ // The consumer updates it's timelines in Layer and SurfaceFlinger since
+ // they can coordinate shared timelines better. The producer doesn't have
+ // shared timelines though, so just let it own and update all of them.
+ FenceTimeline mAcquireTimeline;
+ FenceTimeline mGpuCompositionDoneTimeline;
+ FenceTimeline mPresentTimeline;
+ FenceTimeline mRetireTimeline;
+ FenceTimeline mReleaseTimeline;
};
@@ -136,7 +142,7 @@
uint64_t frameNumber{0};
nsecs_t postedTime{0};
nsecs_t requestedPresentTime{0};
- sp<Fence> acquireFence{Fence::NO_FENCE};
+ std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
};
@@ -175,13 +181,19 @@
void addLatch(uint64_t frameNumber, nsecs_t latchTime);
void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
void addPostComposition(uint64_t frameNumber,
- sp<Fence> gpuCompositionDone, sp<Fence> displayPresent);
- void addRetire(uint64_t frameNumber, sp<Fence> displayRetire);
- void addRelease(uint64_t frameNumber, sp<Fence> release);
+ const std::shared_ptr<FenceTime>& gpuCompositionDone,
+ const std::shared_ptr<FenceTime>& displayPresent);
+ void addRetire(uint64_t frameNumber,
+ const std::shared_ptr<FenceTime>& displayRetire);
+ void addRelease(uint64_t frameNumber,
+ std::shared_ptr<FenceTime>&& release);
void getAndResetDelta(FrameEventHistoryDelta* delta);
private:
+ void getFrameDelta(FrameEventHistoryDelta* delta,
+ const std::array<FrameEvents, MAX_FRAME_HISTORY>::iterator& frame);
+
std::array<FrameEventDirtyFields, MAX_FRAME_HISTORY> mFramesDirty;
size_t mQueueOffset{0};
size_t mCompositionOffset{0};
@@ -202,6 +214,13 @@
const FrameEvents& frameTimestamps,
const FrameEventDirtyFields& dirtyFields);
+ // Movable.
+ FrameEventsDelta(FrameEventsDelta&& src) = default;
+ FrameEventsDelta& operator=(FrameEventsDelta&& src) = default;
+ // Not copyable.
+ FrameEventsDelta(const FrameEventsDelta& src) = delete;
+ FrameEventsDelta& operator=(const FrameEventsDelta& src) = delete;
+
// Flattenable implementation
size_t getFlattenedSize() const;
size_t getFdCount() const;
@@ -226,10 +245,10 @@
nsecs_t mFirstRefreshStartTime{0};
nsecs_t mLastRefreshStartTime{0};
- sp<Fence> mGpuCompositionDoneFence{Fence::NO_FENCE};
- sp<Fence> mDisplayPresentFence{Fence::NO_FENCE};
- sp<Fence> mDisplayRetireFence{Fence::NO_FENCE};
- sp<Fence> mReleaseFence{Fence::NO_FENCE};
+ FenceTime::Snapshot mGpuCompositionDoneFence;
+ FenceTime::Snapshot mDisplayPresentFence;
+ FenceTime::Snapshot mDisplayRetireFence;
+ FenceTime::Snapshot mReleaseFence;
// This is a static method with an auto return value so we can call
// it without needing const and non-const versions.
@@ -253,6 +272,16 @@
friend class ProducerFrameEventHistory;
public:
+ FrameEventHistoryDelta() = default;
+
+ // Movable.
+ FrameEventHistoryDelta(FrameEventHistoryDelta&& src) = default;
+ FrameEventHistoryDelta& operator=(FrameEventHistoryDelta&& src);
+ // Not copyable.
+ FrameEventHistoryDelta(const FrameEventHistoryDelta& src) = delete;
+ FrameEventHistoryDelta& operator=(
+ const FrameEventHistoryDelta& src) = delete;
+
// Flattenable implementation.
size_t getFlattenedSize() const;
size_t getFdCount() const;
diff --git a/include/gui/GLConsumer.h b/include/gui/GLConsumer.h
index 6ff1303..493ecde 100644
--- a/include/gui/GLConsumer.h
+++ b/include/gui/GLConsumer.h
@@ -187,6 +187,10 @@
// ready to be read from.
sp<Fence> getCurrentFence() const;
+ // getCurrentFence returns the FenceTime indicating when the current
+ // buffer is ready to be read from.
+ std::shared_ptr<FenceTime> getCurrentFenceTime() const;
+
// doGLFenceWait inserts a wait command into the OpenGL ES command stream
// to ensure that it is safe for future OpenGL ES commands to access the
// current texture buffer.
@@ -398,6 +402,9 @@
// mCurrentFence is the fence received from BufferQueue in updateTexImage.
sp<Fence> mCurrentFence;
+ // The FenceTime wrapper around mCurrentFence.
+ std::shared_ptr<FenceTime> mCurrentFenceTime{FenceTime::NO_FENCE};
+
// mCurrentTransformMatrix is the transform matrix for the current texture.
// It gets computed by computeTransformMatrix each time updateTexImage is
// called.
diff --git a/include/gui/IGraphicBufferProducer.h b/include/gui/IGraphicBufferProducer.h
index 492db35..304a0c0 100644
--- a/include/gui/IGraphicBufferProducer.h
+++ b/include/gui/IGraphicBufferProducer.h
@@ -363,6 +363,15 @@
};
struct QueueBufferOutput : public Flattenable<QueueBufferOutput> {
+ QueueBufferOutput() = default;
+
+ // Moveable.
+ QueueBufferOutput(QueueBufferOutput&& src) = default;
+ QueueBufferOutput& operator=(QueueBufferOutput&& src) = default;
+ // Not copyable.
+ QueueBufferOutput(const QueueBufferOutput& src) = delete;
+ QueueBufferOutput& operator=(const QueueBufferOutput& src) = delete;
+
// Flattenable protocol
static constexpr size_t minFlattenedSize();
size_t getFlattenedSize() const;
diff --git a/include/media/hardware/HDCPAPI.h b/include/media/hardware/HDCPAPI.h
index 3a53e9f..30cd5fd 100644
--- a/include/media/hardware/HDCPAPI.h
+++ b/include/media/hardware/HDCPAPI.h
@@ -73,7 +73,7 @@
// Module can call the notification function to signal completion/failure
// of asynchronous operations (such as initialization) or out of band
// events.
- HDCPModule(void *cookie, ObserverFunc observerNotify) {};
+ HDCPModule(void * /*cookie*/, ObserverFunc /*observerNotify*/) {};
virtual ~HDCPModule() {};
@@ -104,8 +104,8 @@
// 1 for the second and so on)
// inputCTR _will_be_maintained_by_the_callee_ for each PES stream.
virtual status_t encrypt(
- const void *inData, size_t size, uint32_t streamCTR,
- uint64_t *outInputCTR, void *outData) {
+ const void * /*inData*/, size_t /*size*/, uint32_t /*streamCTR*/,
+ uint64_t * /*outInputCTR*/, void * /*outData*/) {
return INVALID_OPERATION;
}
@@ -119,8 +119,8 @@
// 1 for the second and so on)
// inputCTR _will_be_maintained_by_the_callee_ for each PES stream.
virtual status_t encryptNative(
- buffer_handle_t buffer, size_t offset, size_t size,
- uint32_t streamCTR, uint64_t *outInputCTR, void *outData) {
+ buffer_handle_t /*buffer*/, size_t /*offset*/, size_t /*size*/,
+ uint32_t /*streamCTR*/, uint64_t * /*outInputCTR*/, void * /*outData*/) {
return INVALID_OPERATION;
}
// DECRYPTION only:
@@ -133,9 +133,9 @@
// until outData contains size bytes of decrypted data.
// Both streamCTR and inputCTR will be provided by the caller.
virtual status_t decrypt(
- const void *inData, size_t size,
- uint32_t streamCTR, uint64_t inputCTR,
- void *outData) {
+ const void * /*inData*/, size_t /*size*/,
+ uint32_t /*streamCTR*/, uint64_t /*inputCTR*/,
+ void * /*outData*/) {
return INVALID_OPERATION;
}
diff --git a/include/ui/PixelFormat.h b/include/ui/PixelFormat.h
index f26fecb..99c6663 100644
--- a/include/ui/PixelFormat.h
+++ b/include/ui/PixelFormat.h
@@ -60,6 +60,8 @@
PIXEL_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, // 4x8-bit BGRA
PIXEL_FORMAT_RGBA_5551 = 6, // 16-bit ARGB
PIXEL_FORMAT_RGBA_4444 = 7, // 16-bit ARGB
+ PIXEL_FORMAT_RGBA_FP16 = HAL_PIXEL_FORMAT_RGBA_FP16, // 64-bit RGBA
+ PIXEL_FORMAT_RGBX_FP16 = HAL_PIXEL_FORMAT_RGBX_FP16, // 64-bit RGB0
};
typedef int32_t PixelFormat;
diff --git a/libs/gui/BufferItem.cpp b/libs/gui/BufferItem.cpp
index 669124e..ec2a9a6 100644
--- a/libs/gui/BufferItem.cpp
+++ b/libs/gui/BufferItem.cpp
@@ -204,6 +204,8 @@
status_t err = mFence->unflatten(buffer, size, fds, count);
if (err) return err;
size -= FlattenableUtils::align<4>(buffer);
+
+ mFenceTime = std::make_shared<FenceTime>(mFence);
}
status_t err = mSurfaceDamage.unflatten(buffer, size);
diff --git a/libs/gui/BufferQueueConsumer.cpp b/libs/gui/BufferQueueConsumer.cpp
index ee4c58c..d66aa1a 100644
--- a/libs/gui/BufferQueueConsumer.cpp
+++ b/libs/gui/BufferQueueConsumer.cpp
@@ -205,6 +205,7 @@
// was cached when it was last queued.
outBuffer->mGraphicBuffer = mSlots[slot].mGraphicBuffer;
outBuffer->mFence = Fence::NO_FENCE;
+ outBuffer->mFenceTime = FenceTime::NO_FENCE;
outBuffer->mCrop = mCore->mSharedBufferCache.crop;
outBuffer->mTransform = mCore->mSharedBufferCache.transform &
~static_cast<uint32_t>(
diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp
index 75198d7..39b9a0b 100644
--- a/libs/gui/BufferQueueProducer.cpp
+++ b/libs/gui/BufferQueueProducer.cpp
@@ -762,6 +762,8 @@
return BAD_VALUE;
}
+ auto acquireFenceTime = std::make_shared<FenceTime>(acquireFence);
+
switch (scalingMode) {
case NATIVE_WINDOW_SCALING_MODE_FREEZE:
case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
@@ -858,6 +860,7 @@
item.mFrameNumber = currentFrameNumber;
item.mSlot = slot;
item.mFence = acquireFence;
+ item.mFenceTime = acquireFenceTime;
item.mIsDroppable = mCore->mAsyncMode ||
mCore->mDequeueBufferCannotBlock ||
(mCore->mSharedBufferMode && mCore->mSharedBufferSlot == slot);
@@ -969,7 +972,7 @@
// small trade-off in favor of latency rather than throughput.
mLastQueueBufferFence->waitForever("Throttling EGL Production");
}
- mLastQueueBufferFence = acquireFence;
+ mLastQueueBufferFence = std::move(acquireFence);
mLastQueuedCrop = item.mCrop;
mLastQueuedTransform = item.mTransform;
@@ -979,7 +982,7 @@
currentFrameNumber,
postedTime,
requestedPresentTimestamp,
- acquireFence
+ std::move(acquireFenceTime)
};
addAndGetFrameTimestamps(&newFrameEventsEntry,
getFrameTimestamps ? &output->frameTimestamps : nullptr);
diff --git a/libs/gui/CpuConsumer.cpp b/libs/gui/CpuConsumer.cpp
index 8393160..4acf618 100644
--- a/libs/gui/CpuConsumer.cpp
+++ b/libs/gui/CpuConsumer.cpp
@@ -64,6 +64,8 @@
switch (static_cast<int>(format)) {
case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_RGBX_8888:
+ case HAL_PIXEL_FORMAT_RGBA_FP16:
+ case HAL_PIXEL_FORMAT_RGBX_FP16:
case HAL_PIXEL_FORMAT_RGB_888:
case HAL_PIXEL_FORMAT_RGB_565:
case HAL_PIXEL_FORMAT_BGRA_8888:
diff --git a/libs/gui/FrameTimestamps.cpp b/libs/gui/FrameTimestamps.cpp
index 30ff65f..6503e9c 100644
--- a/libs/gui/FrameTimestamps.cpp
+++ b/libs/gui/FrameTimestamps.cpp
@@ -16,6 +16,7 @@
#include <gui/FrameTimestamps.h>
+#include <cutils/compiler.h> // For CC_[UN]LIKELY
#include <inttypes.h>
#include <utils/String8.h>
@@ -25,28 +26,25 @@
namespace android {
-static inline bool isValidTimestamp(nsecs_t time) {
- return time > 0 && time < INT64_MAX;
-}
// ============================================================================
// FrameEvents
// ============================================================================
bool FrameEvents::hasPostedInfo() const {
- return isValidTimestamp(postedTime);
+ return Fence::isValidTimestamp(postedTime);
}
bool FrameEvents::hasRequestedPresentInfo() const {
- return isValidTimestamp(requestedPresentTime);
+ return Fence::isValidTimestamp(requestedPresentTime);
}
bool FrameEvents::hasLatchInfo() const {
- return isValidTimestamp(latchTime);
+ return Fence::isValidTimestamp(latchTime);
}
bool FrameEvents::hasFirstRefreshStartInfo() const {
- return isValidTimestamp(firstRefreshStartTime);
+ return Fence::isValidTimestamp(firstRefreshStartTime);
}
bool FrameEvents::hasLastRefreshStartInfo() const {
@@ -57,7 +55,7 @@
}
bool FrameEvents::hasAcquireInfo() const {
- return isValidTimestamp(acquireTime) || acquireFence->isValid();
+ return acquireFence->isValid();
}
bool FrameEvents::hasGpuCompositionDoneInfo() const {
@@ -80,22 +78,27 @@
return addReleaseCalled;
}
-static void checkFenceForCompletion(sp<Fence>* fence, nsecs_t* dstTime) {
- if ((*fence)->isValid()) {
- nsecs_t time = (*fence)->getSignalTime();
- if (isValidTimestamp(time)) {
- *dstTime = time;
- *fence = Fence::NO_FENCE;
- }
- }
+void FrameEvents::checkFencesForCompletion() {
+ acquireFence->getSignalTime();
+ gpuCompositionDoneFence->getSignalTime();
+ displayPresentFence->getSignalTime();
+ displayRetireFence->getSignalTime();
+ releaseFence->getSignalTime();
}
-void FrameEvents::checkFencesForCompletion() {
- checkFenceForCompletion(&acquireFence, &acquireTime);
- checkFenceForCompletion(&gpuCompositionDoneFence, &gpuCompositionDoneTime);
- checkFenceForCompletion(&displayPresentFence, &displayPresentTime);
- checkFenceForCompletion(&displayRetireFence, &displayRetireTime);
- checkFenceForCompletion(&releaseFence, &releaseTime);
+static void dumpFenceTime(String8& outString, const char* name,
+ bool pending, const FenceTime& fenceTime) {
+ outString.appendFormat("--- %s", name);
+ nsecs_t signalTime = fenceTime.getCachedSignalTime();
+ if (Fence::isValidTimestamp(signalTime)) {
+ outString.appendFormat("%" PRId64 "\n", signalTime);
+ } else if (pending || signalTime == Fence::SIGNAL_TIME_PENDING) {
+ outString.appendFormat("Pending\n");
+ } else if (&fenceTime == FenceTime::NO_FENCE.get()){
+ outString.appendFormat("N/A\n");
+ } else {
+ outString.appendFormat("Error\n");
+ }
}
void FrameEvents::dump(String8& outString) const
@@ -109,66 +112,36 @@
outString.appendFormat("--- Req. Present\t%" PRId64 "\n", requestedPresentTime);
outString.appendFormat("--- Latched \t");
- if (isValidTimestamp(latchTime)) {
+ if (Fence::isValidTimestamp(latchTime)) {
outString.appendFormat("%" PRId64 "\n", latchTime);
} else {
outString.appendFormat("Pending\n");
}
outString.appendFormat("--- Refresh (First)\t");
- if (isValidTimestamp(firstRefreshStartTime)) {
+ if (Fence::isValidTimestamp(firstRefreshStartTime)) {
outString.appendFormat("%" PRId64 "\n", firstRefreshStartTime);
} else {
outString.appendFormat("Pending\n");
}
outString.appendFormat("--- Refresh (Last)\t");
- if (isValidTimestamp(lastRefreshStartTime)) {
+ if (Fence::isValidTimestamp(lastRefreshStartTime)) {
outString.appendFormat("%" PRId64 "\n", lastRefreshStartTime);
} else {
outString.appendFormat("Pending\n");
}
- outString.appendFormat("--- Acquire \t");
- if (isValidTimestamp(acquireTime)) {
- outString.appendFormat("%" PRId64 "\n", acquireTime);
- } else {
- outString.appendFormat("Pending\n");
- }
-
- outString.appendFormat("--- GPU Composite Done\t");
- if (isValidTimestamp(gpuCompositionDoneTime)) {
- outString.appendFormat("%" PRId64 "\n", gpuCompositionDoneTime);
- } else if (!addPostCompositeCalled || gpuCompositionDoneFence->isValid()) {
- outString.appendFormat("Pending\n");
- } else {
- outString.appendFormat("N/A\n");
- }
-
- outString.appendFormat("--- Display Present\t");
- if (isValidTimestamp(displayPresentTime)) {
- outString.appendFormat("%" PRId64 "\n", displayPresentTime);
- } else if (!addPostCompositeCalled || displayPresentFence->isValid()) {
- outString.appendFormat("Pending\n");
- } else {
- outString.appendFormat("N/A\n");
- }
-
- outString.appendFormat("--- Display Retire\t");
- if (isValidTimestamp(displayRetireTime)) {
- outString.appendFormat("%" PRId64 "\n", displayRetireTime);
- } else if (!addRetireCalled || displayRetireFence->isValid()) {
- outString.appendFormat("Pending\n");
- } else {
- outString.appendFormat("N/A\n");
- }
-
- outString.appendFormat("--- Release \t");
- if (isValidTimestamp(releaseTime)) {
- outString.appendFormat("%" PRId64 "\n", releaseTime);
- } else {
- outString.appendFormat("Pending\n");
- }
+ dumpFenceTime(outString, "Acquire \t",
+ true, *acquireFence);
+ dumpFenceTime(outString, "GPU Composite Done\t",
+ !addPostCompositeCalled, *gpuCompositionDoneFence);
+ dumpFenceTime(outString, "Display Present \t",
+ !addPostCompositeCalled, *displayPresentFence);
+ dumpFenceTime(outString, "Display Retire \t",
+ !addRetireCalled, *displayRetireFence);
+ dumpFenceTime(outString, "Release \t",
+ true, *releaseFence);
}
@@ -250,7 +223,7 @@
ProducerFrameEventHistory::~ProducerFrameEventHistory() = default;
void ProducerFrameEventHistory::updateAcquireFence(
- uint64_t frameNumber, sp<Fence> acquire) {
+ uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) {
FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset);
if (frame == nullptr) {
ALOGE("ProducerFrameEventHistory::updateAcquireFence: "
@@ -259,20 +232,39 @@
}
if (acquire->isValid()) {
- frame->acquireFence = acquire;
+ mAcquireTimeline.push(acquire);
+ frame->acquireFence = std::move(acquire);
} else {
// If there isn't an acquire fence, assume that buffer was
// ready for the consumer when posted.
- frame->acquireTime = frame->postedTime;
+ frame->acquireFence = std::make_shared<FenceTime>(frame->postedTime);
}
}
-static void applyFenceDelta(sp<Fence>* dst, const sp<Fence>& src) {
- if (src->isValid()) {
- if ((*dst)->isValid()) {
- ALOGE("applyFenceDelta: Unexpected fence.");
- }
- *dst = src;
+static void applyFenceDelta(FenceTimeline* timeline,
+ std::shared_ptr<FenceTime>* dst, const FenceTime::Snapshot& src) {
+ if (CC_UNLIKELY(dst == nullptr)) {
+ ALOGE("applyFenceDelta: dst is null.");
+ return;
+ }
+
+ switch (src.state) {
+ case FenceTime::Snapshot::State::EMPTY:
+ return;
+ case FenceTime::Snapshot::State::FENCE:
+ if (CC_UNLIKELY((*dst)->isValid())) {
+ ALOGE("applyFenceDelta: Unexpected fence.");
+ }
+ *dst = std::make_shared<FenceTime>(src.fence);
+ timeline->push(*dst);
+ return;
+ case FenceTime::Snapshot::State::SIGNAL_TIME:
+ if ((*dst)->isValid()) {
+ (*dst)->applyTrustedSnapshot(src);
+ } else {
+ *dst = std::make_shared<FenceTime>(src.signalTime);
+ }
+ return;
}
}
@@ -297,40 +289,37 @@
frame.firstRefreshStartTime = d.mFirstRefreshStartTime;
frame.lastRefreshStartTime = d.mLastRefreshStartTime;
- if (frame.frameNumber == d.mFrameNumber) {
- // Existing frame. Merge.
- // Consumer never sends timestamps of fences, only the fences
- // themselves, so we never need to update the fence timestamps here.
- applyFenceDelta(
- &frame.gpuCompositionDoneFence, d.mGpuCompositionDoneFence);
- applyFenceDelta(&frame.displayPresentFence, d.mDisplayPresentFence);
- applyFenceDelta(&frame.displayRetireFence, d.mDisplayRetireFence);
- applyFenceDelta(&frame.releaseFence, d.mReleaseFence);
- } else {
- // New frame. Overwrite.
+ if (frame.frameNumber != d.mFrameNumber) {
+ // We got a new frame. Initialize some of the fields.
frame.frameNumber = d.mFrameNumber;
-
- frame.gpuCompositionDoneFence = d.mGpuCompositionDoneFence;
- frame.displayPresentFence = d.mDisplayPresentFence;
- frame.displayRetireFence = d.mDisplayRetireFence;
- frame.releaseFence = d.mReleaseFence;
-
- // Set aquire fence and time at this point.
- frame.acquireTime = 0;
- frame.acquireFence = Fence::NO_FENCE;
-
- // Reset fence-related timestamps
- frame.gpuCompositionDoneTime = 0;
- frame.displayPresentTime = 0;
- frame.displayRetireTime = 0;
- frame.releaseTime = 0;
-
+ frame.acquireFence = FenceTime::NO_FENCE;
+ frame.gpuCompositionDoneFence = FenceTime::NO_FENCE;
+ frame.displayPresentFence = FenceTime::NO_FENCE;
+ frame.displayRetireFence = FenceTime::NO_FENCE;
+ frame.releaseFence = FenceTime::NO_FENCE;
// The consumer only sends valid frames.
frame.valid = true;
}
+
+ applyFenceDelta(&mGpuCompositionDoneTimeline,
+ &frame.gpuCompositionDoneFence, d.mGpuCompositionDoneFence);
+ applyFenceDelta(&mPresentTimeline,
+ &frame.displayPresentFence, d.mDisplayPresentFence);
+ applyFenceDelta(&mRetireTimeline,
+ &frame.displayRetireFence, d.mDisplayRetireFence);
+ applyFenceDelta(&mReleaseTimeline,
+ &frame.releaseFence, d.mReleaseFence);
}
}
+void ProducerFrameEventHistory::updateSignalTimes() {
+ mAcquireTimeline.updateSignalTimes();
+ mGpuCompositionDoneTimeline.updateSignalTimes();
+ mPresentTimeline.updateSignalTimes();
+ mRetireTimeline.updateSignalTimes();
+ mReleaseTimeline.updateSignalTimes();
+}
+
// ============================================================================
// ConsumerFrameEventHistory
@@ -377,14 +366,15 @@
}
frame->lastRefreshStartTime = refreshStartTime;
mFramesDirty[mCompositionOffset].setDirty<FrameEvent::LAST_REFRESH_START>();
- if (!isValidTimestamp(frame->firstRefreshStartTime)) {
+ if (!Fence::isValidTimestamp(frame->firstRefreshStartTime)) {
frame->firstRefreshStartTime = refreshStartTime;
mFramesDirty[mCompositionOffset].setDirty<FrameEvent::FIRST_REFRESH_START>();
}
}
void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,
- sp<Fence> gpuCompositionDone, sp<Fence> displayPresent) {
+ const std::shared_ptr<FenceTime>& gpuCompositionDone,
+ const std::shared_ptr<FenceTime>& displayPresent) {
FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
if (frame == nullptr) {
ALOGE("ConsumerFrameEventHistory::addPostComposition: "
@@ -404,7 +394,7 @@
}
void ConsumerFrameEventHistory::addRetire(
- uint64_t frameNumber, sp<Fence> displayRetire) {
+ uint64_t frameNumber, const std::shared_ptr<FenceTime>& displayRetire) {
FrameEvents* frame = getFrame(frameNumber, &mRetireOffset);
if (frame == nullptr) {
ALOGE("ConsumerFrameEventHistory::addRetire: Did not find frame.");
@@ -416,26 +406,39 @@
}
void ConsumerFrameEventHistory::addRelease(
- uint64_t frameNumber, sp<Fence> release) {
+ uint64_t frameNumber, std::shared_ptr<FenceTime>&& release) {
FrameEvents* frame = getFrame(frameNumber, &mReleaseOffset);
if (frame == nullptr) {
ALOGE("ConsumerFrameEventHistory::addRelease: Did not find frame.");
return;
}
frame->addReleaseCalled = true;
- frame->releaseFence = release;
+ frame->releaseFence = std::move(release);
mFramesDirty[mReleaseOffset].setDirty<FrameEvent::RELEASE>();
}
+void ConsumerFrameEventHistory::getFrameDelta(
+ FrameEventHistoryDelta* delta,
+ const std::array<FrameEvents, MAX_FRAME_HISTORY>::iterator& frame) {
+ size_t i = static_cast<size_t>(std::distance(mFrames.begin(), frame));
+ if (mFramesDirty[i].anyDirty()) {
+ delta->mDeltas.emplace_back(i, *frame, mFramesDirty[i]);
+ mFramesDirty[i].reset();
+ }
+}
+
void ConsumerFrameEventHistory::getAndResetDelta(
FrameEventHistoryDelta* delta) {
+ // Write these in order of frame number so that it is easy to
+ // add them to a FenceTimeline in the proper order producer side.
delta->mDeltas.reserve(mFramesDirty.size());
- for (size_t i = 0; i < mFramesDirty.size(); i++) {
- if (mFramesDirty[i].anyDirty()) {
- delta->mDeltas.push_back(
- FrameEventsDelta(i, mFrames[i], mFramesDirty[i]));
- mFramesDirty[i].reset();
- }
+ auto earliestFrame = std::min_element(
+ mFrames.begin(), mFrames.end(), &FrameNumberLessThan);
+ for (auto frame = earliestFrame; frame != mFrames.end(); ++frame) {
+ getFrameDelta(delta, frame);
+ }
+ for (auto frame = mFrames.begin(); frame != earliestFrame; ++frame) {
+ getFrameDelta(delta, frame);
}
}
@@ -458,15 +461,20 @@
mLatchTime(frameTimestamps.latchTime),
mFirstRefreshStartTime(frameTimestamps.firstRefreshStartTime),
mLastRefreshStartTime(frameTimestamps.lastRefreshStartTime) {
- mGpuCompositionDoneFence =
- dirtyFields.isDirty<FrameEvent::GL_COMPOSITION_DONE>() ?
- frameTimestamps.gpuCompositionDoneFence : Fence::NO_FENCE;
- mDisplayPresentFence = dirtyFields.isDirty<FrameEvent::DISPLAY_PRESENT>() ?
- frameTimestamps.displayPresentFence : Fence::NO_FENCE;
- mDisplayRetireFence = dirtyFields.isDirty<FrameEvent::DISPLAY_RETIRE>() ?
- frameTimestamps.displayRetireFence : Fence::NO_FENCE;
- mReleaseFence = dirtyFields.isDirty<FrameEvent::RELEASE>() ?
- frameTimestamps.releaseFence : Fence::NO_FENCE;
+ if (dirtyFields.isDirty<FrameEvent::GL_COMPOSITION_DONE>()) {
+ mGpuCompositionDoneFence =
+ frameTimestamps.gpuCompositionDoneFence->getSnapshot();
+ }
+ if (dirtyFields.isDirty<FrameEvent::DISPLAY_PRESENT>()) {
+ mDisplayPresentFence =
+ frameTimestamps.displayPresentFence->getSnapshot();
+ }
+ if (dirtyFields.isDirty<FrameEvent::DISPLAY_RETIRE>()) {
+ mDisplayRetireFence = frameTimestamps.displayRetireFence->getSnapshot();
+ }
+ if (dirtyFields.isDirty<FrameEvent::RELEASE>()) {
+ mReleaseFence = frameTimestamps.releaseFence->getSnapshot();
+ }
}
size_t FrameEventsDelta::minFlattenedSize() {
@@ -489,16 +497,16 @@
auto fences = allFences(this);
return minFlattenedSize() +
std::accumulate(fences.begin(), fences.end(), size_t(0),
- [](size_t a, const sp<Fence>* fence) {
- return a + (*fence)->getFlattenedSize();
+ [](size_t a, const FenceTime::Snapshot* fence) {
+ return a + fence->getFlattenedSize();
});
}
size_t FrameEventsDelta::getFdCount() const {
auto fences = allFences(this);
return std::accumulate(fences.begin(), fences.end(), size_t(0),
- [](size_t a, const sp<Fence>* fence) {
- return a + (*fence)->getFdCount();
+ [](size_t a, const FenceTime::Snapshot* fence) {
+ return a + fence->getFdCount();
});
}
@@ -532,7 +540,7 @@
// Fences
for (auto fence : allFences(this)) {
- status_t status = (*fence)->flatten(buffer, size, fds, count);
+ status_t status = fence->flatten(buffer, size, fds, count);
if (status != NO_ERROR) {
return status;
}
@@ -570,8 +578,7 @@
// Fences
for (auto fence : allFences(this)) {
- *fence = new Fence;
- status_t status = (*fence)->unflatten(buffer, size, fds, count);
+ status_t status = fence->unflatten(buffer, size, fds, count);
if (status != NO_ERROR) {
return status;
}
@@ -584,6 +591,16 @@
// FrameEventHistoryDelta
// ============================================================================
+FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(
+ FrameEventHistoryDelta&& src) {
+ if (CC_UNLIKELY(!mDeltas.empty())) {
+ ALOGE("FrameEventHistoryDelta: Clobbering history.");
+ }
+ mDeltas = std::move(src.mDeltas);
+ ALOGE_IF(src.mDeltas.empty(), "Source mDeltas not empty.");
+ return *this;
+}
+
size_t FrameEventHistoryDelta::minFlattenedSize() {
return sizeof(uint32_t);
}
diff --git a/libs/gui/GLConsumer.cpp b/libs/gui/GLConsumer.cpp
index 10e999c..b919b3c 100644
--- a/libs/gui/GLConsumer.cpp
+++ b/libs/gui/GLConsumer.cpp
@@ -322,6 +322,7 @@
mCurrentTransform = 0;
mCurrentTimestamp = 0;
mCurrentFence = Fence::NO_FENCE;
+ mCurrentFenceTime = FenceTime::NO_FENCE;
if (mAttached) {
// This binds a dummy buffer (mReleasedTexImage).
@@ -488,6 +489,7 @@
mCurrentScalingMode = item.mScalingMode;
mCurrentTimestamp = item.mTimestamp;
mCurrentFence = item.mFence;
+ mCurrentFenceTime = item.mFenceTime;
mCurrentFrameNumber = item.mFrameNumber;
computeCurrentTransformMatrixLocked();
@@ -856,6 +858,8 @@
switch (buf->getPixelFormat()) {
case PIXEL_FORMAT_RGBA_8888:
case PIXEL_FORMAT_RGBX_8888:
+ case PIXEL_FORMAT_RGBA_FP16:
+ case PIXEL_FORMAT_RGBX_FP16:
case PIXEL_FORMAT_RGB_888:
case PIXEL_FORMAT_RGB_565:
case PIXEL_FORMAT_BGRA_8888:
@@ -981,6 +985,11 @@
return mCurrentFence;
}
+std::shared_ptr<FenceTime> GLConsumer::getCurrentFenceTime() const {
+ Mutex::Autolock lock(mMutex);
+ return mCurrentFenceTime;
+}
+
status_t GLConsumer::doGLFenceWait() const {
Mutex::Autolock lock(mMutex);
return doGLFenceWaitLocked();
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index 6a02a77..c9e1c6c 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -144,6 +144,19 @@
mEnableFrameTimestamps = enable;
}
+static void getFrameTimestamp(nsecs_t *dst, const nsecs_t& src) {
+ if (dst != nullptr) {
+ *dst = Fence::isValidTimestamp(src) ? src : 0;
+ }
+}
+
+static void getFrameTimestampFence(nsecs_t *dst, const std::shared_ptr<FenceTime>& src) {
+ if (dst != nullptr) {
+ nsecs_t signalTime = src->getSignalTime();
+ *dst = Fence::isValidTimestamp(signalTime) ? signalTime : 0;
+ }
+}
+
status_t Surface::getFrameTimestamps(uint64_t frameNumber,
nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,
nsecs_t* outRefreshStartTime, nsecs_t* outGlCompositionDoneTime,
@@ -188,29 +201,16 @@
return NAME_NOT_FOUND;
}
- events->checkFencesForCompletion();
+ getFrameTimestamp(outRequestedPresentTime, events->requestedPresentTime);
+ getFrameTimestamp(outRefreshStartTime, events->firstRefreshStartTime);
- if (outRequestedPresentTime) {
- *outRequestedPresentTime = events->requestedPresentTime;
- }
- if (outAcquireTime) {
- *outAcquireTime = events->acquireTime;
- }
- if (outRefreshStartTime) {
- *outRefreshStartTime = events->firstRefreshStartTime;
- }
- if (outGlCompositionDoneTime) {
- *outGlCompositionDoneTime = events->gpuCompositionDoneTime;
- }
- if (outDisplayPresentTime) {
- *outDisplayPresentTime = events->displayPresentTime;
- }
- if (outDisplayRetireTime) {
- *outDisplayRetireTime = events->displayRetireTime;
- }
- if (outReleaseTime) {
- *outReleaseTime = events->releaseTime;
- }
+ getFrameTimestampFence(outAcquireTime, events->acquireFence);
+ getFrameTimestampFence(
+ outGlCompositionDoneTime, events->gpuCompositionDoneFence);
+ getFrameTimestampFence(
+ outDisplayPresentTime, events->displayPresentFence);
+ getFrameTimestampFence(outDisplayRetireTime, events->displayRetireFence);
+ getFrameTimestampFence(outReleaseTime, events->releaseFence);
return NO_ERROR;
}
@@ -571,7 +571,12 @@
// Update timestamps with the local acquire fence.
// The consumer doesn't send it back to prevent us from having two
// file descriptors of the same fence.
- mFrameEventHistory.updateAcquireFence(mNextFrameNumber, fence);
+ mFrameEventHistory.updateAcquireFence(mNextFrameNumber,
+ std::make_shared<FenceTime>(std::move(fence)));
+
+ // Cache timestamps of signaled fences so we can close their file
+ // descriptors.
+ mFrameEventHistory.updateSignalTimes();
}
mDefaultWidth = output.width;
diff --git a/libs/ui/PixelFormat.cpp b/libs/ui/PixelFormat.cpp
index cab1dde..3ceb638 100644
--- a/libs/ui/PixelFormat.cpp
+++ b/libs/ui/PixelFormat.cpp
@@ -22,6 +22,9 @@
uint32_t bytesPerPixel(PixelFormat format) {
switch (format) {
+ case PIXEL_FORMAT_RGBA_FP16:
+ case PIXEL_FORMAT_RGBX_FP16:
+ return 8;
case PIXEL_FORMAT_RGBA_8888:
case PIXEL_FORMAT_RGBX_8888:
case PIXEL_FORMAT_BGRA_8888:
@@ -38,6 +41,9 @@
uint32_t bitsPerPixel(PixelFormat format) {
switch (format) {
+ case PIXEL_FORMAT_RGBA_FP16:
+ case PIXEL_FORMAT_RGBX_FP16:
+ return 64;
case PIXEL_FORMAT_RGBA_8888:
case PIXEL_FORMAT_RGBX_8888:
case PIXEL_FORMAT_BGRA_8888:
diff --git a/opengl/include/EGL/eglext.h b/opengl/include/EGL/eglext.h
index 73e5e07..874e712 100644
--- a/opengl/include/EGL/eglext.h
+++ b/opengl/include/EGL/eglext.h
@@ -643,8 +643,8 @@
EGLAPI EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
EGLAPI EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
#else
-typedef EGLAPI EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-typedef EGLAPI EGLBoolean (EGLAPIENTRYP PFNEGLQUERYTIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYTIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
#endif
#endif
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 71538d6..6328c9c 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -476,6 +476,7 @@
// modify the EGLconfig's format before setting the native window's
// format.
+ // TODO: Add support for HAL_PIXEL_FORMAT_RGBA_FP16
// by default, just pick RGBA_8888
EGLint format = HAL_PIXEL_FORMAT_RGBA_8888;
android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN;
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h
index 33fb8cb..7e8f94b 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2.h
@@ -57,6 +57,8 @@
typedef std::function<void(std::shared_ptr<Display>)> RefreshCallback;
typedef std::function<void(std::shared_ptr<Display>, nsecs_t)> VsyncCallback;
+// C++ Wrapper around hwc2_device_t. Load all functions pointers
+// and handle callback registration.
class Device
{
public:
@@ -207,6 +209,7 @@
std::vector<std::pair<std::shared_ptr<Display>, nsecs_t>> mPendingVsyncs;
};
+// Convenience C++ class to access hwc2_device_t Display functions directly.
class Display : public std::enable_shared_from_this<Display>
{
public:
@@ -368,6 +371,7 @@
std::unordered_map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs;
};
+// Convenience C++ class to access hwc2_device_t Layer functions directly.
class Layer
{
public:
diff --git a/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.h b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.h
index aa96004..9abdc38 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.h
@@ -40,6 +40,10 @@
namespace android {
+// For devices unable to provide an implementation of HWC2 (see hwcomposer2.h),
+// we provide an adapter able to talk to HWC1 (see hwcomposer.h). It translates
+// streamed function calls ala HWC2 model to batched array of structs calls ala
+// HWC1 model.
class HWC2On1Adapter : public hwc2_device_t
{
public:
@@ -135,6 +139,24 @@
void operator()(struct hwc_display_contents_1* contents);
};
+ // The semantics of the fences returned by the device differ between
+ // hwc1.set() and hwc2.present(). Read hwcomposer.h and hwcomposer2.h
+ // for more information.
+ //
+ // Release fences in hwc1 are obtained on set() for a frame n and signaled
+ // when the layer buffer is not needed for read operations anymore
+ // (typically on frame n+1). In HWC2, release fences are obtained with a
+ // special call after present() for frame n. These fences signal
+ // on frame n: More specifically, the fence for a given buffer provided in
+ // frame n will signal when the prior buffer is no longer required.
+ //
+ // A retire fence (HWC1) is signaled when a composition is replaced
+ // on the panel whereas a present fence (HWC2) is signaled when a
+ // composition starts to be displayed on a panel.
+ //
+ // The HWC2to1Adapter emulates the new fence semantics for a frame
+ // n by returning the fence from frame n-1. For frame 0, the adapter
+ // returns NO_FENCE.
class DeferredFence {
public:
DeferredFence()
@@ -150,6 +172,7 @@
}
private:
+ // There are always two fences in this queue.
std::queue<sp<Fence>> mFences;
};
@@ -234,7 +257,10 @@
bool prepare();
HWC1Contents cloneRequestedContents() const;
+
+ // Called after hwc.prepare() with responses from the device.
void setReceivedContents(HWC1Contents contents);
+
bool hasChanges() const;
HWC2::Error set(hwc_display_contents_1& hwcContents);
void addRetireFence(int fenceFd);
@@ -288,6 +314,10 @@
std::unordered_map<android_color_mode_t, uint32_t> mHwc1Ids;
};
+ // Store changes requested from the device upon calling prepare().
+ // Handles change request to:
+ // - Layer composition type.
+ // - Layer hints.
class Changes {
public:
uint32_t getNumTypes() const {
@@ -336,8 +366,13 @@
void reallocateHwc1Contents();
void assignHwc1LayerIds();
+ // Called after a response to prepare() has been received:
+ // Ingest composition type changes requested by the device.
void updateTypeChanges(const struct hwc_layer_1& hwc1Layer,
const Layer& layer);
+
+ // Called after a response to prepare() has been received:
+ // Ingest layer hint changes requested by the device.
void updateLayerRequests(const struct hwc_layer_1& hwc1Layer,
const Layer& layer);
@@ -361,8 +396,11 @@
mutable std::recursive_mutex mStateMutex;
bool mZIsDirty;
- HWC1Contents mHwc1RequestedContents;
- HWC1Contents mHwc1ReceivedContents;
+
+ // Array of structs exchanged between client and hwc1 device.
+ HWC1Contents mHwc1RequestedContents; // Sent to device upon calling prepare().
+ HWC1Contents mHwc1ReceivedContents; // Returned by device after prepare().
+
DeferredFence mRetireFence;
// Will only be non-null after the layer has been validated but
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index c82b0c4..034a394 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -602,7 +602,7 @@
return mDisplayData[displayId].lastPresentFence;
}
-bool HWComposer::retireFenceRepresentsStartOfScanout() const {
+bool HWComposer::presentFenceRepresentsStartOfScanout() const {
return mAdapter ? false : true;
}
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index e63bdd4..2713505 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -121,10 +121,10 @@
// get the present fence received from the last call to present.
sp<Fence> getPresentFence(int32_t displayId) const;
- // Returns true if the retire fence represents the start of the display
+ // Returns true if the present fence represents the start of the display
// controller's scan out. This should be true for all HWC2 implementations,
// except for the wrapper around HWC1 implementations.
- bool retireFenceRepresentsStartOfScanout() const;
+ bool presentFenceRepresentsStartOfScanout() const;
// Get last release fence for the given layer
sp<Fence> getLayerReleaseFence(int32_t displayId,
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
index 2102457..c40a58c 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
@@ -1159,6 +1159,8 @@
switch (format) {
case PIXEL_FORMAT_RGBA_8888: return String8("RGBA_8888");
case PIXEL_FORMAT_RGBX_8888: return String8("RGBx_8888");
+ case PIXEL_FORMAT_RGBA_FP16: return String8("RGBA_FP16");
+ case PIXEL_FORMAT_RGBX_FP16: return String8("RGBx_FP16");
case PIXEL_FORMAT_RGB_888: return String8("RGB_888");
case PIXEL_FORMAT_RGB_565: return String8("RGB_565");
case PIXEL_FORMAT_BGRA_8888: return String8("BGRA_8888");
diff --git a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
index 0511df2..6a98f03 100644
--- a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
+++ b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
@@ -281,7 +281,7 @@
#endif
&qbo);
if (result == NO_ERROR) {
- updateQueueBufferOutput(qbo);
+ updateQueueBufferOutput(std::move(qbo));
}
} else {
// If the surface hadn't actually been updated, then we only went
@@ -516,7 +516,8 @@
mOutputFence = mFbFence;
}
- *output = mQueueBufferOutput;
+ // This moves the frame timestamps and keeps a copy of all other fields.
+ *output = std::move(mQueueBufferOutput);
return NO_ERROR;
}
@@ -555,8 +556,9 @@
status_t result = mSource[SOURCE_SINK]->connect(listener, api,
producerControlledByApp, &qbo);
if (result == NO_ERROR) {
- updateQueueBufferOutput(qbo);
- *output = mQueueBufferOutput;
+ updateQueueBufferOutput(std::move(qbo));
+ // This moves the frame timestamps and keeps a copy of all other fields.
+ *output = std::move(mQueueBufferOutput);
}
return result;
}
@@ -615,8 +617,8 @@
}
void VirtualDisplaySurface::updateQueueBufferOutput(
- const QueueBufferOutput& qbo) {
- mQueueBufferOutput = qbo;
+ QueueBufferOutput&& qbo) {
+ mQueueBufferOutput = std::move(qbo);
mQueueBufferOutput.transformHint = 0;
}
diff --git a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
index b435bf5..d37dc0a 100644
--- a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
+++ b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
@@ -136,7 +136,7 @@
static Source fbSourceForCompositionType(CompositionType type);
status_t dequeueBuffer(Source source, PixelFormat format, uint32_t usage,
int* sslot, sp<Fence>* fence);
- void updateQueueBufferOutput(const QueueBufferOutput& qbo);
+ void updateQueueBufferOutput(QueueBufferOutput&& qbo);
void resetPerFrameState();
status_t refreshOutputBuffer();
@@ -181,6 +181,8 @@
// The QueueBufferOutput with the latest info from the sink, and with the
// transform hint cleared. Since we defer queueBuffer from the GLES driver
// to the sink, we have to return the previous version.
+ // Moves instead of copies are performed to avoid duplicate
+ // FrameEventHistoryDeltas.
QueueBufferOutput mQueueBufferOutput;
// Details of the current sink buffer. These become valid when a buffer is
diff --git a/services/surfaceflinger/FrameTracker.cpp b/services/surfaceflinger/FrameTracker.cpp
index c09bbe4..319c2a7 100644
--- a/services/surfaceflinger/FrameTracker.cpp
+++ b/services/surfaceflinger/FrameTracker.cpp
@@ -21,7 +21,6 @@
#include <cutils/log.h>
-#include <ui/Fence.h>
#include <ui/FrameStats.h>
#include <utils/String8.h>
@@ -48,9 +47,10 @@
mFrameRecords[mOffset].frameReadyTime = readyTime;
}
-void FrameTracker::setFrameReadyFence(const sp<Fence>& readyFence) {
+void FrameTracker::setFrameReadyFence(
+ std::shared_ptr<FenceTime>&& readyFence) {
Mutex::Autolock lock(mMutex);
- mFrameRecords[mOffset].frameReadyFence = readyFence;
+ mFrameRecords[mOffset].frameReadyFence = std::move(readyFence);
mNumFences++;
}
@@ -59,9 +59,10 @@
mFrameRecords[mOffset].actualPresentTime = presentTime;
}
-void FrameTracker::setActualPresentFence(const sp<Fence>& readyFence) {
+void FrameTracker::setActualPresentFence(
+ std::shared_ptr<FenceTime>&& readyFence) {
Mutex::Autolock lock(mMutex);
- mFrameRecords[mOffset].actualPresentFence = readyFence;
+ mFrameRecords[mOffset].actualPresentFence = std::move(readyFence);
mNumFences++;
}
@@ -95,10 +96,6 @@
mFrameRecords[mOffset].actualPresentFence = NULL;
mNumFences--;
}
-
- // Clean up the signaled fences to keep the number of open fence FDs in
- // this process reasonable.
- processFencesLocked();
}
void FrameTracker::clearStats() {
@@ -107,8 +104,8 @@
mFrameRecords[i].desiredPresentTime = 0;
mFrameRecords[i].frameReadyTime = 0;
mFrameRecords[i].actualPresentTime = 0;
- mFrameRecords[i].frameReadyFence.clear();
- mFrameRecords[i].actualPresentFence.clear();
+ mFrameRecords[i].frameReadyFence.reset();
+ mFrameRecords[i].actualPresentFence.reset();
}
mNumFences = 0;
mFrameRecords[mOffset].desiredPresentTime = INT64_MAX;
@@ -156,7 +153,7 @@
size_t idx = (mOffset+NUM_FRAME_RECORDS-i) % NUM_FRAME_RECORDS;
bool updated = false;
- const sp<Fence>& rfence = records[idx].frameReadyFence;
+ const std::shared_ptr<FenceTime>& rfence = records[idx].frameReadyFence;
if (rfence != NULL) {
records[idx].frameReadyTime = rfence->getSignalTime();
if (records[idx].frameReadyTime < INT64_MAX) {
@@ -166,7 +163,8 @@
}
}
- const sp<Fence>& pfence = records[idx].actualPresentFence;
+ const std::shared_ptr<FenceTime>& pfence =
+ records[idx].actualPresentFence;
if (pfence != NULL) {
records[idx].actualPresentTime = pfence->getSignalTime();
if (records[idx].actualPresentTime < INT64_MAX) {
diff --git a/services/surfaceflinger/FrameTracker.h b/services/surfaceflinger/FrameTracker.h
index cd5e3f3..adcdfb5 100644
--- a/services/surfaceflinger/FrameTracker.h
+++ b/services/surfaceflinger/FrameTracker.h
@@ -17,6 +17,8 @@
#ifndef ANDROID_FRAMETRACKER_H
#define ANDROID_FRAMETRACKER_H
+#include <ui/FenceTime.h>
+
#include <stddef.h>
#include <utils/Mutex.h>
@@ -26,7 +28,6 @@
namespace android {
class String8;
-class Fence;
// FrameTracker tracks information about the most recently rendered frames. It
// uses a circular buffer of frame records, and is *NOT* thread-safe -
@@ -60,7 +61,7 @@
// setFrameReadyFence sets the fence that is used to get the time at which
// the current frame became ready to be presented to the user.
- void setFrameReadyFence(const sp<Fence>& readyFence);
+ void setFrameReadyFence(std::shared_ptr<FenceTime>&& readyFence);
// setActualPresentTime sets the timestamp at which the current frame became
// visible to the user.
@@ -68,7 +69,7 @@
// setActualPresentFence sets the fence that is used to get the time
// at which the current frame became visible to the user.
- void setActualPresentFence(const sp<Fence>& fence);
+ void setActualPresentFence(std::shared_ptr<FenceTime>&& fence);
// setDisplayRefreshPeriod sets the display refresh period in nanoseconds.
// This is used to compute frame presentation duration statistics relative
@@ -100,8 +101,8 @@
nsecs_t desiredPresentTime;
nsecs_t frameReadyTime;
nsecs_t actualPresentTime;
- sp<Fence> frameReadyFence;
- sp<Fence> actualPresentFence;
+ std::shared_ptr<FenceTime> frameReadyFence;
+ std::shared_ptr<FenceTime> actualPresentFence;
};
// processFences iterates over all the frame records that have a fence set
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 38b6eca..c7d37a5 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -1189,6 +1189,7 @@
switch (format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_BGRA_8888:
+ case HAL_PIXEL_FORMAT_RGBA_FP16:
return false;
}
// in all other case, we have no blending (also for unknown formats)
@@ -1740,41 +1741,23 @@
return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
}
-bool Layer::onPostComposition(sp<Fence> glDoneFence) {
+bool Layer::onPostComposition(
+ const std::shared_ptr<FenceTime>& glDoneFence,
+ const std::shared_ptr<FenceTime>& presentFence,
+ const std::shared_ptr<FenceTime>& retireFence) {
+ mAcquireTimeline.updateSignalTimes();
+ mReleaseTimeline.updateSignalTimes();
+
// mFrameLatencyNeeded is true when a new frame was latched for the
// composition.
-
if (!mFrameLatencyNeeded)
return false;
- const HWComposer& hwc = mFlinger->getHwComposer();
-#ifdef USE_HWC2
- sp<Fence> retireFence = Fence::NO_FENCE;
- sp<Fence> presentFence = Fence::NO_FENCE;
- sp<Fence> presentOrRetireFence = Fence::NO_FENCE;
- if (hwc.retireFenceRepresentsStartOfScanout()) {
- presentFence = hwc.getPresentFence(HWC_DISPLAY_PRIMARY);
- presentOrRetireFence = presentFence;
- } else {
- retireFence = hwc.getPresentFence(HWC_DISPLAY_PRIMARY);
- presentOrRetireFence = retireFence;
- }
- bool wasGpuComposited = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ?
- mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType ==
- HWC2::Composition::Client : true;
-#else
- sp<Fence> retireFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
- sp<Fence> presentFence = Fence::NO_FENCE;
- sp<Fence> presentOrRetireFence = retireFence;
- bool wasGpuComposited = mIsGlesComposition;
-#endif
-
// Update mFrameEventHistory.
{
Mutex::Autolock lock(mFrameEventHistoryMutex);
mFrameEventHistory.addPostComposition(mCurrentFrameNumber,
- wasGpuComposited ? glDoneFence : Fence::NO_FENCE,
- presentFence);
+ glDoneFence, presentFence);
mFrameEventHistory.addRetire(mPreviousFrameNumber,
retireFence);
}
@@ -1783,22 +1766,28 @@
nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp();
mFrameTracker.setDesiredPresentTime(desiredPresentTime);
- sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence();
+ std::shared_ptr<FenceTime> frameReadyFence =
+ mSurfaceFlingerConsumer->getCurrentFenceTime();
if (frameReadyFence->isValid()) {
- mFrameTracker.setFrameReadyFence(frameReadyFence);
+ mFrameTracker.setFrameReadyFence(std::move(frameReadyFence));
} else {
// There was no fence for this frame, so assume that it was ready
// to be presented at the desired present time.
mFrameTracker.setFrameReadyTime(desiredPresentTime);
}
- if (presentOrRetireFence->isValid()) {
- mFrameTracker.setActualPresentFence(presentOrRetireFence);
+ if (presentFence->isValid()) {
+ mFrameTracker.setActualPresentFence(
+ std::shared_ptr<FenceTime>(presentFence));
+ } else if (retireFence->isValid()) {
+ mFrameTracker.setActualPresentFence(
+ std::shared_ptr<FenceTime>(retireFence));
} else {
// The HWC doesn't support present fences, so use the refresh
// timestamp instead.
- nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
- mFrameTracker.setActualPresentTime(presentTime);
+ mFrameTracker.setActualPresentTime(
+ mFlinger->getHwComposer().getRefreshTimestamp(
+ HWC_DISPLAY_PRIMARY));
}
mFrameTracker.advanceFrame();
@@ -1809,9 +1798,13 @@
#ifdef USE_HWC2
void Layer::releasePendingBuffer() {
mSurfaceFlingerConsumer->releasePendingBuffer();
- Mutex::Autolock lock(mFrameEventHistoryMutex);
- mFrameEventHistory.addRelease(mPreviousFrameNumber,
+ auto releaseFenceTime = std::make_shared<FenceTime>(
mSurfaceFlingerConsumer->getPrevFinalReleaseFence());
+ mReleaseTimeline.push(releaseFenceTime);
+
+ Mutex::Autolock lock(mFrameEventHistoryMutex);
+ mFrameEventHistory.addRelease(
+ mPreviousFrameNumber, std::move(releaseFenceTime));
}
#endif
@@ -1984,8 +1977,11 @@
Mutex::Autolock lock(mFrameEventHistoryMutex);
mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime);
#ifndef USE_HWC2
- mFrameEventHistory.addRelease(mPreviousFrameNumber,
+ auto releaseFenceTime = std::make_shared<FenceTime>(
mSurfaceFlingerConsumer->getPrevFinalReleaseFence());
+ mReleaseTimeline.push(releaseFenceTime);
+ mFrameEventHistory.addRelease(
+ mPreviousFrameNumber, std::move(releaseFenceTime));
#endif
}
@@ -2220,6 +2216,7 @@
FrameEventHistoryDelta *outDelta) {
Mutex::Autolock lock(mFrameEventHistoryMutex);
if (newTimestamps) {
+ mAcquireTimeline.push(newTimestamps->acquireFence);
mFrameEventHistory.addQueue(*newTimestamps);
}
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index f006726..b1e3298 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -276,7 +276,10 @@
* called after composition.
* returns true if the layer latched a new buffer this frame.
*/
- bool onPostComposition(sp<Fence> glCompositionDoneFence);
+ bool onPostComposition(
+ const std::shared_ptr<FenceTime>& glDoneFence,
+ const std::shared_ptr<FenceTime>& presentFence,
+ const std::shared_ptr<FenceTime>& retireFence);
#ifdef USE_HWC2
// If a buffer was replaced this frame, release the former buffer
@@ -586,6 +589,8 @@
// Accessed by both consumer and producer on main and binder threads.
Mutex mFrameEventHistoryMutex;
ConsumerFrameEventHistory mFrameEventHistory;
+ FenceTimeline mAcquireTimeline;
+ FenceTimeline mReleaseTimeline;
// main thread
sp<GraphicBuffer> mActiveBuffer;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index dde8d11..6625a8b 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -573,7 +573,7 @@
FrameEvent::ACQUIRE,
FrameEvent::FIRST_REFRESH_START,
FrameEvent::GL_COMPOSITION_DONE,
- getHwComposer().retireFenceRepresentsStartOfScanout() ?
+ getHwComposer().presentFenceRepresentsStartOfScanout() ?
FrameEvent::DISPLAY_PRESENT : FrameEvent::DISPLAY_RETIRE,
FrameEvent::RELEASE,
};
@@ -1226,26 +1226,45 @@
layer->releasePendingBuffer();
}
- bool hadClientComposition = mHwc->hasClientComposition(HWC_DISPLAY_PRIMARY);
-
const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
- sp<Fence> glCompositionDoneFence = hadClientComposition
- ? hw->getClientTargetAcquireFence()
- : Fence::NO_FENCE;
+
+ std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
+ if (mHwc->hasClientComposition(HWC_DISPLAY_PRIMARY)) {
+ glCompositionDoneFenceTime =
+ std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
+ mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
+ } else {
+ glCompositionDoneFenceTime = FenceTime::NO_FENCE;
+ }
+ mGlCompositionDoneTimeline.updateSignalTimes();
+
+ sp<Fence> displayFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
+ auto displayFenceTime = std::make_shared<FenceTime>(displayFence);
+ mDisplayTimeline.push(displayFenceTime);
+ mDisplayTimeline.updateSignalTimes();
+
+ const std::shared_ptr<FenceTime>* presentFenceTime = &FenceTime::NO_FENCE;
+ const std::shared_ptr<FenceTime>* retireFenceTime = &FenceTime::NO_FENCE;
+ if (mHwc->presentFenceRepresentsStartOfScanout()) {
+ presentFenceTime = &displayFenceTime;
+ } else {
+ retireFenceTime = &displayFenceTime;
+ }
+
const LayerVector& layers(mDrawingState.layersSortedByZ);
const size_t count = layers.size();
for (size_t i=0 ; i<count ; i++) {
- bool frameLatched = layers[i]->onPostComposition(glCompositionDoneFence);
+ bool frameLatched =
+ layers[i]->onPostComposition(glCompositionDoneFenceTime,
+ *presentFenceTime, *retireFenceTime);
if (frameLatched) {
recordBufferingStats(layers[i]->getName().string(),
layers[i]->getOccupancyHistory(false));
}
}
- sp<Fence> presentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
-
- if (presentFence->isValid()) {
- if (mPrimaryDispSync.addPresentFence(presentFence)) {
+ if (displayFence->isValid()) {
+ if (mPrimaryDispSync.addPresentFence(displayFence)) {
enableHardwareVsync();
} else {
disableHardwareVsync(false);
@@ -1261,8 +1280,9 @@
if (mAnimCompositionPending) {
mAnimCompositionPending = false;
- if (presentFence->isValid()) {
- mAnimFrameTracker.setActualPresentFence(presentFence);
+ if (displayFenceTime->isValid()) {
+ mAnimFrameTracker.setActualPresentFence(
+ std::move(displayFenceTime));
} else {
// The HWC doesn't support present fences, so use the refresh
// timestamp instead.
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 4ec1a72..2d6f9f6 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -37,6 +37,7 @@
#include <binder/IMemory.h>
+#include <ui/FenceTime.h>
#include <ui/PixelFormat.h>
#include <ui/mat4.h>
@@ -501,6 +502,8 @@
sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
bool mHadClientComposition = false;
#endif
+ FenceTimeline mGlCompositionDoneTimeline;
+ FenceTimeline mDisplayTimeline;
// this may only be written from the main thread with mStateLock held
// it may be read from other threads with mStateLock held
diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
index 55edc15..ada0046 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -1136,27 +1136,35 @@
const HWComposer& hwc = getHwComposer();
const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
- bool hadGlesComposition =
- getHwComposer().hasGlesComposition(hw->getHwcDisplayId());
- sp<Fence> glCompositionDoneFence = hadGlesComposition
- ? hw->getClientTargetAcquireFence()
- : Fence::NO_FENCE;
+ std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
+ if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
+ glCompositionDoneFenceTime =
+ std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
+ mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
+ } else {
+ glCompositionDoneFenceTime = FenceTime::NO_FENCE;
+ }
+ mGlCompositionDoneTimeline.updateSignalTimes();
+
+ sp<Fence> displayFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
+ const std::shared_ptr<FenceTime>& presentFenceTime = FenceTime::NO_FENCE;
+ auto retireFenceTime = std::make_shared<FenceTime>(displayFence);
+ mDisplayTimeline.push(retireFenceTime);
+ mDisplayTimeline.updateSignalTimes();
const LayerVector& layers(mDrawingState.layersSortedByZ);
const size_t count = layers.size();
for (size_t i=0 ; i<count ; i++) {
bool frameLatched = layers[i]->onPostComposition(
- glCompositionDoneFence);
+ glCompositionDoneFenceTime, presentFenceTime, retireFenceTime);
if (frameLatched) {
recordBufferingStats(layers[i]->getName().string(),
layers[i]->getOccupancyHistory(false));
}
}
- sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
-
- if (presentFence->isValid()) {
- if (mPrimaryDispSync.addPresentFence(presentFence)) {
+ if (displayFence->isValid()) {
+ if (mPrimaryDispSync.addPresentFence(displayFence)) {
enableHardwareVsync();
} else {
disableHardwareVsync(false);
@@ -1172,8 +1180,8 @@
if (mAnimCompositionPending) {
mAnimCompositionPending = false;
- if (presentFence->isValid()) {
- mAnimFrameTracker.setActualPresentFence(presentFence);
+ if (retireFenceTime->isValid()) {
+ mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
} else {
// The HWC doesn't support present fences, so use the refresh
// timestamp instead.
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 7e90503..9856d6a 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -723,6 +723,8 @@
const VkAllocationCallbacks* allocator) {
const auto& dispatch = GetData(device).driver;
Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
+ if (!swapchain)
+ return;
bool active = swapchain->surface.swapchain_handle == swapchain_handle;
ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;