summaryrefslogtreecommitdiffstats
path: root/widget/gonk/HwcComposer2D.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/gonk/HwcComposer2D.cpp')
-rw-r--r--widget/gonk/HwcComposer2D.cpp971
1 files changed, 971 insertions, 0 deletions
diff --git a/widget/gonk/HwcComposer2D.cpp b/widget/gonk/HwcComposer2D.cpp
new file mode 100644
index 000000000..6b4c7a1cc
--- /dev/null
+++ b/widget/gonk/HwcComposer2D.cpp
@@ -0,0 +1,971 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:set ts=4 sw=4 sts=4 et: */
+/*
+ * Copyright (c) 2012, 2013 The Linux Foundation. All rights reserved.
+ *
+ * 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.
+ */
+
+#include <android/log.h>
+#include <string.h>
+
+#include "gfxPrefs.h"
+#include "ImageLayers.h"
+#include "libdisplay/GonkDisplay.h"
+#include "HwcComposer2D.h"
+#include "LayerScope.h"
+#include "Units.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/LayerManagerComposite.h"
+#include "mozilla/layers/PLayerTransaction.h"
+#include "mozilla/layers/ShadowLayerUtilsGralloc.h"
+#include "mozilla/layers/TextureHostOGL.h" // for TextureHostOGL
+#include "mozilla/StaticPtr.h"
+#include "nsThreadUtils.h"
+#include "cutils/properties.h"
+#include "gfx2DGlue.h"
+#include "gfxPlatform.h"
+#include "VsyncSource.h"
+#include "nsScreenManagerGonk.h"
+#include "nsWindow.h"
+
+#if ANDROID_VERSION >= 17
+#include "libdisplay/DisplaySurface.h"
+#endif
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "HWComposer"
+
+/*
+ * By default the debug message of hwcomposer (LOG_DEBUG level) are undefined,
+ * but can be enabled by uncommenting HWC_DEBUG below.
+ */
+//#define HWC_DEBUG
+
+#ifdef HWC_DEBUG
+#define LOGD(args...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, ## args)
+#else
+#define LOGD(args...) ((void)0)
+#endif
+
+#define LOGI(args...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, ## args)
+#define LOGE(args...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, ## args)
+
+#define LAYER_COUNT_INCREMENTS 5
+
+using namespace android;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+
+namespace mozilla {
+
+static void
+HookInvalidate(const struct hwc_procs* aProcs)
+{
+ HwcComposer2D::GetInstance()->Invalidate();
+}
+
+static void
+HookVsync(const struct hwc_procs* aProcs, int aDisplay,
+ int64_t aTimestamp)
+{
+ HwcComposer2D::GetInstance()->Vsync(aDisplay, aTimestamp);
+}
+
+static void
+HookHotplug(const struct hwc_procs* aProcs, int aDisplay,
+ int aConnected)
+{
+ HwcComposer2D::GetInstance()->Hotplug(aDisplay, aConnected);
+}
+
+static StaticRefPtr<HwcComposer2D> sInstance;
+
+HwcComposer2D::HwcComposer2D()
+ : mList(nullptr)
+ , mMaxLayerCount(0)
+ , mColorFill(false)
+ , mRBSwapSupport(false)
+ , mPrepared(false)
+ , mHasHWVsync(false)
+ , mLock("mozilla.HwcComposer2D.mLock")
+{
+ mHal = HwcHALBase::CreateHwcHAL();
+ if (!mHal->HasHwc()) {
+ LOGD("no hwc support");
+ return;
+ }
+
+ RegisterHwcEventCallback();
+
+ nsIntSize screenSize;
+
+ GonkDisplay::NativeData data = GetGonkDisplay()->GetNativeData(GonkDisplay::DISPLAY_PRIMARY);
+ ANativeWindow *win = data.mNativeWindow.get();
+ win->query(win, NATIVE_WINDOW_WIDTH, &screenSize.width);
+ win->query(win, NATIVE_WINDOW_HEIGHT, &screenSize.height);
+ mScreenRect = gfx::IntRect(gfx::IntPoint(0, 0), screenSize);
+
+ mColorFill = mHal->Query(HwcHALBase::QueryType::COLOR_FILL);
+ mRBSwapSupport = mHal->Query(HwcHALBase::QueryType::RB_SWAP);
+}
+
+HwcComposer2D::~HwcComposer2D()
+{
+ free(mList);
+}
+
+HwcComposer2D*
+HwcComposer2D::GetInstance()
+{
+ if (!sInstance) {
+#ifdef HWC_DEBUG
+ // Make sure only create once
+ static int timesCreated = 0;
+ ++timesCreated;
+ MOZ_ASSERT(timesCreated == 1);
+#endif
+ LOGI("Creating new instance");
+ sInstance = new HwcComposer2D();
+
+ // If anyone uses the compositor thread to create HwcComposer2D,
+ // we just skip this function.
+ // If ClearOnShutdown() can handle objects in other threads
+ // in the future, we can remove this check.
+ if (NS_IsMainThread()) {
+ // If we create HwcComposer2D by the main thread, we can use
+ // ClearOnShutdown() to make sure it will be nullified properly.
+ ClearOnShutdown(&sInstance);
+ }
+ }
+ return sInstance;
+}
+
+bool
+HwcComposer2D::EnableVsync(bool aEnable)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (!mHasHWVsync) {
+ return false;
+ }
+ return mHal->EnableVsync(aEnable) && aEnable;
+}
+
+bool
+HwcComposer2D::RegisterHwcEventCallback()
+{
+ const HwcHALProcs_t cHWCProcs = {
+ &HookInvalidate, // 1st: void (*invalidate)(...)
+ &HookVsync, // 2nd: void (*vsync)(...)
+ &HookHotplug // 3rd: void (*hotplug)(...)
+ };
+ mHasHWVsync = mHal->RegisterHwcEventCallback(cHWCProcs);
+ return mHasHWVsync;
+}
+
+void
+HwcComposer2D::Vsync(int aDisplay, nsecs_t aVsyncTimestamp)
+{
+ // Only support hardware vsync on kitkat, L and up due to inaccurate timings
+ // with JellyBean.
+#if (ANDROID_VERSION == 19 || ANDROID_VERSION >= 21)
+ TimeStamp vsyncTime = mozilla::TimeStamp::FromSystemTime(aVsyncTimestamp);
+ gfxPlatform::GetPlatform()->GetHardwareVsync()->GetGlobalDisplay().NotifyVsync(vsyncTime);
+#else
+ // If this device doesn't support vsync, this function should not be used.
+ MOZ_ASSERT(false);
+#endif
+}
+
+// Called on the "invalidator" thread (run from HAL).
+void
+HwcComposer2D::Invalidate()
+{
+ if (!mHal->HasHwc()) {
+ LOGE("HwcComposer2D::Invalidate failed!");
+ return;
+ }
+
+ MutexAutoLock lock(mLock);
+ if (mCompositorBridgeParent) {
+ mCompositorBridgeParent->ScheduleRenderOnCompositorThread();
+ }
+}
+
+namespace {
+class HotplugEvent : public Runnable {
+public:
+ HotplugEvent(GonkDisplay::DisplayType aType, bool aConnected)
+ : mType(aType)
+ , mConnected(aConnected)
+ {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ RefPtr<nsScreenManagerGonk> screenManager =
+ nsScreenManagerGonk::GetInstance();
+ if (mConnected) {
+ screenManager->AddScreen(mType);
+ } else {
+ screenManager->RemoveScreen(mType);
+ }
+ return NS_OK;
+ }
+private:
+ GonkDisplay::DisplayType mType;
+ bool mConnected;
+};
+} // namespace
+
+void
+HwcComposer2D::Hotplug(int aDisplay, int aConnected)
+{
+ NS_DispatchToMainThread(new HotplugEvent(GonkDisplay::DISPLAY_EXTERNAL,
+ aConnected));
+}
+
+void
+HwcComposer2D::SetCompositorBridgeParent(CompositorBridgeParent* aCompositorBridgeParent)
+{
+ MutexAutoLock lock(mLock);
+ mCompositorBridgeParent = aCompositorBridgeParent;
+}
+
+bool
+HwcComposer2D::ReallocLayerList()
+{
+ int size = sizeof(HwcList) +
+ ((mMaxLayerCount + LAYER_COUNT_INCREMENTS) * sizeof(HwcLayer));
+
+ HwcList* listrealloc = (HwcList*)realloc(mList, size);
+
+ if (!listrealloc) {
+ return false;
+ }
+
+ if (!mList) {
+ //first alloc, initialize
+ listrealloc->numHwLayers = 0;
+ listrealloc->flags = 0;
+ }
+
+ mList = listrealloc;
+ mMaxLayerCount += LAYER_COUNT_INCREMENTS;
+ return true;
+}
+
+bool
+HwcComposer2D::PrepareLayerList(Layer* aLayer,
+ const nsIntRect& aClip,
+ const Matrix& aParentTransform,
+ bool aFindSidebandStreams)
+{
+ // NB: we fall off this path whenever there are container layers
+ // that require intermediate surfaces. That means all the
+ // GetEffective*() coordinates are relative to the framebuffer.
+
+ bool fillColor = false;
+
+ const nsIntRegion visibleRegion = aLayer->GetLocalVisibleRegion().ToUnknownRegion();
+ if (visibleRegion.IsEmpty()) {
+ return true;
+ }
+
+ uint8_t opacity = std::min(0xFF, (int)(aLayer->GetEffectiveOpacity() * 256.0));
+ if (opacity == 0) {
+ LOGD("%s Layer has zero opacity; skipping", aLayer->Name());
+ return true;
+ }
+
+ if (!mHal->SupportTransparency() && opacity < 0xFF && !aFindSidebandStreams) {
+ LOGD("%s Layer has planar semitransparency which is unsupported by hwcomposer", aLayer->Name());
+ return false;
+ }
+
+ if (aLayer->GetMaskLayer() && !aFindSidebandStreams) {
+ LOGD("%s Layer has MaskLayer which is unsupported by hwcomposer", aLayer->Name());
+ return false;
+ }
+
+ nsIntRect clip;
+ nsIntRect layerClip = aLayer->GetLocalClipRect().valueOr(ParentLayerIntRect()).ToUnknownRect();
+ nsIntRect* layerClipPtr = aLayer->GetLocalClipRect() ? &layerClip : nullptr;
+ if (!HwcUtils::CalculateClipRect(aParentTransform,
+ layerClipPtr,
+ aClip,
+ &clip))
+ {
+ LOGD("%s Clip rect is empty. Skip layer", aLayer->Name());
+ return true;
+ }
+
+ // HWC supports only the following 2D transformations:
+ //
+ // Scaling via the sourceCrop and displayFrame in HwcLayer
+ // Translation via the sourceCrop and displayFrame in HwcLayer
+ // Rotation (in square angles only) via the HWC_TRANSFORM_ROT_* flags
+ // Reflection (horizontal and vertical) via the HWC_TRANSFORM_FLIP_* flags
+ //
+ // A 2D transform with PreservesAxisAlignedRectangles() has all the attributes
+ // above
+ Matrix layerTransform;
+ if (!aLayer->GetEffectiveTransform().Is2D(&layerTransform) ||
+ !layerTransform.PreservesAxisAlignedRectangles()) {
+ LOGD("Layer EffectiveTransform has a 3D transform or a non-square angle rotation");
+ return false;
+ }
+
+ Matrix layerBufferTransform;
+ if (!aLayer->GetEffectiveTransformForBuffer().Is2D(&layerBufferTransform) ||
+ !layerBufferTransform.PreservesAxisAlignedRectangles()) {
+ LOGD("Layer EffectiveTransformForBuffer has a 3D transform or a non-square angle rotation");
+ return false;
+ }
+
+ if (ContainerLayer* container = aLayer->AsContainerLayer()) {
+ if (container->UseIntermediateSurface() && !aFindSidebandStreams) {
+ LOGD("Container layer needs intermediate surface");
+ return false;
+ }
+ AutoTArray<Layer*, 12> children;
+ container->SortChildrenBy3DZOrder(children);
+
+ for (uint32_t i = 0; i < children.Length(); i++) {
+ if (!PrepareLayerList(children[i], clip, layerTransform, aFindSidebandStreams) &&
+ !aFindSidebandStreams) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ LayerRenderState state = aLayer->GetRenderState();
+
+#if ANDROID_VERSION >= 21
+ if (!state.GetGrallocBuffer() && !state.GetSidebandStream().IsValid()) {
+#else
+ if (!state.GetGrallocBuffer()) {
+#endif
+ if (aLayer->AsColorLayer() && mColorFill) {
+ fillColor = true;
+ } else {
+ LOGD("%s Layer doesn't have a gralloc buffer", aLayer->Name());
+ return false;
+ }
+ }
+
+ nsIntRect visibleRect = visibleRegion.GetBounds();
+
+ nsIntRect bufferRect;
+ if (fillColor) {
+ bufferRect = nsIntRect(visibleRect);
+ } else {
+ nsIntRect layerRect;
+ if (state.mHasOwnOffset) {
+ bufferRect = nsIntRect(state.mOffset.x, state.mOffset.y,
+ state.mSize.width, state.mSize.height);
+ layerRect = bufferRect;
+ } else {
+ //Since the buffer doesn't have its own offset, assign the whole
+ //surface size as its buffer bounds
+ bufferRect = nsIntRect(0, 0, state.mSize.width, state.mSize.height);
+ layerRect = bufferRect;
+ if (aLayer->GetType() == Layer::TYPE_IMAGE) {
+ ImageLayer* imageLayer = static_cast<ImageLayer*>(aLayer);
+ if(imageLayer->GetScaleMode() != ScaleMode::SCALE_NONE) {
+ layerRect = nsIntRect(0, 0, imageLayer->GetScaleToSize().width, imageLayer->GetScaleToSize().height);
+ }
+ }
+ }
+ // In some cases the visible rect assigned to the layer can be larger
+ // than the layer's surface, e.g., an ImageLayer with a small Image
+ // in it.
+ visibleRect.IntersectRect(visibleRect, layerRect);
+ }
+
+ // Buffer rotation is not to be confused with the angled rotation done by a transform matrix
+ // It's a fancy PaintedLayer feature used for scrolling
+ if (state.BufferRotated()) {
+ LOGD("%s Layer has a rotated buffer", aLayer->Name());
+ return false;
+ }
+
+ const bool needsYFlip = state.OriginBottomLeft() ? true
+ : false;
+
+ hwc_rect_t sourceCrop, displayFrame;
+ if(!HwcUtils::PrepareLayerRects(visibleRect,
+ layerTransform,
+ layerBufferTransform,
+ clip,
+ bufferRect,
+ needsYFlip,
+ &(sourceCrop),
+ &(displayFrame)))
+ {
+ return true;
+ }
+
+ // OK! We can compose this layer with hwc.
+ int current = mList ? mList->numHwLayers : 0;
+
+ // Do not compose any layer below full-screen Opaque layer
+ // Note: It can be generalized to non-fullscreen Opaque layers.
+ bool isOpaque = opacity == 0xFF &&
+ (state.mFlags & LayerRenderStateFlags::OPAQUE);
+ // Currently we perform opacity calculation using the *bounds* of the layer.
+ // We can only make this assumption if we're not dealing with a complex visible region.
+ bool isSimpleVisibleRegion = visibleRegion.Contains(visibleRect);
+ if (current && isOpaque && isSimpleVisibleRegion) {
+ nsIntRect displayRect = nsIntRect(displayFrame.left, displayFrame.top,
+ displayFrame.right - displayFrame.left, displayFrame.bottom - displayFrame.top);
+ if (displayRect.Contains(mScreenRect)) {
+ // In z-order, all previous layers are below
+ // the current layer. We can ignore them now.
+ mList->numHwLayers = current = 0;
+ mHwcLayerMap.Clear();
+ }
+ }
+
+ if (!mList || current >= mMaxLayerCount) {
+ if (!ReallocLayerList() || current >= mMaxLayerCount) {
+ LOGE("PrepareLayerList failed! Could not increase the maximum layer count");
+ return false;
+ }
+ }
+
+ HwcLayer& hwcLayer = mList->hwLayers[current];
+ hwcLayer.displayFrame = displayFrame;
+ mHal->SetCrop(hwcLayer, sourceCrop);
+ buffer_handle_t handle = nullptr;
+#if ANDROID_VERSION >= 21
+ if (state.GetSidebandStream().IsValid()) {
+ handle = state.GetSidebandStream().GetRawNativeHandle();
+ } else if (state.GetGrallocBuffer()) {
+ handle = state.GetGrallocBuffer()->getNativeBuffer()->handle;
+ }
+#else
+ if (state.GetGrallocBuffer()) {
+ handle = state.GetGrallocBuffer()->getNativeBuffer()->handle;
+ }
+#endif
+ hwcLayer.handle = handle;
+
+ hwcLayer.flags = 0;
+ hwcLayer.hints = 0;
+ hwcLayer.blending = isOpaque ? HWC_BLENDING_NONE : HWC_BLENDING_PREMULT;
+#if ANDROID_VERSION >= 17
+ hwcLayer.compositionType = HWC_FRAMEBUFFER;
+#if ANDROID_VERSION >= 21
+ if (state.GetSidebandStream().IsValid()) {
+ hwcLayer.compositionType = HWC_SIDEBAND;
+ }
+#endif
+ hwcLayer.acquireFenceFd = -1;
+ hwcLayer.releaseFenceFd = -1;
+#if ANDROID_VERSION >= 18
+ hwcLayer.planeAlpha = opacity;
+#endif
+#else
+ hwcLayer.compositionType = HwcUtils::HWC_USE_COPYBIT;
+#endif
+
+ if (!fillColor) {
+ if (state.FormatRBSwapped()) {
+ if (!mRBSwapSupport) {
+ LOGD("No R/B swap support in H/W Composer");
+ return false;
+ }
+ hwcLayer.flags |= HwcUtils::HWC_FORMAT_RB_SWAP;
+ }
+
+ // Translation and scaling have been addressed in PrepareLayerRects().
+ // Given the above and that we checked for PreservesAxisAlignedRectangles()
+ // the only possible transformations left to address are
+ // square angle rotation and horizontal/vertical reflection.
+ //
+ // The rotation and reflection permutations total 16 but can be
+ // reduced to 8 transformations after eliminating redundancies.
+ //
+ // All matrices represented here are in the form
+ //
+ // | xx xy |
+ // | yx yy |
+ //
+ // And ignore scaling.
+ //
+ // Reflection is applied before rotation
+ gfx::Matrix rotation = layerTransform;
+ // Compute fuzzy zero like PreservesAxisAlignedRectangles()
+ if (fabs(rotation._11) < 1e-6) {
+ if (rotation._21 < 0) {
+ if (rotation._12 > 0) {
+ // 90 degree rotation
+ //
+ // | 0 -1 |
+ // | 1 0 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_ROT_90;
+ LOGD("Layer rotated 90 degrees");
+ }
+ else {
+ // Horizontal reflection then 90 degree rotation
+ //
+ // | 0 -1 | | -1 0 | = | 0 -1 |
+ // | 1 0 | | 0 1 | | -1 0 |
+ //
+ // same as vertical reflection then 270 degree rotation
+ //
+ // | 0 1 | | 1 0 | = | 0 -1 |
+ // | -1 0 | | 0 -1 | | -1 0 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_ROT_90 | HWC_TRANSFORM_FLIP_H;
+ LOGD("Layer vertically reflected then rotated 270 degrees");
+ }
+ } else {
+ if (rotation._12 < 0) {
+ // 270 degree rotation
+ //
+ // | 0 1 |
+ // | -1 0 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_ROT_270;
+ LOGD("Layer rotated 270 degrees");
+ }
+ else {
+ // Vertical reflection then 90 degree rotation
+ //
+ // | 0 1 | | -1 0 | = | 0 1 |
+ // | -1 0 | | 0 1 | | 1 0 |
+ //
+ // Same as horizontal reflection then 270 degree rotation
+ //
+ // | 0 -1 | | 1 0 | = | 0 1 |
+ // | 1 0 | | 0 -1 | | 1 0 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_ROT_90 | HWC_TRANSFORM_FLIP_V;
+ LOGD("Layer horizontally reflected then rotated 270 degrees");
+ }
+ }
+ } else if (rotation._11 < 0) {
+ if (rotation._22 > 0) {
+ // Horizontal reflection
+ //
+ // | -1 0 |
+ // | 0 1 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_FLIP_H;
+ LOGD("Layer rotated 180 degrees");
+ }
+ else {
+ // 180 degree rotation
+ //
+ // | -1 0 |
+ // | 0 -1 |
+ //
+ // Same as horizontal and vertical reflection
+ //
+ // | -1 0 | | 1 0 | = | -1 0 |
+ // | 0 1 | | 0 -1 | | 0 -1 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_ROT_180;
+ LOGD("Layer rotated 180 degrees");
+ }
+ } else {
+ if (rotation._22 < 0) {
+ // Vertical reflection
+ //
+ // | 1 0 |
+ // | 0 -1 |
+ //
+ hwcLayer.transform = HWC_TRANSFORM_FLIP_V;
+ LOGD("Layer rotated 180 degrees");
+ }
+ else {
+ // No rotation or reflection
+ //
+ // | 1 0 |
+ // | 0 1 |
+ //
+ hwcLayer.transform = 0;
+ }
+ }
+
+ const bool needsYFlip = state.OriginBottomLeft() ? true
+ : false;
+
+ if (needsYFlip) {
+ // Invert vertical reflection flag if it was already set
+ hwcLayer.transform ^= HWC_TRANSFORM_FLIP_V;
+ }
+ hwc_region_t region;
+ if (visibleRegion.GetNumRects() > 1) {
+ mVisibleRegions.push_back(HwcUtils::RectVector());
+ HwcUtils::RectVector* visibleRects = &(mVisibleRegions.back());
+ bool isVisible = false;
+ if(!HwcUtils::PrepareVisibleRegion(visibleRegion,
+ layerTransform,
+ layerBufferTransform,
+ clip,
+ bufferRect,
+ visibleRects,
+ isVisible)) {
+ LOGD("A region of layer is too small to be rendered by HWC");
+ return false;
+ }
+ if (!isVisible) {
+ // Layer is not visible, no need to render it
+ return true;
+ }
+ region.numRects = visibleRects->size();
+ region.rects = &((*visibleRects)[0]);
+ } else {
+ region.numRects = 1;
+ region.rects = &(hwcLayer.displayFrame);
+ }
+ hwcLayer.visibleRegionScreen = region;
+ } else {
+ hwcLayer.flags |= HwcUtils::HWC_COLOR_FILL;
+ ColorLayer* colorLayer = aLayer->AsColorLayer();
+ if (colorLayer->GetColor().a < 1.0) {
+ LOGD("Color layer has semitransparency which is unsupported");
+ return false;
+ }
+ hwcLayer.transform = colorLayer->GetColor().ToABGR();
+ }
+
+#if ANDROID_VERSION >= 21
+ if (aFindSidebandStreams && hwcLayer.compositionType == HWC_SIDEBAND) {
+ mCachedSidebandLayers.AppendElement(hwcLayer);
+ }
+#endif
+
+ mHwcLayerMap.AppendElement(static_cast<LayerComposite*>(aLayer->ImplData()));
+ mList->numHwLayers++;
+ return true;
+}
+
+
+#if ANDROID_VERSION >= 17
+bool
+HwcComposer2D::TryHwComposition(nsScreenGonk* aScreen)
+{
+ DisplaySurface* dispSurface = aScreen->GetDisplaySurface();
+
+ if (!(dispSurface && dispSurface->lastHandle)) {
+ LOGD("H/W Composition failed. DispSurface not initialized.");
+ return false;
+ }
+
+ // Add FB layer
+ int idx = mList->numHwLayers++;
+ if (idx >= mMaxLayerCount) {
+ if (!ReallocLayerList() || idx >= mMaxLayerCount) {
+ LOGE("TryHwComposition failed! Could not add FB layer");
+ return false;
+ }
+ }
+
+ Prepare(dispSurface->lastHandle, -1, aScreen);
+
+ /* Possible composition paths, after hwc prepare:
+ 1. GPU Composition
+ 2. BLIT Composition
+ 3. Full OVERLAY Composition
+ 4. Partial OVERLAY Composition (GPU + OVERLAY) */
+
+ bool gpuComposite = false;
+ bool blitComposite = false;
+ bool overlayComposite = true;
+
+ for (int j=0; j < idx; j++) {
+ if (mList->hwLayers[j].compositionType == HWC_FRAMEBUFFER ||
+ mList->hwLayers[j].compositionType == HWC_BLIT) {
+ // Full OVERLAY composition is not possible on this frame
+ // It is either GPU / BLIT / partial OVERLAY composition.
+ overlayComposite = false;
+ break;
+ }
+ }
+
+ if (!overlayComposite) {
+ for (int k=0; k < idx; k++) {
+ switch (mList->hwLayers[k].compositionType) {
+ case HWC_FRAMEBUFFER:
+ gpuComposite = true;
+ break;
+ case HWC_BLIT:
+ blitComposite = true;
+ break;
+#if ANDROID_VERSION >= 21
+ case HWC_SIDEBAND:
+#endif
+ case HWC_OVERLAY: {
+ // HWC will compose HWC_OVERLAY layers in partial
+ // Overlay Composition, set layer composition flag
+ // on mapped LayerComposite to skip GPU composition
+ mHwcLayerMap[k]->SetLayerComposited(true);
+
+ uint8_t opacity = std::min(0xFF, (int)(mHwcLayerMap[k]->GetLayer()->GetEffectiveOpacity() * 256.0));
+ if ((mList->hwLayers[k].hints & HWC_HINT_CLEAR_FB) &&
+ (opacity == 0xFF)) {
+ // Clear visible rect on FB with transparent pixels.
+ hwc_rect_t r = mList->hwLayers[k].displayFrame;
+ mHwcLayerMap[k]->SetClearRect(nsIntRect(r.left, r.top,
+ r.right - r.left,
+ r.bottom - r.top));
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ if (gpuComposite) {
+ // GPU or partial OVERLAY Composition
+ return false;
+ } else if (blitComposite) {
+ // BLIT Composition, flip DispSurface target
+ GetGonkDisplay()->UpdateDispSurface(aScreen->GetEGLDisplay(), aScreen->GetEGLSurface());
+ DisplaySurface* dispSurface = aScreen->GetDisplaySurface();
+ if (!dispSurface) {
+ LOGE("H/W Composition failed. NULL DispSurface.");
+ return false;
+ }
+ mList->hwLayers[idx].handle = dispSurface->lastHandle;
+ mList->hwLayers[idx].acquireFenceFd = dispSurface->GetPrevDispAcquireFd();
+ }
+ }
+
+ // BLIT or full OVERLAY Composition
+ return Commit(aScreen);
+}
+
+bool
+HwcComposer2D::Render(nsIWidget* aWidget)
+{
+ nsScreenGonk* screen = static_cast<nsWindow*>(aWidget)->GetScreen();
+
+ // HWC module does not exist or mList is not created yet.
+ if (!mHal->HasHwc() || !mList) {
+ return GetGonkDisplay()->SwapBuffers(screen->GetEGLDisplay(), screen->GetEGLSurface());
+ } else if (!mList && !ReallocLayerList()) {
+ LOGE("Cannot realloc layer list");
+ return false;
+ }
+
+ DisplaySurface* dispSurface = screen->GetDisplaySurface();
+ if (!dispSurface) {
+ LOGE("H/W Composition failed. DispSurface not initialized.");
+ return false;
+ }
+
+ if (mPrepared) {
+ // No mHwc prepare, if already prepared in current draw cycle
+ mList->hwLayers[mList->numHwLayers - 1].handle = dispSurface->lastHandle;
+ mList->hwLayers[mList->numHwLayers - 1].acquireFenceFd = dispSurface->GetPrevDispAcquireFd();
+ } else {
+ // Update screen rect to handle a case that TryRenderWithHwc() is not called.
+ mScreenRect = screen->GetNaturalBounds().ToUnknownRect();
+
+ mList->flags = HWC_GEOMETRY_CHANGED;
+ mList->numHwLayers = 2;
+ mList->hwLayers[0].hints = 0;
+ mList->hwLayers[0].compositionType = HWC_FRAMEBUFFER;
+ mList->hwLayers[0].flags = HWC_SKIP_LAYER;
+ mList->hwLayers[0].backgroundColor = {0};
+ mList->hwLayers[0].acquireFenceFd = -1;
+ mList->hwLayers[0].releaseFenceFd = -1;
+ mList->hwLayers[0].displayFrame = {0, 0, mScreenRect.width, mScreenRect.height};
+
+#if ANDROID_VERSION >= 21
+ // Prepare layers for sideband streams
+ const uint32_t len = mCachedSidebandLayers.Length();
+ for (uint32_t i = 0; i < len; ++i) {
+ ++mList->numHwLayers;
+ mList->hwLayers[i+1] = mCachedSidebandLayers[i];
+ }
+#endif
+ Prepare(dispSurface->lastHandle, dispSurface->GetPrevDispAcquireFd(), screen);
+ }
+
+ // GPU or partial HWC Composition
+ return Commit(screen);
+}
+
+void
+HwcComposer2D::Prepare(buffer_handle_t dispHandle, int fence, nsScreenGonk* screen)
+{
+ if (mPrepared) {
+ LOGE("Multiple hwc prepare calls!");
+ }
+ hwc_rect_t dispRect = {0, 0, mScreenRect.width, mScreenRect.height};
+ mHal->Prepare(mList, screen->GetDisplayType(), dispRect, dispHandle, fence);
+ mPrepared = true;
+}
+
+bool
+HwcComposer2D::Commit(nsScreenGonk* aScreen)
+{
+ for (uint32_t j=0; j < (mList->numHwLayers - 1); j++) {
+ mList->hwLayers[j].acquireFenceFd = -1;
+ if (mHwcLayerMap.IsEmpty() ||
+ (mList->hwLayers[j].compositionType == HWC_FRAMEBUFFER)) {
+ continue;
+ }
+ LayerRenderState state = mHwcLayerMap[j]->GetLayer()->GetRenderState();
+ if (!state.mTexture) {
+ continue;
+ }
+ FenceHandle fence = state.mTexture->GetAndResetAcquireFenceHandle();
+ if (fence.IsValid()) {
+ RefPtr<FenceHandle::FdObj> fdObj = fence.GetAndResetFdObj();
+ mList->hwLayers[j].acquireFenceFd = fdObj->GetAndResetFd();
+ }
+ }
+
+ int err = mHal->Set(mList, aScreen->GetDisplayType());
+
+ mPrevRetireFence.TransferToAnotherFenceHandle(mPrevDisplayFence);
+
+ for (uint32_t j=0; j < (mList->numHwLayers - 1); j++) {
+ if (mList->hwLayers[j].releaseFenceFd >= 0) {
+ int fd = mList->hwLayers[j].releaseFenceFd;
+ mList->hwLayers[j].releaseFenceFd = -1;
+ RefPtr<FenceHandle::FdObj> fdObj = new FenceHandle::FdObj(fd);
+ FenceHandle fence(fdObj);
+
+ LayerRenderState state = mHwcLayerMap[j]->GetLayer()->GetRenderState();
+ if (!state.mTexture) {
+ continue;
+ }
+ state.mTexture->SetReleaseFenceHandle(fence);
+ }
+ }
+
+ if (mList->retireFenceFd >= 0) {
+ mPrevRetireFence = FenceHandle(new FenceHandle::FdObj(mList->retireFenceFd));
+ }
+
+ // Set DisplaySurface layer fence
+ DisplaySurface* displaySurface = aScreen->GetDisplaySurface();
+ displaySurface->setReleaseFenceFd(mList->hwLayers[mList->numHwLayers - 1].releaseFenceFd);
+ mList->hwLayers[mList->numHwLayers - 1].releaseFenceFd = -1;
+
+ mPrepared = false;
+ return !err;
+}
+#else
+bool
+HwcComposer2D::TryHwComposition(nsScreenGonk* aScreen)
+{
+ mHal->SetEGLInfo(aScreen->GetEGLDisplay(), aScreen->GetEGLSurface());
+ return !mHal->Set(mList, aScreen->GetDisplayType());
+}
+
+bool
+HwcComposer2D::Render(nsIWidget* aWidget)
+{
+ nsScreenGonk* screen = static_cast<nsWindow*>(aWidget)->GetScreen();
+ return GetGonkDisplay()->SwapBuffers(screen->GetEGLDisplay(), screen->GetEGLSurface());
+}
+#endif
+
+bool
+HwcComposer2D::TryRenderWithHwc(Layer* aRoot,
+ nsIWidget* aWidget,
+ bool aGeometryChanged,
+ bool aHasImageHostOverlays)
+{
+ if (!mHal->HasHwc()) {
+ return false;
+ }
+
+ nsScreenGonk* screen = static_cast<nsWindow*>(aWidget)->GetScreen();
+
+ if (mList) {
+ mList->flags = mHal->GetGeometryChangedFlag(aGeometryChanged);
+ mList->numHwLayers = 0;
+ mHwcLayerMap.Clear();
+ }
+
+ if (mPrepared) {
+ mHal->ResetHwc();
+ mPrepared = false;
+ }
+
+ // XXX: The clear() below means all rect vectors will be have to be
+ // reallocated. We may want to avoid this if possible
+ mVisibleRegions.clear();
+
+ mScreenRect = screen->GetNaturalBounds().ToUnknownRect();
+ MOZ_ASSERT(mHwcLayerMap.IsEmpty());
+ mCachedSidebandLayers.Clear();
+ if (!PrepareLayerList(aRoot,
+ mScreenRect,
+ gfx::Matrix(),
+ /* aFindSidebandStreams */ false))
+ {
+ mHwcLayerMap.Clear();
+ LOGD("Render aborted. Fallback to GPU Composition");
+ if (aHasImageHostOverlays) {
+ LOGD("Prepare layers of SidebandStreams");
+ // Failed to create a layer list for hwc. But we need the list
+ // only for handling sideband streams. Traverse layer tree without
+ // some early returns to make sure we can find all the layers.
+ // It is the best wrong thing that we can do.
+ PrepareLayerList(aRoot,
+ mScreenRect,
+ gfx::Matrix(),
+ /* aFindSidebandStreams */ true);
+ // Reset mPrepared to false, since we already fell back to
+ // gpu composition.
+ mPrepared = false;
+ }
+ return false;
+ }
+
+ // Send data to LayerScope for debugging
+ SendtoLayerScope();
+
+ if (!TryHwComposition(screen)) {
+ LOGD("Full HWC Composition failed. Fallback to GPU Composition or partial OVERLAY Composition");
+ LayerScope::CleanLayer();
+ return false;
+ }
+
+ LOGD("Frame rendered");
+ return true;
+}
+
+void
+HwcComposer2D::SendtoLayerScope()
+{
+ if (!LayerScope::CheckSendable()) {
+ return;
+ }
+
+ const int len = mList->numHwLayers;
+ for (int i = 0; i < len; ++i) {
+ LayerComposite* layer = mHwcLayerMap[i];
+ const hwc_rect_t r = mList->hwLayers[i].displayFrame;
+ LayerScope::SendLayer(layer, r.right - r.left, r.bottom - r.top);
+ }
+}
+
+} // namespace mozilla