Switch SurfaceFlinger to HWC 2.0
Enables SurfaceFlinger to speak to version 2.0 of the Hardware Composer
HAL instead of version 1.x (also removing support for the framebuffer
HAL). By default, however, this functionality is disabled. In order to
enable it, USE_HWC2 must be set to true in Android.mk.
Change-Id: I4589e02ac2165236b10ff2f7cb772f87e0d3daab
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index d37fcb2..26f9519 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -14,6 +14,10 @@
* limitations under the License.
*/
+// #define LOG_NDEBUG 0
+
+#undef LOG_TAG
+#define LOG_TAG "HWComposer"
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
#include <inttypes.h>
@@ -43,6 +47,8 @@
#include <cutils/properties.h>
#include "HWComposer.h"
+#include "HWC2On1Adapter.h"
+#include "HWC2.h"
#include "../Layer.h" // needed only for debugging
#include "../SurfaceFlinger.h"
@@ -51,1088 +57,688 @@
#define MIN_HWC_HEADER_VERSION HWC_HEADER_VERSION
-static uint32_t hwcApiVersion(const hwc_composer_device_1_t* hwc) {
- uint32_t hwcVersion = hwc->common.version;
- return hwcVersion & HARDWARE_API_VERSION_2_MAJ_MIN_MASK;
-}
-
-static uint32_t hwcHeaderVersion(const hwc_composer_device_1_t* hwc) {
- uint32_t hwcVersion = hwc->common.version;
- return hwcVersion & HARDWARE_API_VERSION_2_HEADER_MASK;
-}
-
-static bool hwcHasApiVersion(const hwc_composer_device_1_t* hwc,
- uint32_t version) {
- return hwcApiVersion(hwc) >= (version & HARDWARE_API_VERSION_2_MAJ_MIN_MASK);
-}
-
// ---------------------------------------------------------------------------
-struct HWComposer::cb_context {
- struct callbacks : public hwc_procs_t {
- // these are here to facilitate the transition when adding
- // new callbacks (an implementation can check for NULL before
- // calling a new callback).
- void (*zero[4])(void);
- };
- callbacks procs;
- HWComposer* hwc;
-};
-
-// ---------------------------------------------------------------------------
-
-HWComposer::HWComposer(
- const sp<SurfaceFlinger>& flinger,
- EventHandler& handler)
+HWComposer::HWComposer(const sp<SurfaceFlinger>& flinger)
: mFlinger(flinger),
- mFbDev(0), mHwc(0), mNumDisplays(1),
- mCBContext(new cb_context),
- mEventHandler(handler),
- mDebugForceFakeVSync(false)
+ mAdapter(),
+ mHwcDevice(),
+ mDisplayData(2),
+ mFreeDisplaySlots(),
+ mHwcDisplaySlots(),
+ mCBContext(),
+ mEventHandler(nullptr),
+ mVSyncCounts(),
+ mRemainingHwcVirtualDisplays(0)
{
- for (size_t i =0 ; i<MAX_HWC_DISPLAYS ; i++) {
- mLists[i] = 0;
- }
-
for (size_t i=0 ; i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {
mLastHwVSync[i] = 0;
mVSyncCounts[i] = 0;
}
- char value[PROPERTY_VALUE_MAX];
- property_get("debug.sf.no_hw_vsync", value, "0");
- mDebugForceFakeVSync = atoi(value);
-
- bool needVSyncThread = true;
-
- // Note: some devices may insist that the FB HAL be opened before HWC.
- int fberr = loadFbHalModule();
loadHwcModule();
-
- if (mFbDev && mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // close FB HAL if we don't needed it.
- // FIXME: this is temporary until we're not forced to open FB HAL
- // before HWC.
- framebuffer_close(mFbDev);
- mFbDev = NULL;
- }
-
- // If we have no HWC, or a pre-1.1 HWC, an FB dev is mandatory.
- if ((!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
- && !mFbDev) {
- ALOGE("ERROR: failed to open framebuffer (%s), aborting",
- strerror(-fberr));
- abort();
- }
-
- // these display IDs are always reserved
- for (size_t i=0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {
- mAllocatedDisplayIDs.markBit(i);
- }
-
- if (mHwc) {
- ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,
- (hwcApiVersion(mHwc) >> 24) & 0xff,
- (hwcApiVersion(mHwc) >> 16) & 0xff);
- if (mHwc->registerProcs) {
- mCBContext->hwc = this;
- mCBContext->procs.invalidate = &hook_invalidate;
- mCBContext->procs.vsync = &hook_vsync;
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
- mCBContext->procs.hotplug = &hook_hotplug;
- else
- mCBContext->procs.hotplug = NULL;
- memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));
- mHwc->registerProcs(mHwc, &mCBContext->procs);
- }
-
- // don't need a vsync thread if we have a hardware composer
- needVSyncThread = false;
- // always turn vsync off when we start
- eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);
-
- // the number of displays we actually have depends on the
- // hw composer version
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
- // 1.3 adds support for virtual displays
- mNumDisplays = MAX_HWC_DISPLAYS;
- } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // 1.1 adds support for multiple displays
- mNumDisplays = NUM_BUILTIN_DISPLAYS;
- } else {
- mNumDisplays = 1;
- }
- }
-
- if (mFbDev) {
- ALOG_ASSERT(!(mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)),
- "should only have fbdev if no hwc or hwc is 1.0");
-
- DisplayData& disp(mDisplayData[HWC_DISPLAY_PRIMARY]);
- disp.connected = true;
- disp.format = mFbDev->format;
- DisplayConfig config = DisplayConfig();
- config.width = mFbDev->width;
- config.height = mFbDev->height;
- config.xdpi = mFbDev->xdpi;
- config.ydpi = mFbDev->ydpi;
- config.refresh = nsecs_t(1e9 / mFbDev->fps);
- disp.configs.push_back(config);
- disp.currentConfig = 0;
- } else if (mHwc) {
- // here we're guaranteed to have at least HWC 1.1
- for (size_t i =0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {
- queryDisplayProperties(i);
- }
- }
-
- if (needVSyncThread) {
- // we don't have VSYNC support, we need to fake it
- mVSyncThread = new VSyncThread(*this);
- }
}
-HWComposer::~HWComposer() {
- if (mHwc) {
- eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);
+HWComposer::~HWComposer() {}
+
+void HWComposer::setEventHandler(EventHandler* handler)
+{
+ if (handler == nullptr) {
+ ALOGE("setEventHandler: Rejected attempt to clear handler");
+ return;
}
- if (mVSyncThread != NULL) {
- mVSyncThread->requestExitAndWait();
+
+ bool wasNull = (mEventHandler == nullptr);
+ mEventHandler = handler;
+
+ if (wasNull) {
+ auto hotplugHook = std::bind(&HWComposer::hotplug, this,
+ std::placeholders::_1, std::placeholders::_2);
+ mHwcDevice->registerHotplugCallback(hotplugHook);
+ auto invalidateHook = std::bind(&HWComposer::invalidate, this,
+ std::placeholders::_1);
+ mHwcDevice->registerRefreshCallback(invalidateHook);
+ auto vsyncHook = std::bind(&HWComposer::vsync, this,
+ std::placeholders::_1, std::placeholders::_2);
+ mHwcDevice->registerVsyncCallback(vsyncHook);
}
- if (mHwc) {
- hwc_close_1(mHwc);
- }
- if (mFbDev) {
- framebuffer_close(mFbDev);
- }
- delete mCBContext;
}
// Load and prepare the hardware composer module. Sets mHwc.
void HWComposer::loadHwcModule()
{
+ ALOGV("loadHwcModule");
+
hw_module_t const* module;
if (hw_get_module(HWC_HARDWARE_MODULE_ID, &module) != 0) {
- ALOGE("%s module not found", HWC_HARDWARE_MODULE_ID);
- return;
+ ALOGE("%s module not found, aborting", HWC_HARDWARE_MODULE_ID);
+ abort();
}
- int err = hwc_open_1(module, &mHwc);
- if (err) {
- ALOGE("%s device failed to initialize (%s)",
- HWC_HARDWARE_COMPOSER, strerror(-err));
- return;
+ if (module->module_api_version >= 0x0200) {
+ hwc2_device_t* hwc2device = nullptr;
+ int error = hwc2_open(module, &hwc2device);
+ if (error != 0) {
+ ALOGE("Failed to open HWC2 device (%s), aborting", strerror(-error));
+ abort();
+ }
+ mHwcDevice = std::make_unique<HWC2::Device>(hwc2device);
+ } else {
+ hwc_composer_device_1_t* hwc1device = nullptr;
+ int error = hwc_open_1(module, &hwc1device);
+ if (error) {
+ ALOGE("Failed to open HWC1 device (%s), aborting", strerror(-error));
+ abort();
+ }
+ mAdapter = std::make_unique<HWC2On1Adapter>(hwc1device);
+ uint8_t minorVersion = mAdapter->getHwc1MinorVersion();
+ if (minorVersion < 1) {
+ ALOGE("Cannot adapt to HWC version %d.%d",
+ static_cast<int32_t>((minorVersion >> 8) & 0xF),
+ static_cast<int32_t>(minorVersion & 0xF));
+ abort();
+ }
+ mHwcDevice = std::make_unique<HWC2::Device>(
+ static_cast<hwc2_device_t*>(mAdapter.get()));
}
- if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_0) ||
- hwcHeaderVersion(mHwc) < MIN_HWC_HEADER_VERSION ||
- hwcHeaderVersion(mHwc) > HWC_HEADER_VERSION) {
- ALOGE("%s device version %#x unsupported, will not be used",
- HWC_HARDWARE_COMPOSER, mHwc->common.version);
- hwc_close_1(mHwc);
- mHwc = NULL;
- return;
+ mRemainingHwcVirtualDisplays = mHwcDevice->getMaxVirtualDisplayCount();
+}
+
+bool HWComposer::isValidDisplay(int32_t displayId) const {
+ return static_cast<size_t>(displayId) < mDisplayData.size() &&
+ mDisplayData[displayId].hwcDisplay;
+}
+
+void HWComposer::validateChange(HWC2::Composition from, HWC2::Composition to) {
+ bool valid = true;
+ switch (from) {
+ case HWC2::Composition::Client:
+ valid = false;
+ break;
+ case HWC2::Composition::Device:
+ case HWC2::Composition::SolidColor:
+ valid = (to == HWC2::Composition::Client);
+ break;
+ case HWC2::Composition::Cursor:
+ case HWC2::Composition::Sideband:
+ valid = (to == HWC2::Composition::Client ||
+ to == HWC2::Composition::Device);
+ break;
+ default:
+ break;
+ }
+
+ if (!valid) {
+ ALOGE("Invalid layer type change: %s --> %s", to_string(from).c_str(),
+ to_string(to).c_str());
}
}
-// Load and prepare the FB HAL, which uses the gralloc module. Sets mFbDev.
-int HWComposer::loadFbHalModule()
-{
- hw_module_t const* module;
-
- int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
- if (err != 0) {
- ALOGE("%s module not found", GRALLOC_HARDWARE_MODULE_ID);
- return err;
+void HWComposer::hotplug(const std::shared_ptr<HWC2::Display>& display,
+ HWC2::Connection connected) {
+ ALOGV("hotplug: %" PRIu64 ", %s", display->getId(),
+ to_string(connected).c_str());
+ int32_t disp = 0;
+ if (!mDisplayData[0].hwcDisplay) {
+ ALOGE_IF(connected != HWC2::Connection::Connected, "Assumed primary"
+ " display would be connected");
+ mDisplayData[0].hwcDisplay = display;
+ mHwcDisplaySlots[display->getId()] = 0;
+ disp = DisplayDevice::DISPLAY_PRIMARY;
+ } else {
+ // Disconnect is handled through HWComposer::disconnectDisplay via
+ // SurfaceFlinger's onHotplugReceived callback handling
+ if (connected == HWC2::Connection::Connected) {
+ mDisplayData[1].hwcDisplay = display;
+ mHwcDisplaySlots[display->getId()] = 1;
+ }
+ disp = DisplayDevice::DISPLAY_EXTERNAL;
}
-
- return framebuffer_open(module, &mFbDev);
+ mEventHandler->onHotplugReceived(disp,
+ connected == HWC2::Connection::Connected);
}
-status_t HWComposer::initCheck() const {
- return mHwc ? NO_ERROR : NO_INIT;
-}
-
-void HWComposer::hook_invalidate(const struct hwc_procs* procs) {
- cb_context* ctx = reinterpret_cast<cb_context*>(
- const_cast<hwc_procs_t*>(procs));
- ctx->hwc->invalidate();
-}
-
-void HWComposer::hook_vsync(const struct hwc_procs* procs, int disp,
- int64_t timestamp) {
- cb_context* ctx = reinterpret_cast<cb_context*>(
- const_cast<hwc_procs_t*>(procs));
- ctx->hwc->vsync(disp, timestamp);
-}
-
-void HWComposer::hook_hotplug(const struct hwc_procs* procs, int disp,
- int connected) {
- cb_context* ctx = reinterpret_cast<cb_context*>(
- const_cast<hwc_procs_t*>(procs));
- ctx->hwc->hotplug(disp, connected);
-}
-
-void HWComposer::invalidate() {
+void HWComposer::invalidate(const std::shared_ptr<HWC2::Display>& /*display*/) {
mFlinger->repaintEverything();
}
-void HWComposer::vsync(int disp, int64_t timestamp) {
- if (uint32_t(disp) < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
- {
- Mutex::Autolock _l(mLock);
-
- // There have been reports of HWCs that signal several vsync events
- // with the same timestamp when turning the display off and on. This
- // is a bug in the HWC implementation, but filter the extra events
- // out here so they don't cause havoc downstream.
- if (timestamp == mLastHwVSync[disp]) {
- ALOGW("Ignoring duplicate VSYNC event from HWC (t=%" PRId64 ")",
- timestamp);
- return;
- }
-
- mLastHwVSync[disp] = timestamp;
- }
-
- char tag[16];
- snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);
- ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);
-
- mEventHandler.onVSyncReceived(disp, timestamp);
- }
-}
-
-void HWComposer::hotplug(int disp, int connected) {
- if (disp >= VIRTUAL_DISPLAY_ID_BASE) {
- ALOGE("hotplug event received for invalid display: disp=%d connected=%d",
- disp, connected);
+void HWComposer::vsync(const std::shared_ptr<HWC2::Display>& display,
+ int64_t timestamp) {
+ auto displayType = HWC2::DisplayType::Invalid;
+ auto error = display->getType(&displayType);
+ if (error != HWC2::Error::None) {
+ ALOGE("vsync: Failed to determine type of display %" PRIu64,
+ display->getId());
return;
}
- queryDisplayProperties(disp);
- // Do not teardown or recreate the primary display
- if (disp != HWC_DISPLAY_PRIMARY) {
- mEventHandler.onHotplugReceived(disp, bool(connected));
- }
-}
-static float getDefaultDensity(uint32_t width, uint32_t height) {
- // Default density is based on TVs: 1080p displays get XHIGH density,
- // lower-resolution displays get TV density. Maybe eventually we'll need
- // to update it for 4K displays, though hopefully those just report
- // accurate DPI information to begin with. This is also used for virtual
- // displays and even primary displays with older hwcomposers, so be
- // careful about orientation.
-
- uint32_t h = width < height ? width : height;
- if (h >= 1080) return ACONFIGURATION_DENSITY_XHIGH;
- else return ACONFIGURATION_DENSITY_TV;
-}
-
-static const uint32_t DISPLAY_ATTRIBUTES[] = {
- HWC_DISPLAY_VSYNC_PERIOD,
- HWC_DISPLAY_WIDTH,
- HWC_DISPLAY_HEIGHT,
- HWC_DISPLAY_DPI_X,
- HWC_DISPLAY_DPI_Y,
- HWC_DISPLAY_COLOR_TRANSFORM,
- HWC_DISPLAY_NO_ATTRIBUTE,
-};
-#define NUM_DISPLAY_ATTRIBUTES (sizeof(DISPLAY_ATTRIBUTES) / sizeof(DISPLAY_ATTRIBUTES)[0])
-
-static const uint32_t PRE_HWC15_DISPLAY_ATTRIBUTES[] = {
- HWC_DISPLAY_VSYNC_PERIOD,
- HWC_DISPLAY_WIDTH,
- HWC_DISPLAY_HEIGHT,
- HWC_DISPLAY_DPI_X,
- HWC_DISPLAY_DPI_Y,
- HWC_DISPLAY_NO_ATTRIBUTE,
-};
-
-status_t HWComposer::queryDisplayProperties(int disp) {
-
- LOG_ALWAYS_FATAL_IF(!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1));
-
- // use zero as default value for unspecified attributes
- int32_t values[NUM_DISPLAY_ATTRIBUTES - 1];
- memset(values, 0, sizeof(values));
-
- const size_t MAX_NUM_CONFIGS = 128;
- uint32_t configs[MAX_NUM_CONFIGS] = {0};
- size_t numConfigs = MAX_NUM_CONFIGS;
- status_t err = mHwc->getDisplayConfigs(mHwc, disp, configs, &numConfigs);
- if (err != NO_ERROR) {
- // this can happen if an unpluggable display is not connected
- mDisplayData[disp].connected = false;
- return err;
+ if (displayType == HWC2::DisplayType::Virtual) {
+ ALOGE("Virtual display %" PRIu64 " passed to vsync callback",
+ display->getId());
+ return;
}
- mDisplayData[disp].currentConfig = 0;
- for (size_t c = 0; c < numConfigs; ++c) {
- err = mHwc->getDisplayAttributes(mHwc, disp, configs[c],
- DISPLAY_ATTRIBUTES, values);
- // If this is a pre-1.5 HWC, it may not know about color transform, so
- // try again with a smaller set of attributes
- if (err != NO_ERROR) {
- err = mHwc->getDisplayAttributes(mHwc, disp, configs[c],
- PRE_HWC15_DISPLAY_ATTRIBUTES, values);
- }
- if (err != NO_ERROR) {
- // we can't get this display's info. turn it off.
- mDisplayData[disp].connected = false;
- return err;
- }
-
- DisplayConfig config = DisplayConfig();
- for (size_t i = 0; i < NUM_DISPLAY_ATTRIBUTES - 1; i++) {
- switch (DISPLAY_ATTRIBUTES[i]) {
- case HWC_DISPLAY_VSYNC_PERIOD:
- config.refresh = nsecs_t(values[i]);
- break;
- case HWC_DISPLAY_WIDTH:
- config.width = values[i];
- break;
- case HWC_DISPLAY_HEIGHT:
- config.height = values[i];
- break;
- case HWC_DISPLAY_DPI_X:
- config.xdpi = values[i] / 1000.0f;
- break;
- case HWC_DISPLAY_DPI_Y:
- config.ydpi = values[i] / 1000.0f;
- break;
- case HWC_DISPLAY_COLOR_TRANSFORM:
- config.colorTransform = values[i];
- break;
- default:
- ALOG_ASSERT(false, "unknown display attribute[%zu] %#x",
- i, DISPLAY_ATTRIBUTES[i]);
- break;
- }
- }
-
- if (config.xdpi == 0.0f || config.ydpi == 0.0f) {
- float dpi = getDefaultDensity(config.width, config.height);
- config.xdpi = dpi;
- config.ydpi = dpi;
- }
-
- mDisplayData[disp].configs.push_back(config);
+ if (mHwcDisplaySlots.count(display->getId()) == 0) {
+ ALOGE("Unknown physical display %" PRIu64 " passed to vsync callback",
+ display->getId());
+ return;
}
- // FIXME: what should we set the format to?
- mDisplayData[disp].format = HAL_PIXEL_FORMAT_RGBA_8888;
- mDisplayData[disp].connected = true;
- return NO_ERROR;
-}
+ int32_t disp = mHwcDisplaySlots[display->getId()];
+ {
+ Mutex::Autolock _l(mLock);
-status_t HWComposer::setVirtualDisplayProperties(int32_t id,
- uint32_t w, uint32_t h, uint32_t format) {
- if (id < VIRTUAL_DISPLAY_ID_BASE || id >= int32_t(mNumDisplays) ||
- !mAllocatedDisplayIDs.hasBit(id)) {
- return BAD_INDEX;
+ // There have been reports of HWCs that signal several vsync events
+ // with the same timestamp when turning the display off and on. This
+ // is a bug in the HWC implementation, but filter the extra events
+ // out here so they don't cause havoc downstream.
+ if (timestamp == mLastHwVSync[disp]) {
+ ALOGW("Ignoring duplicate VSYNC event from HWC (t=%" PRId64 ")",
+ timestamp);
+ return;
+ }
+
+ mLastHwVSync[disp] = timestamp;
}
- size_t configId = mDisplayData[id].currentConfig;
- mDisplayData[id].format = format;
- DisplayConfig& config = mDisplayData[id].configs.editItemAt(configId);
- config.width = w;
- config.height = h;
- config.xdpi = config.ydpi = getDefaultDensity(w, h);
- return NO_ERROR;
+
+ char tag[16];
+ snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);
+ ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);
+
+ mEventHandler->onVSyncReceived(disp, timestamp);
}
-int32_t HWComposer::allocateDisplayId() {
- if (mAllocatedDisplayIDs.count() >= mNumDisplays) {
+status_t HWComposer::allocateVirtualDisplay(uint32_t width, uint32_t height,
+ int32_t *outId) {
+ if (mRemainingHwcVirtualDisplays == 0) {
+ ALOGE("allocateVirtualDisplay: No remaining virtual displays");
return NO_MEMORY;
}
- int32_t id = mAllocatedDisplayIDs.firstUnmarkedBit();
- mAllocatedDisplayIDs.markBit(id);
- mDisplayData[id].connected = true;
- mDisplayData[id].configs.resize(1);
- mDisplayData[id].currentConfig = 0;
- return id;
-}
-status_t HWComposer::freeDisplayId(int32_t id) {
- if (id < NUM_BUILTIN_DISPLAYS) {
- // cannot free the reserved IDs
- return BAD_VALUE;
+ std::shared_ptr<HWC2::Display> display;
+ auto error = mHwcDevice->createVirtualDisplay(width, height, &display);
+ if (error != HWC2::Error::None) {
+ ALOGE("allocateVirtualDisplay: Failed to create HWC virtual display");
+ return NO_MEMORY;
}
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
- return BAD_INDEX;
+
+ size_t displaySlot = 0;
+ if (!mFreeDisplaySlots.empty()) {
+ displaySlot = *mFreeDisplaySlots.begin();
+ mFreeDisplaySlots.erase(displaySlot);
+ } else if (mDisplayData.size() < INT32_MAX) {
+ // Don't bother allocating a slot larger than we can return
+ displaySlot = mDisplayData.size();
+ mDisplayData.resize(displaySlot + 1);
+ } else {
+ ALOGE("allocateVirtualDisplay: Unable to allocate a display slot");
+ return NO_MEMORY;
}
- mAllocatedDisplayIDs.clearBit(id);
- mDisplayData[id].connected = false;
+
+ mDisplayData[displaySlot].hwcDisplay = display;
+
+ --mRemainingHwcVirtualDisplays;
+ *outId = static_cast<int32_t>(displaySlot);
+
return NO_ERROR;
}
-nsecs_t HWComposer::getRefreshTimestamp(int disp) const {
+std::shared_ptr<HWC2::Layer> HWComposer::createLayer(int32_t displayId) {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("Failed to create layer on invalid display %d", displayId);
+ return nullptr;
+ }
+ auto display = mDisplayData[displayId].hwcDisplay;
+ std::shared_ptr<HWC2::Layer> layer;
+ auto error = display->createLayer(&layer);
+ if (error != HWC2::Error::None) {
+ ALOGE("Failed to create layer on display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return nullptr;
+ }
+ return layer;
+}
+
+nsecs_t HWComposer::getRefreshTimestamp(int32_t disp) const {
// this returns the last refresh timestamp.
// if the last one is not available, we estimate it based on
// the refresh period and whatever closest timestamp we have.
Mutex::Autolock _l(mLock);
nsecs_t now = systemTime(CLOCK_MONOTONIC);
- size_t configId = mDisplayData[disp].currentConfig;
- return now - ((now - mLastHwVSync[disp]) %
- mDisplayData[disp].configs[configId].refresh);
+ auto vsyncPeriod = getActiveConfig(disp)->getVsyncPeriod();
+ return now - ((now - mLastHwVSync[disp]) % vsyncPeriod);
}
-sp<Fence> HWComposer::getDisplayFence(int disp) const {
- return mDisplayData[disp].lastDisplayFence;
-}
-
-uint32_t HWComposer::getFormat(int disp) const {
- if (static_cast<uint32_t>(disp) >= MAX_HWC_DISPLAYS || !mAllocatedDisplayIDs.hasBit(disp)) {
- return HAL_PIXEL_FORMAT_RGBA_8888;
- } else {
- return mDisplayData[disp].format;
- }
-}
-
-bool HWComposer::isConnected(int disp) const {
- return mDisplayData[disp].connected;
-}
-
-uint32_t HWComposer::getWidth(int disp) const {
- size_t currentConfig = mDisplayData[disp].currentConfig;
- return mDisplayData[disp].configs[currentConfig].width;
-}
-
-uint32_t HWComposer::getHeight(int disp) const {
- size_t currentConfig = mDisplayData[disp].currentConfig;
- return mDisplayData[disp].configs[currentConfig].height;
-}
-
-float HWComposer::getDpiX(int disp) const {
- size_t currentConfig = mDisplayData[disp].currentConfig;
- return mDisplayData[disp].configs[currentConfig].xdpi;
-}
-
-float HWComposer::getDpiY(int disp) const {
- size_t currentConfig = mDisplayData[disp].currentConfig;
- return mDisplayData[disp].configs[currentConfig].ydpi;
-}
-
-nsecs_t HWComposer::getRefreshPeriod(int disp) const {
- size_t currentConfig = mDisplayData[disp].currentConfig;
- return mDisplayData[disp].configs[currentConfig].refresh;
-}
-
-const Vector<HWComposer::DisplayConfig>& HWComposer::getConfigs(int disp) const {
- return mDisplayData[disp].configs;
-}
-
-size_t HWComposer::getCurrentConfig(int disp) const {
- return mDisplayData[disp].currentConfig;
-}
-
-void HWComposer::eventControl(int disp, int event, int enabled) {
- if (uint32_t(disp)>31 || !mAllocatedDisplayIDs.hasBit(disp)) {
- ALOGD("eventControl ignoring event %d on unallocated disp %d (en=%d)",
- event, disp, enabled);
- return;
- }
- if (event != EVENT_VSYNC) {
- ALOGW("eventControl got unexpected event %d (disp=%d en=%d)",
- event, disp, enabled);
- return;
- }
- status_t err = NO_ERROR;
- if (mHwc && !mDebugForceFakeVSync) {
- // NOTE: we use our own internal lock here because we have to call
- // into the HWC with the lock held, and we want to make sure
- // that even if HWC blocks (which it shouldn't), it won't
- // affect other threads.
- Mutex::Autolock _l(mEventControlLock);
- const int32_t eventBit = 1UL << event;
- const int32_t newValue = enabled ? eventBit : 0;
- const int32_t oldValue = mDisplayData[disp].events & eventBit;
- if (newValue != oldValue) {
- ATRACE_CALL();
- err = mHwc->eventControl(mHwc, disp, event, enabled);
- if (!err) {
- int32_t& events(mDisplayData[disp].events);
- events = (events & ~eventBit) | newValue;
-
- char tag[16];
- snprintf(tag, sizeof(tag), "HW_VSYNC_ON_%1u", disp);
- ATRACE_INT(tag, enabled);
- }
- }
- // error here should not happen -- not sure what we should
- // do if it does.
- ALOGE_IF(err, "eventControl(%d, %d) failed %s",
- event, enabled, strerror(-err));
- }
-
- if (err == NO_ERROR && mVSyncThread != NULL) {
- mVSyncThread->setEnabled(enabled);
- }
-}
-
-status_t HWComposer::createWorkList(int32_t id, size_t numLayers) {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
- return BAD_INDEX;
- }
-
- if (mHwc) {
- DisplayData& disp(mDisplayData[id]);
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // we need space for the HWC_FRAMEBUFFER_TARGET
- numLayers++;
- }
- if (disp.capacity < numLayers || disp.list == NULL) {
- size_t size = sizeof(hwc_display_contents_1_t)
- + numLayers * sizeof(hwc_layer_1_t);
- free(disp.list);
- disp.list = (hwc_display_contents_1_t*)malloc(size);
- disp.capacity = numLayers;
- }
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- disp.framebufferTarget = &disp.list->hwLayers[numLayers - 1];
- memset(disp.framebufferTarget, 0, sizeof(hwc_layer_1_t));
- const DisplayConfig& currentConfig =
- disp.configs[disp.currentConfig];
- const hwc_rect_t r = { 0, 0,
- (int) currentConfig.width, (int) currentConfig.height };
- disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
- disp.framebufferTarget->hints = 0;
- disp.framebufferTarget->flags = 0;
- disp.framebufferTarget->handle = disp.fbTargetHandle;
- disp.framebufferTarget->transform = 0;
- disp.framebufferTarget->blending = HWC_BLENDING_PREMULT;
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
- disp.framebufferTarget->sourceCropf.left = 0;
- disp.framebufferTarget->sourceCropf.top = 0;
- disp.framebufferTarget->sourceCropf.right =
- currentConfig.width;
- disp.framebufferTarget->sourceCropf.bottom =
- currentConfig.height;
- } else {
- disp.framebufferTarget->sourceCrop = r;
- }
- disp.framebufferTarget->displayFrame = r;
- disp.framebufferTarget->visibleRegionScreen.numRects = 1;
- disp.framebufferTarget->visibleRegionScreen.rects =
- &disp.framebufferTarget->displayFrame;
- disp.framebufferTarget->acquireFenceFd = -1;
- disp.framebufferTarget->releaseFenceFd = -1;
- disp.framebufferTarget->planeAlpha = 0xFF;
- }
- disp.list->retireFenceFd = -1;
- disp.list->flags = HWC_GEOMETRY_CHANGED;
- disp.list->numHwLayers = numLayers;
- }
- return NO_ERROR;
-}
-
-status_t HWComposer::setFramebufferTarget(int32_t id,
- const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf) {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
- return BAD_INDEX;
- }
- DisplayData& disp(mDisplayData[id]);
- if (!disp.framebufferTarget) {
- // this should never happen, but apparently eglCreateWindowSurface()
- // triggers a Surface::queueBuffer() on some
- // devices (!?) -- log and ignore.
- ALOGE("HWComposer: framebufferTarget is null");
- return NO_ERROR;
- }
-
- int acquireFenceFd = -1;
- if (acquireFence->isValid()) {
- acquireFenceFd = acquireFence->dup();
- }
-
- // ALOGD("fbPost: handle=%p, fence=%d", buf->handle, acquireFenceFd);
- disp.fbTargetHandle = buf->handle;
- disp.framebufferTarget->handle = disp.fbTargetHandle;
- disp.framebufferTarget->acquireFenceFd = acquireFenceFd;
- return NO_ERROR;
-}
-
-status_t HWComposer::prepare() {
- Mutex::Autolock _l(mDisplayLock);
- for (size_t i=0 ; i<mNumDisplays ; i++) {
- DisplayData& disp(mDisplayData[i]);
- if (disp.framebufferTarget) {
- // make sure to reset the type to HWC_FRAMEBUFFER_TARGET
- // DO NOT reset the handle field to NULL, because it's possible
- // that we have nothing to redraw (eg: eglSwapBuffers() not called)
- // in which case, we should continue to use the same buffer.
- LOG_FATAL_IF(disp.list == NULL);
- disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
- }
- if (!disp.connected && disp.list != NULL) {
- ALOGW("WARNING: disp %zu: connected, non-null list, layers=%zu",
- i, disp.list->numHwLayers);
- }
- mLists[i] = disp.list;
- if (mLists[i]) {
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
- mLists[i]->outbuf = disp.outbufHandle;
- mLists[i]->outbufAcquireFenceFd = -1;
- } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // garbage data to catch improper use
- mLists[i]->dpy = (hwc_display_t)0xDEADBEEF;
- mLists[i]->sur = (hwc_surface_t)0xDEADBEEF;
- } else {
- mLists[i]->dpy = EGL_NO_DISPLAY;
- mLists[i]->sur = EGL_NO_SURFACE;
- }
- }
- }
-
- int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
- ALOGE_IF(err, "HWComposer: prepare failed (%s)", strerror(-err));
-
- if (err == NO_ERROR) {
- // here we're just making sure that "skip" layers are set
- // to HWC_FRAMEBUFFER and we're also counting how many layers
- // we have of each type.
- //
- // If there are no window layers, we treat the display has having FB
- // composition, because SurfaceFlinger will use GLES to draw the
- // wormhole region.
- for (size_t i=0 ; i<mNumDisplays ; i++) {
- DisplayData& disp(mDisplayData[i]);
- disp.hasFbComp = false;
- disp.hasOvComp = false;
- if (disp.list) {
- for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {
- hwc_layer_1_t& l = disp.list->hwLayers[i];
-
- //ALOGD("prepare: %d, type=%d, handle=%p",
- // i, l.compositionType, l.handle);
-
- if (l.flags & HWC_SKIP_LAYER) {
- l.compositionType = HWC_FRAMEBUFFER;
- }
- if (l.compositionType == HWC_FRAMEBUFFER) {
- disp.hasFbComp = true;
- }
- if (l.compositionType == HWC_OVERLAY) {
- disp.hasOvComp = true;
- }
- if (l.compositionType == HWC_CURSOR_OVERLAY) {
- disp.hasOvComp = true;
- }
- }
- if (disp.list->numHwLayers == (disp.framebufferTarget ? 1 : 0)) {
- disp.hasFbComp = true;
- }
- } else {
- disp.hasFbComp = true;
- }
- }
- }
- return (status_t)err;
-}
-
-bool HWComposer::hasHwcComposition(int32_t id) const {
- if (!mHwc || uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
+bool HWComposer::isConnected(int32_t disp) const {
+ if (!isValidDisplay(disp)) {
+ ALOGE("isConnected: Attempted to access invalid display %d", disp);
return false;
- return mDisplayData[id].hasOvComp;
+ }
+ return mDisplayData[disp].hwcDisplay->isConnected();
}
-bool HWComposer::hasGlesComposition(int32_t id) const {
- if (!mHwc || uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
- return true;
- return mDisplayData[id].hasFbComp;
-}
-
-sp<Fence> HWComposer::getAndResetReleaseFence(int32_t id) {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
- return Fence::NO_FENCE;
-
- int fd = INVALID_OPERATION;
- if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- const DisplayData& disp(mDisplayData[id]);
- if (disp.framebufferTarget) {
- fd = disp.framebufferTarget->releaseFenceFd;
- disp.framebufferTarget->acquireFenceFd = -1;
- disp.framebufferTarget->releaseFenceFd = -1;
+std::vector<std::shared_ptr<const HWC2::Display::Config>>
+ HWComposer::getConfigs(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getConfigs: Attempted to access invalid display %d", displayId);
+ return {};
+ }
+ auto& displayData = mDisplayData[displayId];
+ auto configs = mDisplayData[displayId].hwcDisplay->getConfigs();
+ if (displayData.configMap.empty()) {
+ for (size_t i = 0; i < configs.size(); ++i) {
+ displayData.configMap[i] = configs[i];
}
}
- return fd >= 0 ? new Fence(fd) : Fence::NO_FENCE;
+ return configs;
}
-status_t HWComposer::commit() {
- int err = NO_ERROR;
- if (mHwc) {
- if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // On version 1.0, the OpenGL ES target surface is communicated
- // by the (dpy, sur) fields and we are guaranteed to have only
- // a single display.
- mLists[0]->dpy = eglGetCurrentDisplay();
- mLists[0]->sur = eglGetCurrentSurface(EGL_DRAW);
- }
-
- for (size_t i=VIRTUAL_DISPLAY_ID_BASE; i<mNumDisplays; i++) {
- DisplayData& disp(mDisplayData[i]);
- if (disp.outbufHandle) {
- mLists[i]->outbuf = disp.outbufHandle;
- mLists[i]->outbufAcquireFenceFd =
- disp.outbufAcquireFence->dup();
- }
- }
-
- err = mHwc->set(mHwc, mNumDisplays, mLists);
-
- for (size_t i=0 ; i<mNumDisplays ; i++) {
- DisplayData& disp(mDisplayData[i]);
- disp.lastDisplayFence = disp.lastRetireFence;
- disp.lastRetireFence = Fence::NO_FENCE;
- if (disp.list) {
- if (disp.list->retireFenceFd != -1) {
- disp.lastRetireFence = new Fence(disp.list->retireFenceFd);
- disp.list->retireFenceFd = -1;
- }
- disp.list->flags &= ~HWC_GEOMETRY_CHANGED;
- }
- }
+std::shared_ptr<const HWC2::Display::Config>
+ HWComposer::getActiveConfig(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getActiveConfigs: Attempted to access invalid display %d",
+ displayId);
+ return nullptr;
}
- return (status_t)err;
+ std::shared_ptr<const HWC2::Display::Config> config;
+ auto error = mDisplayData[displayId].hwcDisplay->getActiveConfig(&config);
+ if (error == HWC2::Error::BadConfig) {
+ ALOGV("getActiveConfig: No config active, returning null");
+ return nullptr;
+ } else if (error != HWC2::Error::None) {
+ ALOGE("getActiveConfig failed for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return nullptr;
+ } else if (!config) {
+ ALOGE("getActiveConfig returned an unknown config for display %d",
+ displayId);
+ return nullptr;
+ }
+
+ return config;
}
-status_t HWComposer::setPowerMode(int disp, int mode) {
- LOG_FATAL_IF(disp >= VIRTUAL_DISPLAY_ID_BASE);
- if (mHwc) {
- if (mode == HWC_POWER_MODE_OFF) {
- eventControl(disp, HWC_EVENT_VSYNC, 0);
- }
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_4)) {
- return (status_t)mHwc->setPowerMode(mHwc, disp, mode);
+void HWComposer::setVsyncEnabled(int32_t disp, HWC2::Vsync enabled) {
+ if (disp < 0 || disp >= HWC_DISPLAY_VIRTUAL) {
+ ALOGD("setVsyncEnabled: Ignoring for virtual display %d", disp);
+ return;
+ }
+
+ if (!isValidDisplay(disp)) {
+ ALOGE("setVsyncEnabled: Attempted to access invalid display %d", disp);
+ return;
+ }
+
+ // NOTE: we use our own internal lock here because we have to call
+ // into the HWC with the lock held, and we want to make sure
+ // that even if HWC blocks (which it shouldn't), it won't
+ // affect other threads.
+ Mutex::Autolock _l(mVsyncLock);
+ auto& displayData = mDisplayData[disp];
+ if (enabled != displayData.vsyncEnabled) {
+ ATRACE_CALL();
+ auto error = displayData.hwcDisplay->setVsyncEnabled(enabled);
+ if (error == HWC2::Error::None) {
+ displayData.vsyncEnabled = enabled;
+
+ char tag[16];
+ snprintf(tag, sizeof(tag), "HW_VSYNC_ON_%1u", disp);
+ ATRACE_INT(tag, enabled == HWC2::Vsync::Enable ? 1 : 0);
} else {
- return (status_t)mHwc->blank(mHwc, disp,
- mode == HWC_POWER_MODE_OFF ? 1 : 0);
+ ALOGE("setVsyncEnabled: Failed to set vsync to %s on %d/%" PRIu64
+ ": %s (%d)", to_string(enabled).c_str(), disp,
+ mDisplayData[disp].hwcDisplay->getId(),
+ to_string(error).c_str(), static_cast<int32_t>(error));
}
}
- return NO_ERROR;
}
-status_t HWComposer::setActiveConfig(int disp, int mode) {
- LOG_FATAL_IF(disp >= VIRTUAL_DISPLAY_ID_BASE);
- DisplayData& dd(mDisplayData[disp]);
- dd.currentConfig = mode;
- if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_4)) {
- return (status_t)mHwc->setActiveConfig(mHwc, disp, mode);
- } else {
- LOG_FATAL_IF(mode != 0);
- }
- return NO_ERROR;
-}
-
-void HWComposer::disconnectDisplay(int disp) {
- LOG_ALWAYS_FATAL_IF(disp < 0 || disp == HWC_DISPLAY_PRIMARY);
- DisplayData& dd(mDisplayData[disp]);
- free(dd.list);
- dd.list = NULL;
- dd.framebufferTarget = NULL; // points into dd.list
- dd.fbTargetHandle = NULL;
- dd.outbufHandle = NULL;
- dd.lastRetireFence = Fence::NO_FENCE;
- dd.lastDisplayFence = Fence::NO_FENCE;
- dd.outbufAcquireFence = Fence::NO_FENCE;
- // clear all the previous configs and repopulate when a new
- // device is added
- dd.configs.clear();
-}
-
-int HWComposer::getVisualID() const {
- if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // FIXME: temporary hack until HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
- // is supported by the implementation. we can only be in this case
- // if we have HWC 1.1
- return HAL_PIXEL_FORMAT_RGBA_8888;
- //return HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
- } else {
- return mFbDev->format;
- }
-}
-
-bool HWComposer::supportsFramebufferTarget() const {
- return (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1));
-}
-
-int HWComposer::fbPost(int32_t id,
- const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buffer) {
- if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- return setFramebufferTarget(id, acquireFence, buffer);
- } else {
- acquireFence->waitForever("HWComposer::fbPost");
- return mFbDev->post(mFbDev, buffer->handle);
- }
-}
-
-int HWComposer::fbCompositionComplete() {
- if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
- return NO_ERROR;
-
- if (mFbDev->compositionComplete) {
- return mFbDev->compositionComplete(mFbDev);
- } else {
- return INVALID_OPERATION;
- }
-}
-
-void HWComposer::fbDump(String8& result) {
- if (mFbDev && mFbDev->common.version >= 1 && mFbDev->dump) {
- const size_t SIZE = 4096;
- char buffer[SIZE];
- mFbDev->dump(mFbDev, buffer, SIZE);
- result.append(buffer);
- }
-}
-
-status_t HWComposer::setOutputBuffer(int32_t id, const sp<Fence>& acquireFence,
- const sp<GraphicBuffer>& buf) {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
+status_t HWComposer::setClientTarget(int32_t displayId,
+ const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
+ android_dataspace_t dataspace) {
+ if (!isValidDisplay(displayId)) {
return BAD_INDEX;
- if (id < VIRTUAL_DISPLAY_ID_BASE)
- return INVALID_OPERATION;
+ }
- DisplayData& disp(mDisplayData[id]);
- disp.outbufHandle = buf->handle;
- disp.outbufAcquireFence = acquireFence;
+ ALOGV("setClientTarget for display %d", displayId);
+ auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
+ buffer_handle_t handle = nullptr;
+ if ((target != nullptr) && target->getNativeBuffer()) {
+ handle = target->getNativeBuffer()->handle;
+ }
+ auto error = hwcDisplay->setClientTarget(handle, acquireFence, dataspace);
+ if (error != HWC2::Error::None) {
+ ALOGE("Failed to set client target for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return BAD_VALUE;
+ }
+
return NO_ERROR;
}
-sp<Fence> HWComposer::getLastRetireFence(int32_t id) const {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
+status_t HWComposer::prepare(DisplayDevice& displayDevice) {
+ ATRACE_CALL();
+
+ Mutex::Autolock _l(mDisplayLock);
+ auto displayId = displayDevice.getHwcDisplayId();
+ if (!isValidDisplay(displayId)) {
+ return BAD_INDEX;
+ }
+
+ auto& displayData = mDisplayData[displayId];
+ auto& hwcDisplay = displayData.hwcDisplay;
+ if (!hwcDisplay->isConnected()) {
+ return NO_ERROR;
+ }
+
+ uint32_t numTypes = 0;
+ uint32_t numRequests = 0;
+ auto error = hwcDisplay->validate(&numTypes, &numRequests);
+ if (error != HWC2::Error::None && error != HWC2::Error::HasChanges) {
+ ALOGE("prepare: validate failed for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return BAD_INDEX;
+ }
+
+ std::unordered_map<std::shared_ptr<HWC2::Layer>, HWC2::Composition>
+ changedTypes;
+ changedTypes.reserve(numTypes);
+ error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
+ if (error != HWC2::Error::None) {
+ ALOGE("prepare: getChangedCompositionTypes failed on display %d: "
+ "%s (%d)", displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ return BAD_INDEX;
+ }
+
+
+ displayData.displayRequests = static_cast<HWC2::DisplayRequest>(0);
+ std::unordered_map<std::shared_ptr<HWC2::Layer>, HWC2::LayerRequest>
+ layerRequests;
+ layerRequests.reserve(numRequests);
+ error = hwcDisplay->getRequests(&displayData.displayRequests,
+ &layerRequests);
+ if (error != HWC2::Error::None) {
+ ALOGE("prepare: getRequests failed on display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return BAD_INDEX;
+ }
+
+ displayData.hasClientComposition = false;
+ displayData.hasDeviceComposition = false;
+ for (auto& layer : displayDevice.getVisibleLayersSortedByZ()) {
+ auto hwcLayer = layer->getHwcLayer(displayId);
+
+ if (changedTypes.count(hwcLayer) != 0) {
+ // We pass false so we only update our state and don't call back
+ // into the HWC device
+ validateChange(layer->getCompositionType(displayId),
+ changedTypes[hwcLayer]);
+ layer->setCompositionType(displayId, changedTypes[hwcLayer], false);
+ }
+
+ switch (layer->getCompositionType(displayId)) {
+ case HWC2::Composition::Client:
+ displayData.hasClientComposition = true;
+ break;
+ case HWC2::Composition::Device:
+ case HWC2::Composition::SolidColor:
+ case HWC2::Composition::Cursor:
+ case HWC2::Composition::Sideband:
+ displayData.hasDeviceComposition = true;
+ break;
+ default:
+ break;
+ }
+
+ if (layerRequests.count(hwcLayer) != 0 &&
+ layerRequests[hwcLayer] ==
+ HWC2::LayerRequest::ClearClientTarget) {
+ layer->setClearClientTarget(displayId, true);
+ } else {
+ if (layerRequests.count(hwcLayer) != 0) {
+ ALOGE("prepare: Unknown layer request: %s",
+ to_string(layerRequests[hwcLayer]).c_str());
+ }
+ layer->setClearClientTarget(displayId, false);
+ }
+ }
+
+ error = hwcDisplay->acceptChanges();
+ if (error != HWC2::Error::None) {
+ ALOGE("prepare: acceptChanges failed: %s", to_string(error).c_str());
+ return BAD_INDEX;
+ }
+
+ return NO_ERROR;
+}
+
+bool HWComposer::hasDeviceComposition(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("hasDeviceComposition: Invalid display %d", displayId);
+ return false;
+ }
+ return mDisplayData[displayId].hasDeviceComposition;
+}
+
+bool HWComposer::hasClientComposition(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("hasClientComposition: Invalid display %d", displayId);
+ return true;
+ }
+ return mDisplayData[displayId].hasClientComposition;
+}
+
+sp<Fence> HWComposer::getRetireFence(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getRetireFence failed for invalid display %d", displayId);
return Fence::NO_FENCE;
- return mDisplayData[id].lastRetireFence;
+ }
+ return mDisplayData[displayId].lastRetireFence;
}
-status_t HWComposer::setCursorPositionAsync(int32_t id, const Rect& pos)
-{
- if (mHwc->setCursorPositionAsync) {
- return (status_t)mHwc->setCursorPositionAsync(mHwc, id, pos.left, pos.top);
+sp<Fence> HWComposer::getLayerReleaseFence(int32_t displayId,
+ const std::shared_ptr<HWC2::Layer>& layer) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getLayerReleaseFence: Invalid display");
+ return Fence::NO_FENCE;
}
- else {
- return NO_ERROR;
+ auto displayFences = mDisplayData[displayId].releaseFences;
+ if (displayFences.count(layer) == 0) {
+ ALOGV("getLayerReleaseFence: Release fence not found");
+ return Fence::NO_FENCE;
}
+ return displayFences[layer];
}
-/*
- * Helper template to implement a concrete HWCLayer
- * This holds the pointer to the concrete hwc layer type
- * and implements the "iterable" side of HWCLayer.
- */
-template<typename CONCRETE, typename HWCTYPE>
-class Iterable : public HWComposer::HWCLayer {
-protected:
- HWCTYPE* const mLayerList;
- HWCTYPE* mCurrentLayer;
- Iterable(HWCTYPE* layer) : mLayerList(layer), mCurrentLayer(layer) { }
- inline HWCTYPE const * getLayer() const { return mCurrentLayer; }
- inline HWCTYPE* getLayer() { return mCurrentLayer; }
- virtual ~Iterable() { }
-private:
- // returns a copy of ourselves
- virtual HWComposer::HWCLayer* dup() {
- return new CONCRETE( static_cast<const CONCRETE&>(*this) );
- }
- virtual status_t setLayer(size_t index) {
- mCurrentLayer = &mLayerList[index];
- return NO_ERROR;
- }
-};
+status_t HWComposer::commit(int32_t displayId) {
+ ATRACE_CALL();
-/*
- * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_1_0.
- * This implements the HWCLayer side of HWCIterableLayer.
- */
-class HWCLayerVersion1 : public Iterable<HWCLayerVersion1, hwc_layer_1_t> {
- struct hwc_composer_device_1* mHwc;
-public:
- HWCLayerVersion1(struct hwc_composer_device_1* hwc, hwc_layer_1_t* layer)
- : Iterable<HWCLayerVersion1, hwc_layer_1_t>(layer), mHwc(hwc) { }
-
- virtual int32_t getCompositionType() const {
- return getLayer()->compositionType;
- }
- virtual uint32_t getHints() const {
- return getLayer()->hints;
- }
- virtual sp<Fence> getAndResetReleaseFence() {
- int fd = getLayer()->releaseFenceFd;
- getLayer()->releaseFenceFd = -1;
- return fd >= 0 ? new Fence(fd) : Fence::NO_FENCE;
- }
- virtual void setAcquireFenceFd(int fenceFd) {
- getLayer()->acquireFenceFd = fenceFd;
- }
- virtual void setPerFrameDefaultState() {
- //getLayer()->compositionType = HWC_FRAMEBUFFER;
- }
- virtual void setPlaneAlpha(uint8_t alpha) {
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {
- getLayer()->planeAlpha = alpha;
- } else {
- if (alpha < 0xFF) {
- getLayer()->flags |= HWC_SKIP_LAYER;
- }
- }
- }
- virtual void setDefaultState() {
- hwc_layer_1_t* const l = getLayer();
- l->compositionType = HWC_FRAMEBUFFER;
- l->hints = 0;
- l->flags = HWC_SKIP_LAYER;
- l->handle = 0;
- l->transform = 0;
- l->blending = HWC_BLENDING_NONE;
- l->visibleRegionScreen.numRects = 0;
- l->visibleRegionScreen.rects = NULL;
- l->acquireFenceFd = -1;
- l->releaseFenceFd = -1;
- l->planeAlpha = 0xFF;
- }
- virtual void setSkip(bool skip) {
- if (skip) {
- getLayer()->flags |= HWC_SKIP_LAYER;
- } else {
- getLayer()->flags &= ~HWC_SKIP_LAYER;
- }
- }
- virtual void setIsCursorLayerHint(bool isCursor) {
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_4)) {
- if (isCursor) {
- getLayer()->flags |= HWC_IS_CURSOR_LAYER;
- }
- else {
- getLayer()->flags &= ~HWC_IS_CURSOR_LAYER;
- }
- }
- }
- virtual void setBlending(uint32_t blending) {
- getLayer()->blending = blending;
- }
- virtual void setTransform(uint32_t transform) {
- getLayer()->transform = transform;
- }
- virtual void setFrame(const Rect& frame) {
- getLayer()->displayFrame = reinterpret_cast<hwc_rect_t const&>(frame);
- }
- virtual void setCrop(const FloatRect& crop) {
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
- getLayer()->sourceCropf = reinterpret_cast<hwc_frect_t const&>(crop);
- } else {
- /*
- * Since h/w composer didn't support a flot crop rect before version 1.3,
- * using integer coordinates instead produces a different output from the GL code in
- * Layer::drawWithOpenGL(). The difference can be large if the buffer crop to
- * window size ratio is large and a window crop is defined
- * (i.e.: if we scale the buffer a lot and we also crop it with a window crop).
- */
- hwc_rect_t& r = getLayer()->sourceCrop;
- r.left = int(ceilf(crop.left));
- r.top = int(ceilf(crop.top));
- r.right = int(floorf(crop.right));
- r.bottom= int(floorf(crop.bottom));
- }
- }
- virtual void setVisibleRegionScreen(const Region& reg) {
- hwc_region_t& visibleRegion = getLayer()->visibleRegionScreen;
- mVisibleRegion = reg;
- visibleRegion.rects = reinterpret_cast<hwc_rect_t const *>(
- mVisibleRegion.getArray(&visibleRegion.numRects));
- }
- virtual void setSurfaceDamage(const Region& reg) {
- if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_5)) {
- return;
- }
- hwc_region_t& surfaceDamage = getLayer()->surfaceDamage;
- // We encode default full-screen damage as INVALID_RECT upstream, but as
- // 0 rects for HWComposer
- if (reg.isRect() && reg.getBounds() == Rect::INVALID_RECT) {
- surfaceDamage.numRects = 0;
- surfaceDamage.rects = NULL;
- return;
- }
- mSurfaceDamage = reg;
- surfaceDamage.rects = reinterpret_cast<hwc_rect_t const *>(
- mSurfaceDamage.getArray(&surfaceDamage.numRects));
- }
- virtual void setSidebandStream(const sp<NativeHandle>& stream) {
- ALOG_ASSERT(stream->handle() != NULL);
- getLayer()->compositionType = HWC_SIDEBAND;
- getLayer()->sidebandStream = stream->handle();
- }
- virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
- if (buffer == 0 || buffer->handle == 0) {
- getLayer()->compositionType = HWC_FRAMEBUFFER;
- getLayer()->flags |= HWC_SKIP_LAYER;
- getLayer()->handle = 0;
- } else {
- if (getLayer()->compositionType == HWC_SIDEBAND) {
- // If this was a sideband layer but the stream was removed, reset
- // it to FRAMEBUFFER. The HWC can change it to OVERLAY in prepare.
- getLayer()->compositionType = HWC_FRAMEBUFFER;
- }
- getLayer()->handle = buffer->handle;
- }
- }
- virtual void onDisplayed() {
- getLayer()->acquireFenceFd = -1;
+ if (!isValidDisplay(displayId)) {
+ return BAD_INDEX;
}
-protected:
- // We need to hold "copies" of these for memory management purposes. The
- // actual hwc_layer_1_t holds pointers to the memory within. Vector<>
- // internally doesn't copy the memory unless one of the copies is modified.
- Region mVisibleRegion;
- Region mSurfaceDamage;
-};
+ auto& displayData = mDisplayData[displayId];
+ auto& hwcDisplay = displayData.hwcDisplay;
+ auto error = hwcDisplay->present(&displayData.lastRetireFence);
+ if (error != HWC2::Error::None) {
+ ALOGE("commit: present failed for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return UNKNOWN_ERROR;
+ }
-/*
- * returns an iterator initialized at a given index in the layer list
- */
-HWComposer::LayerListIterator HWComposer::getLayerIterator(int32_t id, size_t index) {
- if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
- return LayerListIterator();
+ std::unordered_map<std::shared_ptr<HWC2::Layer>, sp<Fence>> releaseFences;
+ error = hwcDisplay->getReleaseFences(&releaseFences);
+ if (error != HWC2::Error::None) {
+ ALOGE("commit: Failed to get release fences for display %d: %s (%d)",
+ displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ return UNKNOWN_ERROR;
}
- const DisplayData& disp(mDisplayData[id]);
- if (!mHwc || !disp.list || index > disp.list->numHwLayers) {
- return LayerListIterator();
- }
- return LayerListIterator(new HWCLayerVersion1(mHwc, disp.list->hwLayers), index);
+
+ displayData.releaseFences = std::move(releaseFences);
+
+ return NO_ERROR;
}
-/*
- * returns an iterator on the beginning of the layer list
- */
-HWComposer::LayerListIterator HWComposer::begin(int32_t id) {
- return getLayerIterator(id, 0);
-}
+status_t HWComposer::setPowerMode(int32_t displayId, int32_t intMode) {
+ ALOGV("setPowerMode(%d, %d)", displayId, intMode);
+ if (!isValidDisplay(displayId)) {
+ ALOGE("setPowerMode: Bad display");
+ return BAD_INDEX;
+ }
+ if (displayId >= VIRTUAL_DISPLAY_ID_BASE) {
+ ALOGE("setPowerMode: Virtual display %d passed in, returning",
+ displayId);
+ return BAD_INDEX;
+ }
-/*
- * returns an iterator on the end of the layer list
- */
-HWComposer::LayerListIterator HWComposer::end(int32_t id) {
- size_t numLayers = 0;
- if (uint32_t(id) <= 31 && mAllocatedDisplayIDs.hasBit(id)) {
- const DisplayData& disp(mDisplayData[id]);
- if (mHwc && disp.list) {
- numLayers = disp.list->numHwLayers;
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
- // with HWC 1.1, the last layer is always the HWC_FRAMEBUFFER_TARGET,
- // which we ignore when iterating through the layer list.
- ALOGE_IF(!numLayers, "mDisplayData[%d].list->numHwLayers is 0", id);
- if (numLayers) {
- numLayers--;
+ auto mode = static_cast<HWC2::PowerMode>(intMode);
+ if (mode == HWC2::PowerMode::Off) {
+ setVsyncEnabled(displayId, HWC2::Vsync::Disable);
+ }
+
+ auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
+ switch (mode) {
+ case HWC2::PowerMode::Off:
+ case HWC2::PowerMode::On:
+ ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
+ {
+ auto error = hwcDisplay->setPowerMode(mode);
+ if (error != HWC2::Error::None) {
+ ALOGE("setPowerMode: Unable to set power mode %s for "
+ "display %d: %s (%d)", to_string(mode).c_str(),
+ displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
}
}
- }
+ break;
+ case HWC2::PowerMode::Doze:
+ case HWC2::PowerMode::DozeSuspend:
+ ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
+ {
+ bool supportsDoze = false;
+ auto error = hwcDisplay->supportsDoze(&supportsDoze);
+ if (error != HWC2::Error::None) {
+ ALOGE("setPowerMode: Unable to query doze support for "
+ "display %d: %s (%d)", displayId,
+ to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ }
+ if (!supportsDoze) {
+ mode = HWC2::PowerMode::On;
+ }
+
+ error = hwcDisplay->setPowerMode(mode);
+ if (error != HWC2::Error::None) {
+ ALOGE("setPowerMode: Unable to set power mode %s for "
+ "display %d: %s (%d)", to_string(mode).c_str(),
+ displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ }
+ }
+ break;
+ default:
+ ALOGV("setPowerMode: Not calling HWC");
+ break;
}
- return getLayerIterator(id, numLayers);
+
+ return NO_ERROR;
+}
+
+status_t HWComposer::setActiveConfig(int32_t displayId, size_t configId) {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("setActiveConfig: Display %d is not valid", displayId);
+ return BAD_INDEX;
+ }
+
+ auto& displayData = mDisplayData[displayId];
+ if (displayData.configMap.count(configId) == 0) {
+ ALOGE("setActiveConfig: Invalid config %zd", configId);
+ return BAD_INDEX;
+ }
+
+ auto error = displayData.hwcDisplay->setActiveConfig(
+ displayData.configMap[configId]);
+ if (error != HWC2::Error::None) {
+ ALOGE("setActiveConfig: Failed to set config %zu on display %d: "
+ "%s (%d)", configId, displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+void HWComposer::disconnectDisplay(int displayId) {
+ LOG_ALWAYS_FATAL_IF(displayId < 0);
+ auto& displayData = mDisplayData[displayId];
+
+ auto displayType = HWC2::DisplayType::Invalid;
+ auto error = displayData.hwcDisplay->getType(&displayType);
+ if (error != HWC2::Error::None) {
+ ALOGE("disconnectDisplay: Failed to determine type of display %d",
+ displayId);
+ return;
+ }
+
+ // If this was a virtual display, add its slot back for reuse by future
+ // virtual displays
+ if (displayType == HWC2::DisplayType::Virtual) {
+ mFreeDisplaySlots.insert(displayId);
+ ++mRemainingHwcVirtualDisplays;
+ }
+
+ auto hwcId = displayData.hwcDisplay->getId();
+ mHwcDisplaySlots.erase(hwcId);
+ displayData.reset();
+}
+
+status_t HWComposer::setOutputBuffer(int32_t displayId,
+ const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buffer) {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("setOutputBuffer: Display %d is not valid", displayId);
+ return BAD_INDEX;
+ }
+
+ auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
+ auto displayType = HWC2::DisplayType::Invalid;
+ auto error = hwcDisplay->getType(&displayType);
+ if (error != HWC2::Error::None) {
+ ALOGE("setOutputBuffer: Failed to determine type of display %d",
+ displayId);
+ return NAME_NOT_FOUND;
+ }
+
+ if (displayType != HWC2::DisplayType::Virtual) {
+ ALOGE("setOutputBuffer: Display %d is not virtual", displayId);
+ return INVALID_OPERATION;
+ }
+
+ error = hwcDisplay->setOutputBuffer(buffer, acquireFence);
+ if (error != HWC2::Error::None) {
+ ALOGE("setOutputBuffer: Failed to set buffer on display %d: %s (%d)",
+ displayId, to_string(error).c_str(),
+ static_cast<int32_t>(error));
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+void HWComposer::clearReleaseFences(int32_t displayId) {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("clearReleaseFences: Display %d is not valid", displayId);
+ return;
+ }
+ mDisplayData[displayId].releaseFences.clear();
}
// Converts a PixelFormat to a human-readable string. Max 11 chars.
// (Could use a table of prefab String8 objects.)
+/*
static String8 getFormatStr(PixelFormat format) {
switch (format) {
case PIXEL_FORMAT_RGBA_8888: return String8("RGBA_8888");
@@ -1148,174 +754,34 @@
return result;
}
}
+*/
void HWComposer::dump(String8& result) const {
- Mutex::Autolock _l(mDisplayLock);
- if (mHwc) {
- result.appendFormat("Hardware Composer state (version %08x):\n", hwcApiVersion(mHwc));
- result.appendFormat(" mDebugForceFakeVSync=%d\n", mDebugForceFakeVSync);
- for (size_t i=0 ; i<mNumDisplays ; i++) {
- const DisplayData& disp(mDisplayData[i]);
- if (!disp.connected)
- continue;
-
- const Vector< sp<Layer> >& visibleLayersSortedByZ =
- mFlinger->getLayerSortedByZForHwcDisplay(i);
-
-
- result.appendFormat(" Display[%zd] configurations (* current):\n", i);
- for (size_t c = 0; c < disp.configs.size(); ++c) {
- const DisplayConfig& config(disp.configs[c]);
- result.appendFormat(" %s%zd: %ux%u, xdpi=%f, ydpi=%f"
- ", refresh=%" PRId64 ", colorTransform=%d\n",
- c == disp.currentConfig ? "* " : "", c,
- config.width, config.height, config.xdpi, config.ydpi,
- config.refresh, config.colorTransform);
- }
-
- if (disp.list) {
- result.appendFormat(
- " numHwLayers=%zu, flags=%08x\n",
- disp.list->numHwLayers, disp.list->flags);
-
- result.append(
- " type | handle | hint | flag | tr | blnd | format | source crop (l,t,r,b) | frame | name \n"
- "-----------+----------+------+------+----+------+-------------+--------------------------------+------------------------+------\n");
- // " _________ | ________ | ____ | ____ | __ | ____ | ___________ |_____._,_____._,_____._,_____._ |_____,_____,_____,_____ | ___...
- for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {
- const hwc_layer_1_t&l = disp.list->hwLayers[i];
- int32_t format = -1;
- String8 name("unknown");
-
- if (i < visibleLayersSortedByZ.size()) {
- const sp<Layer>& layer(visibleLayersSortedByZ[i]);
- const sp<GraphicBuffer>& buffer(
- layer->getActiveBuffer());
- if (buffer != NULL) {
- format = buffer->getPixelFormat();
- }
- name = layer->getName();
- }
-
- int type = l.compositionType;
- if (type == HWC_FRAMEBUFFER_TARGET) {
- name = "HWC_FRAMEBUFFER_TARGET";
- format = disp.format;
- }
-
- static char const* compositionTypeName[] = {
- "GLES",
- "HWC",
- "BKGND",
- "FB TARGET",
- "SIDEBAND",
- "HWC_CURSOR",
- "UNKNOWN"};
- if (type >= NELEM(compositionTypeName))
- type = NELEM(compositionTypeName) - 1;
-
- String8 formatStr = getFormatStr(format);
- if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
- result.appendFormat(
- " %9s | %08" PRIxPTR " | %04x | %04x | %02x | %04x | %-11s |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d | %s\n",
- compositionTypeName[type],
- intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, formatStr.string(),
- l.sourceCropf.left, l.sourceCropf.top, l.sourceCropf.right, l.sourceCropf.bottom,
- l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
- name.string());
- } else {
- result.appendFormat(
- " %9s | %08" PRIxPTR " | %04x | %04x | %02x | %04x | %-11s |%7d,%7d,%7d,%7d |%5d,%5d,%5d,%5d | %s\n",
- compositionTypeName[type],
- intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, formatStr.string(),
- l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
- l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
- name.string());
- }
- }
- }
- }
- }
-
- if (mHwc && mHwc->dump) {
- const size_t SIZE = 4096;
- char buffer[SIZE];
- mHwc->dump(mHwc, buffer, SIZE);
- result.append(buffer);
- }
+ // TODO: In order to provide a dump equivalent to HWC1, we need to shadow
+ // all the state going into the layers. This is probably better done in
+ // Layer itself, but it's going to take a bit of work to get there.
+ result.append(mHwcDevice->dump().c_str());
}
// ---------------------------------------------------------------------------
-HWComposer::VSyncThread::VSyncThread(HWComposer& hwc)
- : mHwc(hwc), mEnabled(false),
- mNextFakeVSync(0),
- mRefreshPeriod(hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY))
-{
-}
-
-void HWComposer::VSyncThread::setEnabled(bool enabled) {
- Mutex::Autolock _l(mLock);
- if (mEnabled != enabled) {
- mEnabled = enabled;
- mCondition.signal();
- }
-}
-
-void HWComposer::VSyncThread::onFirstRef() {
- run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
-}
-
-bool HWComposer::VSyncThread::threadLoop() {
- { // scope for lock
- Mutex::Autolock _l(mLock);
- while (!mEnabled) {
- mCondition.wait(mLock);
- }
- }
-
- const nsecs_t period = mRefreshPeriod;
- const nsecs_t now = systemTime(CLOCK_MONOTONIC);
- nsecs_t next_vsync = mNextFakeVSync;
- nsecs_t sleep = next_vsync - now;
- if (sleep < 0) {
- // we missed, find where the next vsync should be
- sleep = (period - ((now - next_vsync) % period));
- next_vsync = now + sleep;
- }
- mNextFakeVSync = next_vsync + period;
-
- struct timespec spec;
- spec.tv_sec = next_vsync / 1000000000;
- spec.tv_nsec = next_vsync % 1000000000;
-
- int err;
- do {
- err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
- } while (err<0 && errno == EINTR);
-
- if (err == 0) {
- mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
- }
-
- return true;
-}
-
HWComposer::DisplayData::DisplayData()
-: configs(),
- currentConfig(0),
- format(HAL_PIXEL_FORMAT_RGBA_8888),
- connected(false),
- hasFbComp(false), hasOvComp(false),
- capacity(0), list(NULL),
- framebufferTarget(NULL), fbTargetHandle(0),
- lastRetireFence(Fence::NO_FENCE), lastDisplayFence(Fence::NO_FENCE),
- outbufHandle(NULL), outbufAcquireFence(Fence::NO_FENCE),
- events(0)
-{}
+ : hasClientComposition(false),
+ hasDeviceComposition(false),
+ hwcDisplay(),
+ lastRetireFence(Fence::NO_FENCE),
+ outbufHandle(nullptr),
+ outbufAcquireFence(Fence::NO_FENCE),
+ vsyncEnabled(HWC2::Vsync::Disable) {
+ ALOGV("Created new DisplayData");
+}
HWComposer::DisplayData::~DisplayData() {
- free(list);
+}
+
+void HWComposer::DisplayData::reset() {
+ ALOGV("DisplayData reset");
+ *this = DisplayData();
}
// ---------------------------------------------------------------------------