/* * Copyright (C) 2007 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 "Layer" #define ATRACE_TAG ATRACE_TAG_GRAPHICS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "clz.h" #include "Colorizer.h" #include "DisplayDevice.h" #include "Layer.h" #include "MonitoredProducer.h" #include "SurfaceFlinger.h" #include "DisplayHardware/HWComposer.h" #include "RenderEngine/RenderEngine.h" #define DEBUG_RESIZE 0 namespace android { // --------------------------------------------------------------------------- int32_t Layer::sSequence = 1; Layer::Layer(SurfaceFlinger* flinger, const sp& client, const String8& name, uint32_t w, uint32_t h, uint32_t flags) : contentDirty(false), sequence(uint32_t(android_atomic_inc(&sSequence))), mFlinger(flinger), mTextureName(-1U), mPremultipliedAlpha(true), mName("unnamed"), mFormat(PIXEL_FORMAT_NONE), mTransactionFlags(0), mPendingStateMutex(), mPendingStates(), mQueuedFrames(0), mSidebandStreamChanged(false), mCurrentTransform(0), mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), mOverrideScalingMode(-1), mCurrentOpacity(true), mCurrentFrameNumber(0), mRefreshPending(false), mFrameLatencyNeeded(false), mFiltering(false), mNeedsFiltering(false), mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), #ifndef USE_HWC2 mIsGlesComposition(false), #endif mProtectedByApp(false), mHasSurface(false), mClientRef(client), mPotentialCursor(false), mQueueItemLock(), mQueueItemCondition(), mQueueItems(), mLastFrameNumberReceived(0), mUpdateTexImageFailed(false), mAutoRefresh(false), mFreezePositionUpdates(false) { #ifdef USE_HWC2 ALOGV("Creating Layer %s", name.string()); #endif mCurrentCrop.makeInvalid(); mFlinger->getRenderEngine().genTextures(1, &mTextureName); mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); uint32_t layerFlags = 0; if (flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden; if (flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque; if (flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure; if (flags & ISurfaceComposerClient::eNonPremultiplied) mPremultipliedAlpha = false; mName = name; mCurrentState.active.w = w; mCurrentState.active.h = h; mCurrentState.active.transform.set(0, 0); mCurrentState.crop.makeInvalid(); mCurrentState.finalCrop.makeInvalid(); mCurrentState.z = 0; #ifdef USE_HWC2 mCurrentState.alpha = 1.0f; #else mCurrentState.alpha = 0xFF; #endif mCurrentState.layerStack = 0; mCurrentState.flags = layerFlags; mCurrentState.sequence = 0; mCurrentState.requested = mCurrentState.active; // drawing state & current state are identical mDrawingState = mCurrentState; #ifdef USE_HWC2 const auto& hwc = flinger->getHwComposer(); const auto& activeConfig = hwc.getActiveConfig(HWC_DISPLAY_PRIMARY); nsecs_t displayPeriod = activeConfig->getVsyncPeriod(); #else nsecs_t displayPeriod = flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); #endif mFrameTracker.setDisplayRefreshPeriod(displayPeriod); } void Layer::onFirstRef() { // Creates a custom BufferQueue for SurfaceFlingerConsumer to use sp producer; sp consumer; BufferQueue::createBufferQueue(&producer, &consumer); mProducer = new MonitoredProducer(producer, mFlinger); mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName); mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); mSurfaceFlingerConsumer->setContentsChangedListener(this); mSurfaceFlingerConsumer->setName(mName); #ifdef TARGET_DISABLE_TRIPLE_BUFFERING #warning "disabling triple buffering" #else mProducer->setMaxDequeuedBufferCount(2); #endif const sp hw(mFlinger->getDefaultDisplayDevice()); updateTransformHint(hw); } Layer::~Layer() { sp c(mClientRef.promote()); if (c != 0) { c->detachLayer(this); } for (auto& point : mRemoteSyncPoints) { point->setTransactionApplied(); } for (auto& point : mLocalSyncPoints) { point->setFrameAvailable(); } mFlinger->deleteTextureAsync(mTextureName); mFrameTracker.logAndResetStats(mName); } // --------------------------------------------------------------------------- // callbacks // --------------------------------------------------------------------------- #ifdef USE_HWC2 void Layer::onLayerDisplayed(const sp& releaseFence) { if (mHwcLayers.empty()) { return; } mSurfaceFlingerConsumer->setReleaseFence(releaseFence); } #else void Layer::onLayerDisplayed(const sp& /* hw */, HWComposer::HWCLayerInterface* layer) { if (layer) { layer->onDisplayed(); mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); } } #endif void Layer::onFrameAvailable(const BufferItem& item) { // Add this buffer from our internal queue tracker { // Autolock scope Mutex::Autolock lock(mQueueItemLock); // Reset the frame number tracker when we receive the first buffer after // a frame number reset if (item.mFrameNumber == 1) { mLastFrameNumberReceived = 0; } // Ensure that callbacks are handled in order while (item.mFrameNumber != mLastFrameNumberReceived + 1) { status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); if (result != NO_ERROR) { ALOGE("[%s] Timed out waiting on callback", mName.string()); } } mQueueItems.push_back(item); android_atomic_inc(&mQueuedFrames); // Wake up any pending callbacks mLastFrameNumberReceived = item.mFrameNumber; mQueueItemCondition.broadcast(); } mFlinger->signalLayerUpdate(); } void Layer::onFrameReplaced(const BufferItem& item) { { // Autolock scope Mutex::Autolock lock(mQueueItemLock); // Ensure that callbacks are handled in order while (item.mFrameNumber != mLastFrameNumberReceived + 1) { status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); if (result != NO_ERROR) { ALOGE("[%s] Timed out waiting on callback", mName.string()); } } if (mQueueItems.empty()) { ALOGE("Can't replace a frame on an empty queue"); return; } mQueueItems.editItemAt(mQueueItems.size() - 1) = item; // Wake up any pending callbacks mLastFrameNumberReceived = item.mFrameNumber; mQueueItemCondition.broadcast(); } } void Layer::onSidebandStreamChanged() { if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { // mSidebandStreamChanged was false mFlinger->signalLayerUpdate(); } } // called with SurfaceFlinger::mStateLock from the drawing thread after // the layer has been remove from the current state list (and just before // it's removed from the drawing state list) void Layer::onRemoved() { mSurfaceFlingerConsumer->abandon(); } // --------------------------------------------------------------------------- // set-up // --------------------------------------------------------------------------- const String8& Layer::getName() const { return mName; } status_t Layer::setBuffers( uint32_t w, uint32_t h, PixelFormat format, uint32_t flags) { uint32_t const maxSurfaceDims = min( mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); // never allow a surface larger than what our underlying GL implementation // can handle. if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); return BAD_VALUE; } mFormat = format; mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; mCurrentOpacity = getOpacityForFormat(format); mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); mSurfaceFlingerConsumer->setDefaultBufferFormat(format); mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); return NO_ERROR; } /* * The layer handle is just a BBinder object passed to the client * (remote process) -- we don't keep any reference on our side such that * the dtor is called when the remote side let go of its reference. * * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for * this layer when the handle is destroyed. */ class Layer::Handle : public BBinder, public LayerCleaner { public: Handle(const sp& flinger, const sp& layer) : LayerCleaner(flinger, layer), owner(layer) {} wp owner; }; sp Layer::getHandle() { Mutex::Autolock _l(mLock); LOG_ALWAYS_FATAL_IF(mHasSurface, "Layer::getHandle() has already been called"); mHasSurface = true; return new Handle(mFlinger, this); } sp Layer::getProducer() const { return mProducer; } // --------------------------------------------------------------------------- // h/w composer set-up // --------------------------------------------------------------------------- Rect Layer::getContentCrop() const { // this is the crop rectangle that applies to the buffer // itself (as opposed to the window) Rect crop; if (!mCurrentCrop.isEmpty()) { // if the buffer crop is defined, we use that crop = mCurrentCrop; } else if (mActiveBuffer != NULL) { // otherwise we use the whole buffer crop = mActiveBuffer->getBounds(); } else { // if we don't have a buffer yet, we use an empty/invalid crop crop.makeInvalid(); } return crop; } static Rect reduce(const Rect& win, const Region& exclude) { if (CC_LIKELY(exclude.isEmpty())) { return win; } if (exclude.isRect()) { return win.reduce(exclude.getBounds()); } return Region(win).subtract(exclude).getBounds(); } Rect Layer::computeBounds() const { const Layer::State& s(getDrawingState()); return computeBounds(s.activeTransparentRegion); } Rect Layer::computeBounds(const Region& activeTransparentRegion) const { const Layer::State& s(getDrawingState()); Rect win(s.active.w, s.active.h); if (!s.crop.isEmpty()) { win.intersect(s.crop, &win); } // subtract the transparent region and snap to the bounds return reduce(win, activeTransparentRegion); } FloatRect Layer::computeCrop(const sp& hw) const { // the content crop is the area of the content that gets scaled to the // layer's size. FloatRect crop(getContentCrop()); // the crop is the area of the window that gets cropped, but not // scaled in any ways. const State& s(getDrawingState()); // apply the projection's clipping to the window crop in // layerstack space, and convert-back to layer space. // if there are no window scaling involved, this operation will map to full // pixels in the buffer. // FIXME: the 3 lines below can produce slightly incorrect clipping when we have // a viewport clipping and a window transform. we should use floating point to fix this. Rect activeCrop(s.active.w, s.active.h); if (!s.crop.isEmpty()) { activeCrop = s.crop; } activeCrop = s.active.transform.transform(activeCrop); if (!activeCrop.intersect(hw->getViewport(), &activeCrop)) { activeCrop.clear(); } if (!s.finalCrop.isEmpty()) { if(!activeCrop.intersect(s.finalCrop, &activeCrop)) { activeCrop.clear(); } } activeCrop = s.active.transform.inverse().transform(activeCrop); // This needs to be here as transform.transform(Rect) computes the // transformed rect and then takes the bounding box of the result before // returning. This means // transform.inverse().transform(transform.transform(Rect)) != Rect // in which case we need to make sure the final rect is clipped to the // display bounds. if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { activeCrop.clear(); } // subtract the transparent region and snap to the bounds activeCrop = reduce(activeCrop, s.activeTransparentRegion); // Transform the window crop to match the buffer coordinate system, // which means using the inverse of the current transform set on the // SurfaceFlingerConsumer. uint32_t invTransform = mCurrentTransform; if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { /* * the code below applies the primary display's inverse transform to the * buffer */ uint32_t invTransformOrient = DisplayDevice::getPrimaryDisplayOrientationTransform(); // calculate the inverse transform if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) { invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_FLIP_H; } // and apply to the current transform invTransform = (Transform(invTransformOrient) * Transform(invTransform)) .getOrientation(); } int winWidth = s.active.w; int winHeight = s.active.h; if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { // If the activeCrop has been rotate the ends are rotated but not // the space itself so when transforming ends back we can't rely on // a modification of the axes of rotation. To account for this we // need to reorient the inverse rotation in terms of the current // axes of rotation. bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; if (is_h_flipped == is_v_flipped) { invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_FLIP_H; } winWidth = s.active.h; winHeight = s.active.w; } const Rect winCrop = activeCrop.transform( invTransform, s.active.w, s.active.h); // below, crop is intersected with winCrop expressed in crop's coordinate space float xScale = crop.getWidth() / float(winWidth); float yScale = crop.getHeight() / float(winHeight); float insetL = winCrop.left * xScale; float insetT = winCrop.top * yScale; float insetR = (winWidth - winCrop.right ) * xScale; float insetB = (winHeight - winCrop.bottom) * yScale; crop.left += insetL; crop.top += insetT; crop.right -= insetR; crop.bottom -= insetB; return crop; } #ifdef USE_HWC2 void Layer::setGeometry(const sp& displayDevice) #else void Layer::setGeometry( const sp& hw, HWComposer::HWCLayerInterface& layer) #endif { #ifdef USE_HWC2 const auto hwcId = displayDevice->getHwcDisplayId(); auto& hwcInfo = mHwcLayers[hwcId]; #else layer.setDefaultState(); #endif // enable this layer #ifdef USE_HWC2 hwcInfo.forceClientComposition = false; if (isSecure() && !displayDevice->isSecure()) { hwcInfo.forceClientComposition = true; } auto& hwcLayer = hwcInfo.layer; #else layer.setSkip(false); if (isSecure() && !hw->isSecure()) { layer.setSkip(true); } #endif // this gives us only the "orientation" component of the transform const State& s(getDrawingState()); #ifdef USE_HWC2 if (!isOpaque(s) || s.alpha != 1.0f) { auto blendMode = mPremultipliedAlpha ? HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage; auto error = hwcLayer->setBlendMode(blendMode); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set blend mode %s:" " %s (%d)", mName.string(), to_string(blendMode).c_str(), to_string(error).c_str(), static_cast(error)); } #else if (!isOpaque(s) || s.alpha != 0xFF) { layer.setBlending(mPremultipliedAlpha ? HWC_BLENDING_PREMULT : HWC_BLENDING_COVERAGE); } #endif // apply the layer's transform, followed by the display's global transform // here we're guaranteed that the layer's transform preserves rects Region activeTransparentRegion(s.activeTransparentRegion); if (!s.crop.isEmpty()) { Rect activeCrop(s.crop); activeCrop = s.active.transform.transform(activeCrop); #ifdef USE_HWC2 if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) { #else if(!activeCrop.intersect(hw->getViewport(), &activeCrop)) { #endif activeCrop.clear(); } activeCrop = s.active.transform.inverse().transform(activeCrop); // This needs to be here as transform.transform(Rect) computes the // transformed rect and then takes the bounding box of the result before // returning. This means // transform.inverse().transform(transform.transform(Rect)) != Rect // in which case we need to make sure the final rect is clipped to the // display bounds. if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { activeCrop.clear(); } // mark regions outside the crop as transparent activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, s.active.w, s.active.h)); activeTransparentRegion.orSelf(Rect(0, activeCrop.top, activeCrop.left, activeCrop.bottom)); activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, s.active.w, activeCrop.bottom)); } Rect frame(s.active.transform.transform(computeBounds(activeTransparentRegion))); if (!s.finalCrop.isEmpty()) { if(!frame.intersect(s.finalCrop, &frame)) { frame.clear(); } } #ifdef USE_HWC2 if (!frame.intersect(displayDevice->getViewport(), &frame)) { frame.clear(); } const Transform& tr(displayDevice->getTransform()); Rect transformedFrame = tr.transform(frame); auto error = hwcLayer->setDisplayFrame(transformedFrame); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set display frame " "[%d, %d, %d, %d]: %s (%d)", mName.string(), transformedFrame.left, transformedFrame.top, transformedFrame.right, transformedFrame.bottom, to_string(error).c_str(), static_cast(error)); FloatRect sourceCrop = computeCrop(displayDevice); error = hwcLayer->setSourceCrop(sourceCrop); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set source crop " "[%.3f, %.3f, %.3f, %.3f]: %s (%d)", mName.string(), sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom, to_string(error).c_str(), static_cast(error)); error = hwcLayer->setPlaneAlpha(s.alpha); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: " "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(), static_cast(error)); error = hwcLayer->setZOrder(s.z); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)", mName.string(), s.z, to_string(error).c_str(), static_cast(error)); #else if (!frame.intersect(hw->getViewport(), &frame)) { frame.clear(); } const Transform& tr(hw->getTransform()); layer.setFrame(tr.transform(frame)); layer.setCrop(computeCrop(hw)); layer.setPlaneAlpha(s.alpha); #endif /* * Transformations are applied in this order: * 1) buffer orientation/flip/mirror * 2) state transformation (window manager) * 3) layer orientation (screen orientation) * (NOTE: the matrices are multiplied in reverse order) */ const Transform bufferOrientation(mCurrentTransform); Transform transform(tr * s.active.transform * bufferOrientation); if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { /* * the code below applies the primary display's inverse transform to the * buffer */ uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform(); // calculate the inverse transform if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_FLIP_H; } // and apply to the current transform transform = Transform(invTransform) * transform; } // this gives us only the "orientation" component of the transform const uint32_t orientation = transform.getOrientation(); #ifdef USE_HWC2 if (orientation & Transform::ROT_INVALID) { // we can only handle simple transformation hwcInfo.forceClientComposition = true; } else { auto transform = static_cast(orientation); auto error = hwcLayer->setTransform(transform); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: " "%s (%d)", mName.string(), to_string(transform).c_str(), to_string(error).c_str(), static_cast(error)); } #else if (orientation & Transform::ROT_INVALID) { // we can only handle simple transformation layer.setSkip(true); } else { layer.setTransform(orientation); } #endif } #ifdef USE_HWC2 void Layer::forceClientComposition(int32_t hwcId) { if (mHwcLayers.count(hwcId) == 0) { ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId); return; } mHwcLayers[hwcId].forceClientComposition = true; } #endif #ifdef USE_HWC2 void Layer::setPerFrameData(const sp& displayDevice) { // Apply this display's projection's viewport to the visible region // before giving it to the HWC HAL. const Transform& tr = displayDevice->getTransform(); const auto& viewport = displayDevice->getViewport(); Region visible = tr.transform(visibleRegion.intersect(viewport)); auto hwcId = displayDevice->getHwcDisplayId(); auto& hwcLayer = mHwcLayers[hwcId].layer; auto error = hwcLayer->setVisibleRegion(visible); if (error != HWC2::Error::None) { ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), to_string(error).c_str(), static_cast(error)); visible.dump(LOG_TAG); } error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); if (error != HWC2::Error::None) { ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), to_string(error).c_str(), static_cast(error)); surfaceDamageRegion.dump(LOG_TAG); } // Sideband layers if (mSidebandStream.get()) { setCompositionType(hwcId, HWC2::Composition::Sideband); ALOGV("[%s] Requesting Sideband composition", mName.string()); error = hwcLayer->setSidebandStream(mSidebandStream->handle()); if (error != HWC2::Error::None) { ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(), mSidebandStream->handle(), to_string(error).c_str(), static_cast(error)); } return; } // Client or SolidColor layers if (mActiveBuffer == nullptr || mActiveBuffer->handle == nullptr || mHwcLayers[hwcId].forceClientComposition) { // TODO: This also includes solid color layers, but no API exists to // setup a solid color layer yet ALOGV("[%s] Requesting Client composition", mName.string()); setCompositionType(hwcId, HWC2::Composition::Client); error = hwcLayer->setBuffer(nullptr, Fence::NO_FENCE); if (error != HWC2::Error::None) { ALOGE("[%s] Failed to set null buffer: %s (%d)", mName.string(), to_string(error).c_str(), static_cast(error)); } return; } // Device or Cursor layers if (mPotentialCursor) { ALOGV("[%s] Requesting Cursor composition", mName.string()); setCompositionType(hwcId, HWC2::Composition::Cursor); } else { ALOGV("[%s] Requesting Device composition", mName.string()); setCompositionType(hwcId, HWC2::Composition::Device); } auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence(); error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence); if (error != HWC2::Error::None) { ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), mActiveBuffer->handle, to_string(error).c_str(), static_cast(error)); } } #else void Layer::setPerFrameData(const sp& hw, HWComposer::HWCLayerInterface& layer) { // we have to set the visible region on every frame because // we currently free it during onLayerDisplayed(), which is called // after HWComposer::commit() -- every frame. // Apply this display's projection's viewport to the visible region // before giving it to the HWC HAL. const Transform& tr = hw->getTransform(); Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); layer.setVisibleRegionScreen(visible); layer.setSurfaceDamage(surfaceDamageRegion); mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER); if (mSidebandStream.get()) { layer.setSidebandStream(mSidebandStream); } else { // NOTE: buffer can be NULL if the client never drew into this // layer yet, or if we ran out of memory layer.setBuffer(mActiveBuffer); } } #endif #ifdef USE_HWC2 void Layer::updateCursorPosition(const sp& displayDevice) { auto hwcId = displayDevice->getHwcDisplayId(); if (mHwcLayers.count(hwcId) == 0 || getCompositionType(hwcId) != HWC2::Composition::Cursor) { return; } // This gives us only the "orientation" component of the transform const State& s(getCurrentState()); // Apply the layer's transform, followed by the display's global transform // Here we're guaranteed that the layer's transform preserves rects Rect win(s.active.w, s.active.h); if (!s.crop.isEmpty()) { win.intersect(s.crop, &win); } // Subtract the transparent region and snap to the bounds Rect bounds = reduce(win, s.activeTransparentRegion); Rect frame(s.active.transform.transform(bounds)); frame.intersect(displayDevice->getViewport(), &frame); if (!s.finalCrop.isEmpty()) { frame.intersect(s.finalCrop, &frame); } auto& displayTransform(displayDevice->getTransform()); auto position = displayTransform.transform(frame); auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left, position.top); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position " "to (%d, %d): %s (%d)", mName.string(), position.left, position.top, to_string(error).c_str(), static_cast(error)); } #else void Layer::setAcquireFence(const sp& /* hw */, HWComposer::HWCLayerInterface& layer) { int fenceFd = -1; // TODO: there is a possible optimization here: we only need to set the // acquire fence the first time a new buffer is acquired on EACH display. if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) { sp fence = mSurfaceFlingerConsumer->getCurrentFence(); if (fence->isValid()) { fenceFd = fence->dup(); if (fenceFd == -1) { ALOGW("failed to dup layer fence, skipping sync: %d", errno); } } } layer.setAcquireFenceFd(fenceFd); } Rect Layer::getPosition( const sp& hw) { // this gives us only the "orientation" component of the transform const State& s(getCurrentState()); // apply the layer's transform, followed by the display's global transform // here we're guaranteed that the layer's transform preserves rects Rect win(s.active.w, s.active.h); if (!s.crop.isEmpty()) { win.intersect(s.crop, &win); } // subtract the transparent region and snap to the bounds Rect bounds = reduce(win, s.activeTransparentRegion); Rect frame(s.active.transform.transform(bounds)); frame.intersect(hw->getViewport(), &frame); if (!s.finalCrop.isEmpty()) { frame.intersect(s.finalCrop, &frame); } const Transform& tr(hw->getTransform()); return Rect(tr.transform(frame)); } #endif // --------------------------------------------------------------------------- // drawing... // --------------------------------------------------------------------------- void Layer::draw(const sp& hw, const Region& clip) const { onDraw(hw, clip, false); } void Layer::draw(const sp& hw, bool useIdentityTransform) const { onDraw(hw, Region(hw->bounds()), useIdentityTransform); } void Layer::draw(const sp& hw) const { onDraw(hw, Region(hw->bounds()), false); } void Layer::onDraw(const sp& hw, const Region& clip, bool useIdentityTransform) const { ATRACE_CALL(); if (CC_UNLIKELY(mActiveBuffer == 0)) { // the texture has not been created yet, this Layer has // in fact never been drawn into. This happens frequently with // SurfaceView because the WindowManager can't know when the client // has drawn the first time. // If there is nothing under us, we paint the screen in black, otherwise // we just skip this update. // figure out if there is something below us Region under; const SurfaceFlinger::LayerVector& drawingLayers( mFlinger->mDrawingState.layersSortedByZ); const size_t count = drawingLayers.size(); for (size_t i=0 ; i& layer(drawingLayers[i]); if (layer.get() == static_cast(this)) break; under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); } // if not everything below us is covered, we plug the holes! Region holes(clip.subtract(under)); if (!holes.isEmpty()) { clearWithOpenGL(hw, holes, 0, 0, 0, 1); } return; } // Bind the current buffer to the GL texture, and wait for it to be // ready for us to draw into. status_t err = mSurfaceFlingerConsumer->bindTextureImage(); if (err != NO_ERROR) { ALOGW("onDraw: bindTextureImage failed (err=%d)", err); // Go ahead and draw the buffer anyway; no matter what we do the screen // is probably going to have something visibly wrong. } bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); RenderEngine& engine(mFlinger->getRenderEngine()); if (!blackOutLayer) { // TODO: we could be more subtle with isFixedSize() const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); // Query the texture matrix given our current filtering mode. float textureMatrix[16]; mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { /* * the code below applies the primary display's inverse transform to * the texture transform */ // create a 4x4 transform matrix from the display transform flags const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1); const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1); const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1); mat4 tr; uint32_t transform = DisplayDevice::getPrimaryDisplayOrientationTransform(); if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) tr = tr * rot90; if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) tr = tr * flipH; if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) tr = tr * flipV; // calculate the inverse tr = inverse(tr); // and finally apply it to the original texture matrix const mat4 texTransform(mat4(static_cast(textureMatrix)) * tr); memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); } // Set things up for texturing. mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); mTexture.setFiltering(useFiltering); mTexture.setMatrix(textureMatrix); engine.setupLayerTexturing(mTexture); } else { engine.setupLayerBlackedOut(); } drawWithOpenGL(hw, clip, useIdentityTransform); engine.disableTexturing(); } void Layer::clearWithOpenGL(const sp& hw, const Region& /* clip */, float red, float green, float blue, float alpha) const { RenderEngine& engine(mFlinger->getRenderEngine()); computeGeometry(hw, mMesh, false); engine.setupFillWithColor(red, green, blue, alpha); engine.drawMesh(mMesh); } void Layer::clearWithOpenGL( const sp& hw, const Region& clip) const { clearWithOpenGL(hw, clip, 0,0,0,0); } void Layer::drawWithOpenGL(const sp& hw, const Region& /* clip */, bool useIdentityTransform) const { const State& s(getDrawingState()); computeGeometry(hw, mMesh, useIdentityTransform); /* * NOTE: the way we compute the texture coordinates here produces * different results than when we take the HWC path -- in the later case * the "source crop" is rounded to texel boundaries. * This can produce significantly different results when the texture * is scaled by a large amount. * * The GL code below is more logical (imho), and the difference with * HWC is due to a limitation of the HWC API to integers -- a question * is suspend is whether we should ignore this problem or revert to * GL composition when a buffer scaling is applied (maybe with some * minimal value)? Or, we could make GL behave like HWC -- but this feel * like more of a hack. */ Rect win(computeBounds()); if (!s.finalCrop.isEmpty()) { win = s.active.transform.transform(win); if (!win.intersect(s.finalCrop, &win)) { win.clear(); } win = s.active.transform.inverse().transform(win); if (!win.intersect(computeBounds(), &win)) { win.clear(); } } float left = float(win.left) / float(s.active.w); float top = float(win.top) / float(s.active.h); float right = float(win.right) / float(s.active.w); float bottom = float(win.bottom) / float(s.active.h); // TODO: we probably want to generate the texture coords with the mesh // here we assume that we only have 4 vertices Mesh::VertexArray texCoords(mMesh.getTexCoordArray()); texCoords[0] = vec2(left, 1.0f - top); texCoords[1] = vec2(left, 1.0f - bottom); texCoords[2] = vec2(right, 1.0f - bottom); texCoords[3] = vec2(right, 1.0f - top); RenderEngine& engine(mFlinger->getRenderEngine()); engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha); engine.drawMesh(mMesh); engine.disableBlending(); } #ifdef USE_HWC2 void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, bool callIntoHwc) { if (mHwcLayers.count(hwcId) == 0) { ALOGE("setCompositionType called without a valid HWC layer"); return; } auto& hwcInfo = mHwcLayers[hwcId]; auto& hwcLayer = hwcInfo.layer; ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), to_string(type).c_str(), static_cast(callIntoHwc)); if (hwcInfo.compositionType != type) { ALOGV(" actually setting"); hwcInfo.compositionType = type; if (callIntoHwc) { auto error = hwcLayer->setCompositionType(type); ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set " "composition type %s: %s (%d)", mName.string(), to_string(type).c_str(), to_string(error).c_str(), static_cast(error)); } } } HWC2::Composition Layer::getCompositionType(int32_t hwcId) const { if (mHwcLayers.count(hwcId) == 0) { ALOGE("getCompositionType called without a valid HWC layer"); return HWC2::Composition::Invalid; } return mHwcLayers.at(hwcId).compositionType; } void Layer::setClearClientTarget(int32_t hwcId, bool clear) { if (mHwcLayers.count(hwcId) == 0) { ALOGE("setClearClientTarget called without a valid HWC layer"); return; } mHwcLayers[hwcId].clearClientTarget = clear; } bool Layer::getClearClientTarget(int32_t hwcId) const { if (mHwcLayers.count(hwcId) == 0) { ALOGE("getClearClientTarget called without a valid HWC layer"); return false; } return mHwcLayers.at(hwcId).clearClientTarget; } #endif uint32_t Layer::getProducerStickyTransform() const { int producerStickyTransform = 0; int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); if (ret != OK) { ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, strerror(-ret), ret); return 0; } return static_cast(producerStickyTransform); } uint64_t Layer::getHeadFrameNumber() const { Mutex::Autolock lock(mQueueItemLock); if (!mQueueItems.empty()) { return mQueueItems[0].mFrameNumber; } else { return mCurrentFrameNumber; } } bool Layer::addSyncPoint(const std::shared_ptr& point) { if (point->getFrameNumber() <= mCurrentFrameNumber) { // Don't bother with a SyncPoint, since we've already latched the // relevant frame return false; } Mutex::Autolock lock(mLocalSyncPointMutex); mLocalSyncPoints.push_back(point); return true; } void Layer::setFiltering(bool filtering) { mFiltering = filtering; } bool Layer::getFiltering() const { return mFiltering; } // As documented in libhardware header, formats in the range // 0x100 - 0x1FF are specific to the HAL implementation, and // are known to have no alpha channel // TODO: move definition for device-specific range into // hardware.h, instead of using hard-coded values here. #define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) bool Layer::getOpacityForFormat(uint32_t format) { if (HARDWARE_IS_DEVICE_FORMAT(format)) { return true; } switch (format) { case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_BGRA_8888: return false; } // in all other case, we have no blending (also for unknown formats) return true; } // ---------------------------------------------------------------------------- // local state // ---------------------------------------------------------------------------- static void boundPoint(vec2* point, const Rect& crop) { if (point->x < crop.left) { point->x = crop.left; } if (point->x > crop.right) { point->x = crop.right; } if (point->y < crop.top) { point->y = crop.top; } if (point->y > crop.bottom) { point->y = crop.bottom; } } void Layer::computeGeometry(const sp& hw, Mesh& mesh, bool useIdentityTransform) const { const Layer::State& s(getDrawingState()); const Transform tr(hw->getTransform()); const uint32_t hw_h = hw->getHeight(); Rect win(s.active.w, s.active.h); if (!s.crop.isEmpty()) { win.intersect(s.crop, &win); } // subtract the transparent region and snap to the bounds win = reduce(win, s.activeTransparentRegion); vec2 lt = vec2(win.left, win.top); vec2 lb = vec2(win.left, win.bottom); vec2 rb = vec2(win.right, win.bottom); vec2 rt = vec2(win.right, win.top); if (!useIdentityTransform) { lt = s.active.transform.transform(lt); lb = s.active.transform.transform(lb); rb = s.active.transform.transform(rb); rt = s.active.transform.transform(rt); } if (!s.finalCrop.isEmpty()) { boundPoint(<, s.finalCrop); boundPoint(&lb, s.finalCrop); boundPoint(&rb, s.finalCrop); boundPoint(&rt, s.finalCrop); } Mesh::VertexArray position(mesh.getPositionArray()); position[0] = tr.transform(lt); position[1] = tr.transform(lb); position[2] = tr.transform(rb); position[3] = tr.transform(rt); for (size_t i=0 ; i<4 ; i++) { position[i].y = hw_h - position[i].y; } } bool Layer::isOpaque(const Layer::State& s) const { // if we don't have a buffer yet, we're translucent regardless of the // layer's opaque flag. if (mActiveBuffer == 0) { return false; } // if the layer has the opaque flag, then we're always opaque, // otherwise we use the current buffer's format. return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; } bool Layer::isSecure() const { const Layer::State& s(mDrawingState); return (s.flags & layer_state_t::eLayerSecure); } bool Layer::isProtected() const { const sp& activeBuffer(mActiveBuffer); return (activeBuffer != 0) && (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); } bool Layer::isFixedSize() const { return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; } bool Layer::isCropped() const { return !mCurrentCrop.isEmpty(); } bool Layer::needsFiltering(const sp& hw) const { return mNeedsFiltering || hw->needsFiltering(); } void Layer::setVisibleRegion(const Region& visibleRegion) { // always called from main thread this->visibleRegion = visibleRegion; } void Layer::setCoveredRegion(const Region& coveredRegion) { // always called from main thread this->coveredRegion = coveredRegion; } void Layer::setVisibleNonTransparentRegion(const Region& setVisibleNonTransparentRegion) { // always called from main thread this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; } // ---------------------------------------------------------------------------- // transaction // ---------------------------------------------------------------------------- void Layer::pushPendingState() { if (!mCurrentState.modified) { return; } // If this transaction is waiting on the receipt of a frame, generate a sync // point and send it to the remote layer. if (mCurrentState.handle != nullptr) { sp handle = static_cast(mCurrentState.handle.get()); sp handleLayer = handle->owner.promote(); if (handleLayer == nullptr) { ALOGE("[%s] Unable to promote Layer handle", mName.string()); // If we can't promote the layer we are intended to wait on, // then it is expired or otherwise invalid. Allow this transaction // to be applied as per normal (no synchronization). mCurrentState.handle = nullptr; } else { auto syncPoint = std::make_shared( mCurrentState.frameNumber); if (handleLayer->addSyncPoint(syncPoint)) { mRemoteSyncPoints.push_back(std::move(syncPoint)); } else { // We already missed the frame we're supposed to synchronize // on, so go ahead and apply the state update mCurrentState.handle = nullptr; } } // Wake us up to check if the frame has been received setTransactionFlags(eTransactionNeeded); } mPendingStates.push_back(mCurrentState); } void Layer::popPendingState(State* stateToCommit) { auto oldFlags = stateToCommit->flags; *stateToCommit = mPendingStates[0]; stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | (stateToCommit->flags & stateToCommit->mask); mPendingStates.removeAt(0); } bool Layer::applyPendingStates(State* stateToCommit) { bool stateUpdateAvailable = false; while (!mPendingStates.empty()) { if (mPendingStates[0].handle != nullptr) { if (mRemoteSyncPoints.empty()) { // If we don't have a sync point for this, apply it anyway. It // will be visually wrong, but it should keep us from getting // into too much trouble. ALOGE("[%s] No local sync point found", mName.string()); popPendingState(stateToCommit); stateUpdateAvailable = true; continue; } if (mRemoteSyncPoints.front()->getFrameNumber() != mPendingStates[0].frameNumber) { ALOGE("[%s] Unexpected sync point frame number found", mName.string()); // Signal our end of the sync point and then dispose of it mRemoteSyncPoints.front()->setTransactionApplied(); mRemoteSyncPoints.pop_front(); continue; } if (mRemoteSyncPoints.front()->frameIsAvailable()) { // Apply the state update popPendingState(stateToCommit); stateUpdateAvailable = true; // Signal our end of the sync point and then dispose of it mRemoteSyncPoints.front()->setTransactionApplied(); mRemoteSyncPoints.pop_front(); } else { break; } } else { popPendingState(stateToCommit); stateUpdateAvailable = true; } } // If we still have pending updates, wake SurfaceFlinger back up and point // it at this layer so we can process them if (!mPendingStates.empty()) { setTransactionFlags(eTransactionNeeded); mFlinger->setTransactionFlags(eTraversalNeeded); } mCurrentState.modified = false; return stateUpdateAvailable; } void Layer::notifyAvailableFrames() { auto headFrameNumber = getHeadFrameNumber(); Mutex::Autolock lock(mLocalSyncPointMutex); for (auto& point : mLocalSyncPoints) { if (headFrameNumber >= point->getFrameNumber()) { point->setFrameAvailable(); } } } uint32_t Layer::doTransaction(uint32_t flags) { ATRACE_CALL(); pushPendingState(); Layer::State c = getCurrentState(); if (!applyPendingStates(&c)) { return 0; } const Layer::State& s(getDrawingState()); const bool sizeChanged = (c.requested.w != s.requested.w) || (c.requested.h != s.requested.h); if (sizeChanged) { // the size changed, we need to ask our client to request a new buffer ALOGD_IF(DEBUG_RESIZE, "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" " requested={ wh={%4u,%4u} }}\n" " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" " requested={ wh={%4u,%4u} }}\n", this, getName().string(), mCurrentTransform, getEffectiveScalingMode(), c.active.w, c.active.h, c.crop.left, c.crop.top, c.crop.right, c.crop.bottom, c.crop.getWidth(), c.crop.getHeight(), c.requested.w, c.requested.h, s.active.w, s.active.h, s.crop.left, s.crop.top, s.crop.right, s.crop.bottom, s.crop.getWidth(), s.crop.getHeight(), s.requested.w, s.requested.h); // record the new size, form this point on, when the client request // a buffer, it'll get the new size. mSurfaceFlingerConsumer->setDefaultBufferSize( c.requested.w, c.requested.h); } const bool resizePending = (c.requested.w != c.active.w) || (c.requested.h != c.active.h); if (!isFixedSize()) { if (resizePending && mSidebandStream == NULL) { // don't let Layer::doTransaction update the drawing state // if we have a pending resize, unless we are in fixed-size mode. // the drawing state will be updated only once we receive a buffer // with the correct size. // // in particular, we want to make sure the clip (which is part // of the geometry state) is latched together with the size but is // latched immediately when no resizing is involved. // // If a sideband stream is attached, however, we want to skip this // optimization so that transactions aren't missed when a buffer // never arrives flags |= eDontUpdateGeometryState; } } // always set active to requested, unless we're asked not to // this is used by Layer, which special cases resizes. if (flags & eDontUpdateGeometryState) { } else { Layer::State& editCurrentState(getCurrentState()); if (mFreezePositionUpdates) { float tx = c.active.transform.tx(); float ty = c.active.transform.ty(); c.active = c.requested; c.active.transform.set(tx, ty); editCurrentState.active = c.active; } else { editCurrentState.active = editCurrentState.requested; c.active = c.requested; } } if (s.active != c.active) { // invalidate and recompute the visible regions if needed flags |= Layer::eVisibleRegion; } if (c.sequence != s.sequence) { // invalidate and recompute the visible regions if needed flags |= eVisibleRegion; this->contentDirty = true; // we may use linear filtering, if the matrix scales us const uint8_t type = c.active.transform.getType(); mNeedsFiltering = (!c.active.transform.preserveRects() || (type >= Transform::SCALE)); } // If the layer is hidden, signal and clear out all local sync points so // that transactions for layers depending on this layer's frames becoming // visible are not blocked if (c.flags & layer_state_t::eLayerHidden) { Mutex::Autolock lock(mLocalSyncPointMutex); for (auto& point : mLocalSyncPoints) { point->setFrameAvailable(); } mLocalSyncPoints.clear(); } // Commit the transaction commitTransaction(c); return flags; } void Layer::commitTransaction(const State& stateToCommit) { mDrawingState = stateToCommit; } uint32_t Layer::getTransactionFlags(uint32_t flags) { return android_atomic_and(~flags, &mTransactionFlags) & flags; } uint32_t Layer::setTransactionFlags(uint32_t flags) { return android_atomic_or(flags, &mTransactionFlags); } bool Layer::setPosition(float x, float y, bool immediate) { if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) return false; mCurrentState.sequence++; // We update the requested and active position simultaneously because // we want to apply the position portion of the transform matrix immediately, // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. mCurrentState.requested.transform.set(x, y); if (immediate && !mFreezePositionUpdates) { mCurrentState.active.transform.set(x, y); } mFreezePositionUpdates = mFreezePositionUpdates || !immediate; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setLayer(uint32_t z) { if (mCurrentState.z == z) return false; mCurrentState.sequence++; mCurrentState.z = z; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setSize(uint32_t w, uint32_t h) { if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) return false; mCurrentState.requested.w = w; mCurrentState.requested.h = h; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } #ifdef USE_HWC2 bool Layer::setAlpha(float alpha) { #else bool Layer::setAlpha(uint8_t alpha) { #endif if (mCurrentState.alpha == alpha) return false; mCurrentState.sequence++; mCurrentState.alpha = alpha; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { mCurrentState.sequence++; mCurrentState.requested.transform.set( matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setTransparentRegionHint(const Region& transparent) { mCurrentState.requestedTransparentRegion = transparent; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setFlags(uint8_t flags, uint8_t mask) { const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); if (mCurrentState.flags == newFlags) return false; mCurrentState.sequence++; mCurrentState.flags = newFlags; mCurrentState.mask = mask; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setCrop(const Rect& crop) { if (mCurrentState.crop == crop) return false; mCurrentState.sequence++; mCurrentState.crop = crop; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setFinalCrop(const Rect& crop) { if (mCurrentState.finalCrop == crop) return false; mCurrentState.sequence++; mCurrentState.finalCrop = crop; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setOverrideScalingMode(int32_t scalingMode) { if (scalingMode == mOverrideScalingMode) return false; mOverrideScalingMode = scalingMode; setTransactionFlags(eTransactionNeeded); return true; } uint32_t Layer::getEffectiveScalingMode() const { if (mOverrideScalingMode >= 0) { return mOverrideScalingMode; } return mCurrentScalingMode; } bool Layer::setLayerStack(uint32_t layerStack) { if (mCurrentState.layerStack == layerStack) return false; mCurrentState.sequence++; mCurrentState.layerStack = layerStack; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } void Layer::deferTransactionUntil(const sp& handle, uint64_t frameNumber) { mCurrentState.handle = handle; mCurrentState.frameNumber = frameNumber; // We don't set eTransactionNeeded, because just receiving a deferral // request without any other state updates shouldn't actually induce a delay mCurrentState.modified = true; pushPendingState(); mCurrentState.handle = nullptr; mCurrentState.frameNumber = 0; mCurrentState.modified = false; } void Layer::useSurfaceDamage() { if (mFlinger->mForceFullDamage) { surfaceDamageRegion = Region::INVALID_REGION; } else { surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); } } void Layer::useEmptyDamage() { surfaceDamageRegion.clear(); } // ---------------------------------------------------------------------------- // pageflip handling... // ---------------------------------------------------------------------------- bool Layer::shouldPresentNow(const DispSync& dispSync) const { if (mSidebandStreamChanged || mAutoRefresh) { return true; } Mutex::Autolock lock(mQueueItemLock); if (mQueueItems.empty()) { return false; } auto timestamp = mQueueItems[0].mTimestamp; nsecs_t expectedPresent = mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); // Ignore timestamps more than a second in the future bool isPlausible = timestamp < (expectedPresent + s2ns(1)); ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " "relative to expectedPresent %" PRId64, mName.string(), timestamp, expectedPresent); bool isDue = timestamp < expectedPresent; return isDue || !isPlausible; } bool Layer::onPreComposition() { mRefreshPending = false; return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; } void Layer::onPostComposition() { if (mFrameLatencyNeeded) { nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); mFrameTracker.setDesiredPresentTime(desiredPresentTime); sp frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); if (frameReadyFence->isValid()) { mFrameTracker.setFrameReadyFence(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); } const HWComposer& hwc = mFlinger->getHwComposer(); #ifdef USE_HWC2 sp presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY); #else sp presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); #endif if (presentFence->isValid()) { mFrameTracker.setActualPresentFence(presentFence); } 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.advanceFrame(); mFrameLatencyNeeded = false; } } #ifdef USE_HWC2 void Layer::releasePendingBuffer() { mSurfaceFlingerConsumer->releasePendingBuffer(); } #endif bool Layer::isVisible() const { const Layer::State& s(mDrawingState); #ifdef USE_HWC2 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f && (mActiveBuffer != NULL || mSidebandStream != NULL); #else return !(s.flags & layer_state_t::eLayerHidden) && s.alpha && (mActiveBuffer != NULL || mSidebandStream != NULL); #endif } Region Layer::latchBuffer(bool& recomputeVisibleRegions) { ATRACE_CALL(); if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { // mSidebandStreamChanged was true mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); if (mSidebandStream != NULL) { setTransactionFlags(eTransactionNeeded); mFlinger->setTransactionFlags(eTraversalNeeded); } recomputeVisibleRegions = true; const State& s(getDrawingState()); return s.active.transform.transform(Region(Rect(s.active.w, s.active.h))); } Region outDirtyRegion; if (mQueuedFrames > 0 || mAutoRefresh) { // if we've already called updateTexImage() without going through // a composition step, we have to skip this layer at this point // because we cannot call updateTeximage() without a corresponding // compositionComplete() call. // we'll trigger an update in onPreComposition(). if (mRefreshPending) { return outDirtyRegion; } // Capture the old state of the layer for comparisons later const State& s(getDrawingState()); const bool oldOpacity = isOpaque(s); sp oldActiveBuffer = mActiveBuffer; struct Reject : public SurfaceFlingerConsumer::BufferRejecter { Layer::State& front; Layer::State& current; bool& recomputeVisibleRegions; bool stickyTransformSet; const char* name; int32_t overrideScalingMode; Reject(Layer::State& front, Layer::State& current, bool& recomputeVisibleRegions, bool stickySet, const char* name, int32_t overrideScalingMode) : front(front), current(current), recomputeVisibleRegions(recomputeVisibleRegions), stickyTransformSet(stickySet), name(name), overrideScalingMode(overrideScalingMode) { } virtual bool reject(const sp& buf, const BufferItem& item) { if (buf == NULL) { return false; } uint32_t bufWidth = buf->getWidth(); uint32_t bufHeight = buf->getHeight(); // check that we received a buffer of the right size // (Take the buffer's orientation into account) if (item.mTransform & Transform::ROT_90) { swap(bufWidth, bufHeight); } int actualScalingMode = overrideScalingMode >= 0 ? overrideScalingMode : item.mScalingMode; bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; if (front.active != front.requested) { if (isFixedSize || (bufWidth == front.requested.w && bufHeight == front.requested.h)) { // Here we pretend the transaction happened by updating the // current and drawing states. Drawing state is only accessed // in this thread, no need to have it locked front.active = front.requested; // We also need to update the current state so that // we don't end-up overwriting the drawing state with // this stale current state during the next transaction // // NOTE: We don't need to hold the transaction lock here // because State::active is only accessed from this thread. current.active = front.active; current.modified = true; // recompute visible region recomputeVisibleRegions = true; } ALOGD_IF(DEBUG_RESIZE, "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" " requested={ wh={%4u,%4u} }}\n", name, bufWidth, bufHeight, item.mTransform, item.mScalingMode, front.active.w, front.active.h, front.crop.left, front.crop.top, front.crop.right, front.crop.bottom, front.crop.getWidth(), front.crop.getHeight(), front.requested.w, front.requested.h); } if (!isFixedSize && !stickyTransformSet) { if (front.active.w != bufWidth || front.active.h != bufHeight) { // reject this buffer ALOGE("[%s] rejecting buffer: " "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", name, bufWidth, bufHeight, front.active.w, front.active.h); return true; } } // if the transparent region has changed (this test is // conservative, but that's fine, worst case we're doing // a bit of extra work), we latch the new one and we // trigger a visible-region recompute. if (!front.activeTransparentRegion.isTriviallyEqual( front.requestedTransparentRegion)) { front.activeTransparentRegion = front.requestedTransparentRegion; // We also need to update the current state so that // we don't end-up overwriting the drawing state with // this stale current state during the next transaction // // NOTE: We don't need to hold the transaction lock here // because State::active is only accessed from this thread. current.activeTransparentRegion = front.activeTransparentRegion; // recompute visible region recomputeVisibleRegions = true; } return false; } }; Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode); // Check all of our local sync points to ensure that all transactions // which need to have been applied prior to the frame which is about to // be latched have signaled auto headFrameNumber = getHeadFrameNumber(); bool matchingFramesFound = false; bool allTransactionsApplied = true; { Mutex::Autolock lock(mLocalSyncPointMutex); for (auto& point : mLocalSyncPoints) { if (point->getFrameNumber() > headFrameNumber) { break; } matchingFramesFound = true; if (!point->frameIsAvailable()) { // We haven't notified the remote layer that the frame for // this point is available yet. Notify it now, and then // abort this attempt to latch. point->setFrameAvailable(); allTransactionsApplied = false; break; } allTransactionsApplied &= point->transactionIsApplied(); } } if (matchingFramesFound && !allTransactionsApplied) { mFlinger->signalLayerUpdate(); return outDirtyRegion; } // This boolean is used to make sure that SurfaceFlinger's shadow copy // of the buffer queue isn't modified when the buffer queue is returning // BufferItem's that weren't actually queued. This can happen in shared // buffer mode. bool queuedBuffer = false; status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, mLastFrameNumberReceived); if (updateResult == BufferQueue::PRESENT_LATER) { // Producer doesn't want buffer to be displayed yet. Signal a // layer update so we check again at the next opportunity. mFlinger->signalLayerUpdate(); return outDirtyRegion; } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { // If the buffer has been rejected, remove it from the shadow queue // and return early if (queuedBuffer) { Mutex::Autolock lock(mQueueItemLock); mQueueItems.removeAt(0); android_atomic_dec(&mQueuedFrames); } return outDirtyRegion; } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { // This can occur if something goes wrong when trying to create the // EGLImage for this buffer. If this happens, the buffer has already // been released, so we need to clean up the queue and bug out // early. if (queuedBuffer) { Mutex::Autolock lock(mQueueItemLock); mQueueItems.clear(); android_atomic_and(0, &mQueuedFrames); } // Once we have hit this state, the shadow queue may no longer // correctly reflect the incoming BufferQueue's contents, so even if // updateTexImage starts working, the only safe course of action is // to continue to ignore updates. mUpdateTexImageFailed = true; return outDirtyRegion; } if (queuedBuffer) { // Autolock scope auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); Mutex::Autolock lock(mQueueItemLock); // Remove any stale buffers that have been dropped during // updateTexImage while (mQueueItems[0].mFrameNumber != currentFrameNumber) { mQueueItems.removeAt(0); android_atomic_dec(&mQueuedFrames); } mQueueItems.removeAt(0); } // Decrement the queued-frames count. Signal another event if we // have more frames pending. if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) || mAutoRefresh) { mFlinger->signalLayerUpdate(); } if (updateResult != NO_ERROR) { // something happened! recomputeVisibleRegions = true; return outDirtyRegion; } // update the active buffer mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); if (mActiveBuffer == NULL) { // this can only happen if the very first buffer was rejected. return outDirtyRegion; } mRefreshPending = true; mFrameLatencyNeeded = true; if (oldActiveBuffer == NULL) { // the first time we receive a buffer, we need to trigger a // geometry invalidation. recomputeVisibleRegions = true; } Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); if ((crop != mCurrentCrop) || (transform != mCurrentTransform) || (scalingMode != mCurrentScalingMode)) { mCurrentCrop = crop; mCurrentTransform = transform; mCurrentScalingMode = scalingMode; recomputeVisibleRegions = true; } if (oldActiveBuffer != NULL) { uint32_t bufWidth = mActiveBuffer->getWidth(); uint32_t bufHeight = mActiveBuffer->getHeight(); if (bufWidth != uint32_t(oldActiveBuffer->width) || bufHeight != uint32_t(oldActiveBuffer->height)) { recomputeVisibleRegions = true; mFreezePositionUpdates = false; } } mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); if (oldOpacity != isOpaque(s)) { recomputeVisibleRegions = true; } mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); // Remove any sync points corresponding to the buffer which was just // latched { Mutex::Autolock lock(mLocalSyncPointMutex); auto point = mLocalSyncPoints.begin(); while (point != mLocalSyncPoints.end()) { if (!(*point)->frameIsAvailable() || !(*point)->transactionIsApplied()) { // This sync point must have been added since we started // latching. Don't drop it yet. ++point; continue; } if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { point = mLocalSyncPoints.erase(point); } else { ++point; } } } // FIXME: postedRegion should be dirty & bounds Region dirtyRegion(Rect(s.active.w, s.active.h)); // transform the dirty region to window-manager space outDirtyRegion = (s.active.transform.transform(dirtyRegion)); } return outDirtyRegion; } uint32_t Layer::getEffectiveUsage(uint32_t usage) const { // TODO: should we do something special if mSecure is set? if (mProtectedByApp) { // need a hardware-protected path to external video sink usage |= GraphicBuffer::USAGE_PROTECTED; } if (mPotentialCursor) { usage |= GraphicBuffer::USAGE_CURSOR; } usage |= GraphicBuffer::USAGE_HW_COMPOSER; return usage; } void Layer::updateTransformHint(const sp& hw) const { uint32_t orientation = 0; if (!mFlinger->mDebugDisableTransformHint) { // The transform hint is used to improve performance, but we can // only have a single transform hint, it cannot // apply to all displays. const Transform& planeTransform(hw->getTransform()); orientation = planeTransform.getOrientation(); if (orientation & Transform::ROT_INVALID) { orientation = 0; } } mSurfaceFlingerConsumer->setTransformHint(orientation); } // ---------------------------------------------------------------------------- // debugging // ---------------------------------------------------------------------------- void Layer::dump(String8& result, Colorizer& colorizer) const { const Layer::State& s(getDrawingState()); colorizer.colorize(result, Colorizer::GREEN); result.appendFormat( "+ %s %p (%s)\n", getTypeId(), this, getName().string()); colorizer.reset(result); s.activeTransparentRegion.dump(result, "transparentRegion"); visibleRegion.dump(result, "visibleRegion"); surfaceDamageRegion.dump(result, "surfaceDamageRegion"); sp client(mClientRef.promote()); result.appendFormat( " " "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " "isOpaque=%1d, invalidate=%1d, " #ifdef USE_HWC2 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" #else "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" #endif " client=%p\n", s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h, s.crop.left, s.crop.top, s.crop.right, s.crop.bottom, s.finalCrop.left, s.finalCrop.top, s.finalCrop.right, s.finalCrop.bottom, isOpaque(s), contentDirty, s.alpha, s.flags, s.active.transform[0][0], s.active.transform[0][1], s.active.transform[1][0], s.active.transform[1][1], client.get()); sp buf0(mActiveBuffer); uint32_t w0=0, h0=0, s0=0, f0=0; if (buf0 != 0) { w0 = buf0->getWidth(); h0 = buf0->getHeight(); s0 = buf0->getStride(); f0 = buf0->format; } result.appendFormat( " " "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," " queued-frames=%d, mRefreshPending=%d\n", mFormat, w0, h0, s0,f0, mQueuedFrames, mRefreshPending); if (mSurfaceFlingerConsumer != 0) { mSurfaceFlingerConsumer->dump(result, " "); } } void Layer::dumpFrameStats(String8& result) const { mFrameTracker.dumpStats(result); } void Layer::clearFrameStats() { mFrameTracker.clearStats(); } void Layer::logFrameStats() { mFrameTracker.logAndResetStats(mName); } void Layer::getFrameStats(FrameStats* outStats) const { mFrameTracker.getStats(outStats); } void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber, bool* outIsGlesComposition, nsecs_t* outPostedTime, sp* outAcquireFence, sp* outPrevReleaseFence) const { *outName = mName; *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); #ifdef USE_HWC2 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ? mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType == HWC2::Composition::Client : true; #else *outIsGlesComposition = mIsGlesComposition; #endif *outPostedTime = mSurfaceFlingerConsumer->getTimestamp(); *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence(); *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence(); } // --------------------------------------------------------------------------- Layer::LayerCleaner::LayerCleaner(const sp& flinger, const sp& layer) : mFlinger(flinger), mLayer(layer) { } Layer::LayerCleaner::~LayerCleaner() { // destroy client resources mFlinger->onLayerDestroyed(mLayer); } // --------------------------------------------------------------------------- }; // namespace android #if defined(__gl_h_) #error "don't include gl/gl.h in this file" #endif #if defined(__gl2_h_) #error "don't include gl2/gl2.h in this file" #endif