services/surfaceflinger/BufferStateLayer.cpp - platform/frameworks/native - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 //#define LOG_NDEBUG 0
 #undef LOG_TAG
 #define LOG_TAG "BufferStateLayer"
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS

 #include "BufferStateLayer.h"
 #include "RenderEngine/Image.h"

 #include <private/gui/SyncFeatures.h>

 namespace android {

 static const std::array<float, 16> IDENTITY_MATRIX{1, 0, 0, 0,
                                                    0, 1, 0, 0,
                                                    0, 0, 1, 0,
                                                    0, 0, 0, 1};

 BufferStateLayer::BufferStateLayer(SurfaceFlinger* flinger, const sp<Client>& client,
                                    const String8& name, uint32_t w, uint32_t h, uint32_t flags)
       : BufferLayer(flinger, client, name, w, h, flags),
         mSidebandStreamChanged(false),
         mFrameNumber(0) {
     mTransformMatrix = IDENTITY_MATRIX;
 }

 // -----------------------------------------------------------------------
 // Interface implementation for Layer
 // -----------------------------------------------------------------------
 void BufferStateLayer::onLayerDisplayed(const sp<Fence>& /*releaseFence*/) {
     // TODO(marissaw): send the release fence back to buffer owner
     return;
 }

 void BufferStateLayer::setTransformHint(uint32_t /*orientation*/) const {
     // TODO(marissaw): send the transform hint to buffer owner
     return;
 }

 void BufferStateLayer::releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) {
     // TODO(marissaw): use this to signal the buffer owner
     return;
 }

 bool BufferStateLayer::shouldPresentNow(const DispSync& /*dispSync*/) const {
     if (getSidebandStreamChanged() || getAutoRefresh()) {
         return true;
     }

     return hasDrawingBuffer();
 }

 bool BufferStateLayer::getTransformToDisplayInverse() const {
     return mCurrentState.transformToDisplayInverse;
 }

 void BufferStateLayer::pushPendingState() {
     if (!mCurrentState.modified) {
         return;
     }
     mPendingStates.push_back(mCurrentState);
     ATRACE_INT(mTransactionName.string(), mPendingStates.size());
 }

 bool BufferStateLayer::applyPendingStates(Layer::State* stateToCommit) {
     const bool stateUpdateAvailable = !mPendingStates.empty();
     while (!mPendingStates.empty()) {
         popPendingState(stateToCommit);
     }
     mCurrentState.modified = false;
     return stateUpdateAvailable;
 }

 Rect BufferStateLayer::getCrop(const Layer::State& s) const {
     return (getEffectiveScalingMode() == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)
             ? GLConsumer::scaleDownCrop(s.crop, s.active.w, s.active.h)
             : s.crop;
 }

 bool BufferStateLayer::setTransform(uint32_t transform) {
     if (mCurrentState.transform == transform) return false;
     mCurrentState.sequence++;
     mCurrentState.transform = transform;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setTransformToDisplayInverse(bool transformToDisplayInverse) {
     if (mCurrentState.transformToDisplayInverse == transformToDisplayInverse) return false;
     mCurrentState.sequence++;
     mCurrentState.transformToDisplayInverse = transformToDisplayInverse;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setCrop(const Rect& crop) {
     if (mCurrentState.crop == crop) return false;
     mCurrentState.sequence++;
     mCurrentState.crop = crop;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setBuffer(sp<GraphicBuffer> buffer) {
     mCurrentState.sequence++;
     mCurrentState.buffer = buffer;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setAcquireFence(const sp<Fence>& fence) {
     mCurrentState.acquireFence = fence;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setDataspace(ui::Dataspace dataspace) {
     if (mCurrentState.dataspace == dataspace) return false;
     mCurrentState.sequence++;
     mCurrentState.dataspace = dataspace;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setHdrMetadata(const HdrMetadata& hdrMetadata) {
     if (mCurrentState.hdrMetadata == hdrMetadata) return false;
     mCurrentState.sequence++;
     mCurrentState.hdrMetadata = hdrMetadata;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setSurfaceDamageRegion(const Region& surfaceDamage) {
     mCurrentState.sequence++;
     mCurrentState.surfaceDamageRegion = surfaceDamage;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setApi(int32_t api) {
     if (mCurrentState.api == api) return false;
     mCurrentState.sequence++;
     mCurrentState.api = api;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setSidebandStream(const sp<NativeHandle>& sidebandStream) {
     if (mCurrentState.sidebandStream == sidebandStream) return false;
     mCurrentState.sequence++;
     mCurrentState.sidebandStream = sidebandStream;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);

     if (!mSidebandStreamChanged.exchange(true)) {
         // mSidebandStreamChanged was false
         mFlinger->signalLayerUpdate();
     }
     return true;
 }

 bool BufferStateLayer::setSize(uint32_t w, uint32_t h) {
     if (mCurrentState.active.w == w && mCurrentState.active.h == h) return false;
     mCurrentState.active.w = w;
     mCurrentState.active.h = h;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setPosition(float x, float y, bool /*immediate*/) {
     if (mCurrentState.active.transform.tx() == x && mCurrentState.active.transform.ty() == y)
         return false;

     mCurrentState.active.transform.set(x, y);

     mCurrentState.sequence++;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setTransparentRegionHint(const Region& transparent) {
     mCurrentState.transparentRegionHint = transparent;
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }

 bool BufferStateLayer::setMatrix(const layer_state_t::matrix22_t& matrix,
                                  bool allowNonRectPreservingTransforms) {
     ui::Transform t;
     t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);

     if (!allowNonRectPreservingTransforms && !t.preserveRects()) {
         ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored");
         return false;
     }

     mCurrentState.sequence++;
     mCurrentState.active.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
     mCurrentState.modified = true;
     setTransactionFlags(eTransactionNeeded);
     return true;
 }
 // -----------------------------------------------------------------------

 // -----------------------------------------------------------------------
 // Interface implementation for BufferLayer
 // -----------------------------------------------------------------------
 bool BufferStateLayer::fenceHasSignaled() const {
     if (latchUnsignaledBuffers()) {
         return true;
     }

     return getDrawingState().acquireFence->getStatus() == Fence::Status::Signaled;
 }

 nsecs_t BufferStateLayer::getDesiredPresentTime() {
     // TODO(marissaw): support an equivalent to desiredPresentTime for timestats metrics
     return 0;
 }

 std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTime() const {
     return std::make_shared<FenceTime>(getDrawingState().acquireFence);
 }

 void BufferStateLayer::getDrawingTransformMatrix(float *matrix) {
     std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix), matrix);
 }

 uint32_t BufferStateLayer::getDrawingTransform() const {
     return getDrawingState().transform;
 }

 ui::Dataspace BufferStateLayer::getDrawingDataSpace() const {
     return getDrawingState().dataspace;
 }

 Rect BufferStateLayer::getDrawingCrop() const {
     return Rect::INVALID_RECT;
 }

 uint32_t BufferStateLayer::getDrawingScalingMode() const {
     return NATIVE_WINDOW_SCALING_MODE_FREEZE;
 }

 Region BufferStateLayer::getDrawingSurfaceDamage() const {
     return getDrawingState().surfaceDamageRegion;
 }

 const HdrMetadata& BufferStateLayer::getDrawingHdrMetadata() const {
     return getDrawingState().hdrMetadata;
 }

 int BufferStateLayer::getDrawingApi() const {
     return getDrawingState().api;
 }

 PixelFormat BufferStateLayer::getPixelFormat() const {
     return mActiveBuffer->format;
 }

 uint64_t BufferStateLayer::getFrameNumber() const {
     return mFrameNumber;
 }

 bool BufferStateLayer::getAutoRefresh() const {
     // TODO(marissaw): support shared buffer mode
     return false;
 }

 bool BufferStateLayer::getSidebandStreamChanged() const {
     return mSidebandStreamChanged.load();
 }

 std::optional<Region> BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
     if (mSidebandStreamChanged.exchange(false)) {
         const State& s(getDrawingState());
         // mSidebandStreamChanged was true
         // replicated in LayerBE until FE/BE is ready to be synchronized
         getBE().compositionInfo.hwc.sidebandStream = s.sidebandStream;
         if (getBE().compositionInfo.hwc.sidebandStream != nullptr) {
             setTransactionFlags(eTransactionNeeded);
             mFlinger->setTransactionFlags(eTraversalNeeded);
         }
         recomputeVisibleRegions = true;

         return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
     }
     return {};
 }

 bool BufferStateLayer::hasDrawingBuffer() const {
     return getDrawingState().buffer != nullptr;
 }

 void BufferStateLayer::setFilteringEnabled(bool enabled) {
     GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mCurrentCrop,
                                        mCurrentTransform, enabled);
 }

 status_t BufferStateLayer::bindTextureImage() const {
     const State& s(getDrawingState());
     auto& engine(mFlinger->getRenderEngine());

     if (!engine.isCurrent()) {
         ALOGE("RenderEngine is not current");
         return INVALID_OPERATION;
     }

     engine.checkErrors();

     if (!mTextureImage) {
         ALOGE("no currently-bound texture");
         engine.bindExternalTextureImage(mTextureName, *engine.createImage());
         return NO_INIT;
     }

     bool created =
             mTextureImage->setNativeWindowBuffer(s.buffer->getNativeBuffer(),
                                                  s.buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
     if (!created) {
         ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
               s.buffer->getWidth(), s.buffer->getHeight(), s.buffer->getStride(),
               s.buffer->getUsage(), s.buffer->getPixelFormat());
         engine.bindExternalTextureImage(mTextureName, *engine.createImage());
         return NO_INIT;
     }

     engine.bindExternalTextureImage(mTextureName, *mTextureImage);

     // Wait for the new buffer to be ready.
     if (s.acquireFence->isValid()) {
         if (SyncFeatures::getInstance().useWaitSync()) {
             base::unique_fd fenceFd(s.acquireFence->dup());
             if (fenceFd == -1) {
                 ALOGE("error dup'ing fence fd: %d", errno);
                 return -errno;
             }
             if (!engine.waitFence(std::move(fenceFd))) {
                 ALOGE("failed to wait on fence fd");
                 return UNKNOWN_ERROR;
             }
         } else {
             status_t err = s.acquireFence->waitForever("BufferStateLayer::bindTextureImage");
             if (err != NO_ERROR) {
                 ALOGE("error waiting for fence: %d", err);
                 return err;
             }
         }
     }

     return NO_ERROR;
 }

 status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nsecs_t latchTime) {
     const State& s(getDrawingState());

     if (!s.buffer) {
         return NO_ERROR;
     }

     auto& engine(mFlinger->getRenderEngine());
     if (!engine.isCurrent()) {
         ALOGE("RenderEngine is not current");
         return INVALID_OPERATION;
     }
     engine.checkErrors();

     // TODO(marissaw): once buffers are cached, don't create a new image everytime
     mTextureImage = engine.createImage();

     // Reject if the layer is invalid
     uint32_t bufferWidth = s.buffer->width;
     uint32_t bufferHeight = s.buffer->height;

     if (s.transform & ui::Transform::ROT_90) {
         std::swap(bufferWidth, bufferHeight);
     }

     if (s.transformToDisplayInverse) {
         uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform();
         if (invTransform & ui::Transform::ROT_90) {
             std::swap(bufferWidth, bufferHeight);
         }
     }

     if (mOverrideScalingMode == NATIVE_WINDOW_SCALING_MODE_FREEZE &&
         (s.active.w != bufferWidth || s.active.h != bufferHeight)) {
         ALOGE("[%s] rejecting buffer: "
               "bufferWidth=%d, bufferHeight=%d, front.active.{w=%d, h=%d}",
               mName.string(), bufferWidth, bufferHeight, s.active.w, s.active.h);
         mTimeStats.removeTimeRecord(getName().c_str(), getFrameNumber());
         return BAD_VALUE;
     }

     // Handle sync fences
     if (SyncFeatures::getInstance().useNativeFenceSync()) {
         base::unique_fd fenceFd = engine.flush();
         if (fenceFd == -1) {
             ALOGE("failed to flush RenderEngine");
             mTimeStats.clearLayerRecord(getName().c_str());
             return UNKNOWN_ERROR;
         }

         sp<Fence> fence(new Fence(std::move(fenceFd)));

         // Check status of fences first because merging is expensive.
         // Merging an invalid fence with any other fence results in an
         // invalid fence.
         auto currentStatus = s.acquireFence->getStatus();
         if (currentStatus == Fence::Status::Invalid) {
             ALOGE("Existing fence has invalid state");
             mTimeStats.clearLayerRecord(getName().c_str());
             return BAD_VALUE;
         }

         auto incomingStatus = fence->getStatus();
         if (incomingStatus == Fence::Status::Invalid) {
             ALOGE("New fence has invalid state");
             mDrawingState.acquireFence = fence;
             mTimeStats.clearLayerRecord(getName().c_str());
             return BAD_VALUE;
         }

         // If both fences are signaled or both are unsignaled, we need to merge
         // them to get an accurate timestamp.
         if (currentStatus == incomingStatus) {
             char fenceName[32] = {};
             snprintf(fenceName, 32, "%.28s:%d", mName.string(), mFrameNumber);
             sp<Fence> mergedFence = Fence::merge(fenceName, mDrawingState.acquireFence, fence);
             if (!mergedFence.get()) {
                 ALOGE("failed to merge release fences");
                 // synchronization is broken, the best we can do is hope fences
                 // signal in order so the new fence will act like a union
                 mDrawingState.acquireFence = fence;
                 mTimeStats.clearLayerRecord(getName().c_str());
                 return BAD_VALUE;
             }
             mDrawingState.acquireFence = mergedFence;
         } else if (incomingStatus == Fence::Status::Unsignaled) {
             // If one fence has signaled and the other hasn't, the unsignaled
             // fence will approximately correspond with the correct timestamp.
             // There's a small race if both fences signal at about the same time
             // and their statuses are retrieved with unfortunate timing. However,
             // by this point, they will have both signaled and only the timestamp
             // will be slightly off; any dependencies after this point will
             // already have been met.
             mDrawingState.acquireFence = fence;
         }
     } else {
         // Bind the new buffer to the GL texture.
         //
         // Older devices require the "implicit" synchronization provided
         // by glEGLImageTargetTexture2DOES, which this method calls.  Newer
         // devices will either call this in Layer::onDraw, or (if it's not
         // a GL-composited layer) not at all.
         status_t err = bindTextureImage();
         if (err != NO_ERROR) {
             mTimeStats.clearLayerRecord(getName().c_str());
             return BAD_VALUE;
         }
     }

     // TODO(marissaw): properly support mTimeStats
     const std::string layerName(getName().c_str());
     mTimeStats.setPostTime(getName().c_str(), getFrameNumber(), latchTime);
     mTimeStats.setAcquireFence(layerName, getFrameNumber(), getCurrentFenceTime());
     mTimeStats.setLatchTime(layerName, getFrameNumber(), latchTime);

     return NO_ERROR;
 }

 status_t BufferStateLayer::updateActiveBuffer() {
     const State& s(getDrawingState());

     if (s.buffer == nullptr) {
         return BAD_VALUE;
     }

     mActiveBuffer = s.buffer;
     getBE().compositionInfo.mBuffer = mActiveBuffer;
     getBE().compositionInfo.mBufferSlot = 0;

     return NO_ERROR;
 }

 status_t BufferStateLayer::updateFrameNumber(nsecs_t /*latchTime*/) {
     // TODO(marissaw): support frame history events
     mCurrentFrameNumber = mFrameNumber;
     return NO_ERROR;
 }

 void BufferStateLayer::setHwcLayerBuffer(const sp<const DisplayDevice>& display) {
     const auto displayId = display->getId();
     auto& hwcInfo = getBE().mHwcLayers[displayId];
     auto& hwcLayer = hwcInfo.layer;

     const State& s(getDrawingState());

     // TODO(marissaw): support more than one slot
     uint32_t hwcSlot = 0;

     auto error = hwcLayer->setBuffer(hwcSlot, s.buffer, s.acquireFence);
     if (error != HWC2::Error::None) {
         ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
               s.buffer->handle, to_string(error).c_str(), static_cast<int32_t>(error));
     }

     mFrameNumber++;
 }

 void BufferStateLayer::onFirstRef() {
     BufferLayer::onFirstRef();

     if (const auto display = mFlinger->getDefaultDisplayDevice()) {
         updateTransformHint(display);
     }
 }

 } // namespace android
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	//#define LOG_NDEBUG 0
	#undef LOG_TAG
	#define LOG_TAG "BufferStateLayer"
	#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include "BufferStateLayer.h"
	#include "RenderEngine/Image.h"

	#include <private/gui/SyncFeatures.h>

	namespace android {

	static const std::array<float, 16> IDENTITY_MATRIX{1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1};

	BufferStateLayer::BufferStateLayer(SurfaceFlinger* flinger, const sp<Client>& client,
	const String8& name, uint32_t w, uint32_t h, uint32_t flags)
	: BufferLayer(flinger, client, name, w, h, flags),
	mSidebandStreamChanged(false),
	mFrameNumber(0) {
	mTransformMatrix = IDENTITY_MATRIX;
	}

	// -----------------------------------------------------------------------
	// Interface implementation for Layer
	// -----------------------------------------------------------------------
	void BufferStateLayer::onLayerDisplayed(const sp<Fence>& /releaseFence/) {
	// TODO(marissaw): send the release fence back to buffer owner
	return;
	}

	void BufferStateLayer::setTransformHint(uint32_t /orientation/) const {
	// TODO(marissaw): send the transform hint to buffer owner
	return;
	}

	void BufferStateLayer::releasePendingBuffer(nsecs_t /dequeueReadyTime/) {
	// TODO(marissaw): use this to signal the buffer owner
	return;
	}

	bool BufferStateLayer::shouldPresentNow(const DispSync& /dispSync/) const {
	if (getSidebandStreamChanged() \|\| getAutoRefresh()) {
	return true;
	}

	return hasDrawingBuffer();
	}

	bool BufferStateLayer::getTransformToDisplayInverse() const {
	return mCurrentState.transformToDisplayInverse;
	}

	void BufferStateLayer::pushPendingState() {
	if (!mCurrentState.modified) {
	return;
	}
	mPendingStates.push_back(mCurrentState);
	ATRACE_INT(mTransactionName.string(), mPendingStates.size());
	}

	bool BufferStateLayer::applyPendingStates(Layer::State* stateToCommit) {
	const bool stateUpdateAvailable = !mPendingStates.empty();
	while (!mPendingStates.empty()) {
	popPendingState(stateToCommit);
	}
	mCurrentState.modified = false;
	return stateUpdateAvailable;
	}

	Rect BufferStateLayer::getCrop(const Layer::State& s) const {
	return (getEffectiveScalingMode() == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)
	? GLConsumer::scaleDownCrop(s.crop, s.active.w, s.active.h)
	: s.crop;
	}

	bool BufferStateLayer::setTransform(uint32_t transform) {
	if (mCurrentState.transform == transform) return false;
	mCurrentState.sequence++;
	mCurrentState.transform = transform;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setTransformToDisplayInverse(bool transformToDisplayInverse) {
	if (mCurrentState.transformToDisplayInverse == transformToDisplayInverse) return false;
	mCurrentState.sequence++;
	mCurrentState.transformToDisplayInverse = transformToDisplayInverse;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setCrop(const Rect& crop) {
	if (mCurrentState.crop == crop) return false;
	mCurrentState.sequence++;
	mCurrentState.crop = crop;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setBuffer(sp<GraphicBuffer> buffer) {
	mCurrentState.sequence++;
	mCurrentState.buffer = buffer;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setAcquireFence(const sp<Fence>& fence) {
	mCurrentState.acquireFence = fence;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setDataspace(ui::Dataspace dataspace) {
	if (mCurrentState.dataspace == dataspace) return false;
	mCurrentState.sequence++;
	mCurrentState.dataspace = dataspace;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setHdrMetadata(const HdrMetadata& hdrMetadata) {
	if (mCurrentState.hdrMetadata == hdrMetadata) return false;
	mCurrentState.sequence++;
	mCurrentState.hdrMetadata = hdrMetadata;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setSurfaceDamageRegion(const Region& surfaceDamage) {
	mCurrentState.sequence++;
	mCurrentState.surfaceDamageRegion = surfaceDamage;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setApi(int32_t api) {
	if (mCurrentState.api == api) return false;
	mCurrentState.sequence++;
	mCurrentState.api = api;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setSidebandStream(const sp<NativeHandle>& sidebandStream) {
	if (mCurrentState.sidebandStream == sidebandStream) return false;
	mCurrentState.sequence++;
	mCurrentState.sidebandStream = sidebandStream;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);

	if (!mSidebandStreamChanged.exchange(true)) {
	// mSidebandStreamChanged was false
	mFlinger->signalLayerUpdate();
	}
	return true;
	}

	bool BufferStateLayer::setSize(uint32_t w, uint32_t h) {
	if (mCurrentState.active.w == w && mCurrentState.active.h == h) return false;
	mCurrentState.active.w = w;
	mCurrentState.active.h = h;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setPosition(float x, float y, bool /immediate/) {
	if (mCurrentState.active.transform.tx() == x && mCurrentState.active.transform.ty() == y)
	return false;

	mCurrentState.active.transform.set(x, y);

	mCurrentState.sequence++;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setTransparentRegionHint(const Region& transparent) {
	mCurrentState.transparentRegionHint = transparent;
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}

	bool BufferStateLayer::setMatrix(const layer_state_t::matrix22_t& matrix,
	bool allowNonRectPreservingTransforms) {
	ui::Transform t;
	t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);

	if (!allowNonRectPreservingTransforms && !t.preserveRects()) {
	ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored");
	return false;
	}

	mCurrentState.sequence++;
	mCurrentState.active.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
	mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);
	return true;
	}
	// -----------------------------------------------------------------------

	// -----------------------------------------------------------------------
	// Interface implementation for BufferLayer
	// -----------------------------------------------------------------------
	bool BufferStateLayer::fenceHasSignaled() const {
	if (latchUnsignaledBuffers()) {
	return true;
	}

	return getDrawingState().acquireFence->getStatus() == Fence::Status::Signaled;
	}

	nsecs_t BufferStateLayer::getDesiredPresentTime() {
	// TODO(marissaw): support an equivalent to desiredPresentTime for timestats metrics
	return 0;
	}

	std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTime() const {
	return std::make_shared<FenceTime>(getDrawingState().acquireFence);
	}

	void BufferStateLayer::getDrawingTransformMatrix(float *matrix) {
	std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix), matrix);
	}

	uint32_t BufferStateLayer::getDrawingTransform() const {
	return getDrawingState().transform;
	}

	ui::Dataspace BufferStateLayer::getDrawingDataSpace() const {
	return getDrawingState().dataspace;
	}

	Rect BufferStateLayer::getDrawingCrop() const {
	return Rect::INVALID_RECT;
	}

	uint32_t BufferStateLayer::getDrawingScalingMode() const {
	return NATIVE_WINDOW_SCALING_MODE_FREEZE;
	}

	Region BufferStateLayer::getDrawingSurfaceDamage() const {
	return getDrawingState().surfaceDamageRegion;
	}

	const HdrMetadata& BufferStateLayer::getDrawingHdrMetadata() const {
	return getDrawingState().hdrMetadata;
	}

	int BufferStateLayer::getDrawingApi() const {
	return getDrawingState().api;
	}

	PixelFormat BufferStateLayer::getPixelFormat() const {
	return mActiveBuffer->format;
	}

	uint64_t BufferStateLayer::getFrameNumber() const {
	return mFrameNumber;
	}

	bool BufferStateLayer::getAutoRefresh() const {
	// TODO(marissaw): support shared buffer mode
	return false;
	}

	bool BufferStateLayer::getSidebandStreamChanged() const {
	return mSidebandStreamChanged.load();
	}

	std::optional<Region> BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
	if (mSidebandStreamChanged.exchange(false)) {
	const State& s(getDrawingState());
	// mSidebandStreamChanged was true
	// replicated in LayerBE until FE/BE is ready to be synchronized
	getBE().compositionInfo.hwc.sidebandStream = s.sidebandStream;
	if (getBE().compositionInfo.hwc.sidebandStream != nullptr) {
	setTransactionFlags(eTransactionNeeded);
	mFlinger->setTransactionFlags(eTraversalNeeded);
	}
	recomputeVisibleRegions = true;

	return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
	}
	return {};
	}

	bool BufferStateLayer::hasDrawingBuffer() const {
	return getDrawingState().buffer != nullptr;
	}

	void BufferStateLayer::setFilteringEnabled(bool enabled) {
	GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mCurrentCrop,
	mCurrentTransform, enabled);
	}

	status_t BufferStateLayer::bindTextureImage() const {
	const State& s(getDrawingState());
	auto& engine(mFlinger->getRenderEngine());

	if (!engine.isCurrent()) {
	ALOGE("RenderEngine is not current");
	return INVALID_OPERATION;
	}

	engine.checkErrors();

	if (!mTextureImage) {
	ALOGE("no currently-bound texture");
	engine.bindExternalTextureImage(mTextureName, *engine.createImage());
	return NO_INIT;
	}

	bool created =
	mTextureImage->setNativeWindowBuffer(s.buffer->getNativeBuffer(),
	s.buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
	if (!created) {
	ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
	s.buffer->getWidth(), s.buffer->getHeight(), s.buffer->getStride(),
	s.buffer->getUsage(), s.buffer->getPixelFormat());
	engine.bindExternalTextureImage(mTextureName, *engine.createImage());
	return NO_INIT;
	}

	engine.bindExternalTextureImage(mTextureName, *mTextureImage);

	// Wait for the new buffer to be ready.
	if (s.acquireFence->isValid()) {
	if (SyncFeatures::getInstance().useWaitSync()) {
	base::unique_fd fenceFd(s.acquireFence->dup());
	if (fenceFd == -1) {
	ALOGE("error dup'ing fence fd: %d", errno);
	return -errno;
	}
	if (!engine.waitFence(std::move(fenceFd))) {
	ALOGE("failed to wait on fence fd");
	return UNKNOWN_ERROR;
	}
	} else {
	status_t err = s.acquireFence->waitForever("BufferStateLayer::bindTextureImage");
	if (err != NO_ERROR) {
	ALOGE("error waiting for fence: %d", err);
	return err;
	}
	}
	}

	return NO_ERROR;
	}

	status_t BufferStateLayer::updateTexImage(bool& /recomputeVisibleRegions/, nsecs_t latchTime) {
	const State& s(getDrawingState());

	if (!s.buffer) {
	return NO_ERROR;
	}

	auto& engine(mFlinger->getRenderEngine());
	if (!engine.isCurrent()) {
	ALOGE("RenderEngine is not current");
	return INVALID_OPERATION;
	}
	engine.checkErrors();

	// TODO(marissaw): once buffers are cached, don't create a new image everytime
	mTextureImage = engine.createImage();

	// Reject if the layer is invalid
	uint32_t bufferWidth = s.buffer->width;
	uint32_t bufferHeight = s.buffer->height;

	if (s.transform & ui::Transform::ROT_90) {
	std::swap(bufferWidth, bufferHeight);
	}

	if (s.transformToDisplayInverse) {
	uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform();
	if (invTransform & ui::Transform::ROT_90) {
	std::swap(bufferWidth, bufferHeight);
	}
	}

	if (mOverrideScalingMode == NATIVE_WINDOW_SCALING_MODE_FREEZE &&
	(s.active.w != bufferWidth \|\| s.active.h != bufferHeight)) {
	ALOGE("[%s] rejecting buffer: "
	"bufferWidth=%d, bufferHeight=%d, front.active.{w=%d, h=%d}",
	mName.string(), bufferWidth, bufferHeight, s.active.w, s.active.h);
	mTimeStats.removeTimeRecord(getName().c_str(), getFrameNumber());
	return BAD_VALUE;
	}

	// Handle sync fences
	if (SyncFeatures::getInstance().useNativeFenceSync()) {
	base::unique_fd fenceFd = engine.flush();
	if (fenceFd == -1) {
	ALOGE("failed to flush RenderEngine");
	mTimeStats.clearLayerRecord(getName().c_str());
	return UNKNOWN_ERROR;
	}

	sp<Fence> fence(new Fence(std::move(fenceFd)));

	// Check status of fences first because merging is expensive.
	// Merging an invalid fence with any other fence results in an
	// invalid fence.
	auto currentStatus = s.acquireFence->getStatus();
	if (currentStatus == Fence::Status::Invalid) {
	ALOGE("Existing fence has invalid state");
	mTimeStats.clearLayerRecord(getName().c_str());
	return BAD_VALUE;
	}

	auto incomingStatus = fence->getStatus();
	if (incomingStatus == Fence::Status::Invalid) {
	ALOGE("New fence has invalid state");
	mDrawingState.acquireFence = fence;
	mTimeStats.clearLayerRecord(getName().c_str());
	return BAD_VALUE;
	}

	// If both fences are signaled or both are unsignaled, we need to merge
	// them to get an accurate timestamp.
	if (currentStatus == incomingStatus) {
	char fenceName[32] = {};
	snprintf(fenceName, 32, "%.28s:%d", mName.string(), mFrameNumber);
	sp<Fence> mergedFence = Fence::merge(fenceName, mDrawingState.acquireFence, fence);
	if (!mergedFence.get()) {
	ALOGE("failed to merge release fences");
	// synchronization is broken, the best we can do is hope fences
	// signal in order so the new fence will act like a union
	mDrawingState.acquireFence = fence;
	mTimeStats.clearLayerRecord(getName().c_str());
	return BAD_VALUE;
	}
	mDrawingState.acquireFence = mergedFence;
	} else if (incomingStatus == Fence::Status::Unsignaled) {
	// If one fence has signaled and the other hasn't, the unsignaled
	// fence will approximately correspond with the correct timestamp.
	// There's a small race if both fences signal at about the same time
	// and their statuses are retrieved with unfortunate timing. However,
	// by this point, they will have both signaled and only the timestamp
	// will be slightly off; any dependencies after this point will
	// already have been met.
	mDrawingState.acquireFence = fence;
	}
	} else {
	// Bind the new buffer to the GL texture.
	//
	// Older devices require the "implicit" synchronization provided
	// by glEGLImageTargetTexture2DOES, which this method calls. Newer
	// devices will either call this in Layer::onDraw, or (if it's not
	// a GL-composited layer) not at all.
	status_t err = bindTextureImage();
	if (err != NO_ERROR) {
	mTimeStats.clearLayerRecord(getName().c_str());
	return BAD_VALUE;
	}
	}

	// TODO(marissaw): properly support mTimeStats
	const std::string layerName(getName().c_str());
	mTimeStats.setPostTime(getName().c_str(), getFrameNumber(), latchTime);
	mTimeStats.setAcquireFence(layerName, getFrameNumber(), getCurrentFenceTime());
	mTimeStats.setLatchTime(layerName, getFrameNumber(), latchTime);

	return NO_ERROR;
	}

	status_t BufferStateLayer::updateActiveBuffer() {
	const State& s(getDrawingState());

	if (s.buffer == nullptr) {
	return BAD_VALUE;
	}

	mActiveBuffer = s.buffer;
	getBE().compositionInfo.mBuffer = mActiveBuffer;
	getBE().compositionInfo.mBufferSlot = 0;

	return NO_ERROR;
	}

	status_t BufferStateLayer::updateFrameNumber(nsecs_t /latchTime/) {
	// TODO(marissaw): support frame history events
	mCurrentFrameNumber = mFrameNumber;
	return NO_ERROR;
	}

	void BufferStateLayer::setHwcLayerBuffer(const sp<const DisplayDevice>& display) {
	const auto displayId = display->getId();
	auto& hwcInfo = getBE().mHwcLayers[displayId];
	auto& hwcLayer = hwcInfo.layer;

	const State& s(getDrawingState());

	// TODO(marissaw): support more than one slot
	uint32_t hwcSlot = 0;

	auto error = hwcLayer->setBuffer(hwcSlot, s.buffer, s.acquireFence);
	if (error != HWC2::Error::None) {
	ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
	s.buffer->handle, to_string(error).c_str(), static_cast<int32_t>(error));
	}

	mFrameNumber++;
	}

	void BufferStateLayer::onFirstRef() {
	BufferLayer::onFirstRef();

	if (const auto display = mFlinger->getDefaultDisplayDevice()) {
	updateTransformHint(display);
	}
	}

	} // namespace android