| /* |
| * Copyright 2016 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_TAG "HwcPassthrough" |
| |
| #include <mutex> |
| #include <type_traits> |
| #include <unordered_map> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include <hardware/gralloc.h> |
| #include <hardware/gralloc1.h> |
| #include <hardware/hwcomposer2.h> |
| #include <log/log.h> |
| |
| #include "Hwc.h" |
| |
| namespace android { |
| namespace hardware { |
| namespace graphics { |
| namespace composer { |
| namespace V2_1 { |
| namespace implementation { |
| |
| using android::hardware::graphics::allocator::V2_0::PixelFormat; |
| |
| namespace { |
| |
| class HandleImporter { |
| public: |
| HandleImporter() : mInitialized(false) {} |
| |
| bool initialize() |
| { |
| // allow only one client |
| if (mInitialized) { |
| return false; |
| } |
| |
| if (!openGralloc()) { |
| return false; |
| } |
| |
| mInitialized = true; |
| return true; |
| } |
| |
| void cleanup() |
| { |
| if (!mInitialized) { |
| return; |
| } |
| |
| closeGralloc(); |
| mInitialized = false; |
| } |
| |
| // In IComposer, any buffer_handle_t is owned by the caller and we need to |
| // make a clone for hwcomposer2. We also need to translate empty handle |
| // to nullptr. This function does that, in-place. |
| bool importBuffer(buffer_handle_t& handle) |
| { |
| if (!handle->numFds && !handle->numInts) { |
| handle = nullptr; |
| return true; |
| } |
| |
| buffer_handle_t clone = cloneBuffer(handle); |
| if (!clone) { |
| return false; |
| } |
| |
| handle = clone; |
| return true; |
| } |
| |
| void freeBuffer(buffer_handle_t handle) |
| { |
| if (!handle) { |
| return; |
| } |
| |
| releaseBuffer(handle); |
| } |
| |
| bool importFence(const native_handle_t* handle, int& fd) |
| { |
| if (handle->numFds == 0) { |
| fd = -1; |
| } else if (handle->numFds == 1) { |
| fd = dup(handle->data[0]); |
| if (fd < 0) { |
| ALOGE("failed to dup fence fd %d", handle->data[0]); |
| return false; |
| } |
| } else { |
| ALOGE("invalid fence handle with %d file descriptors", |
| handle->numFds); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void closeFence(int fd) |
| { |
| if (fd >= 0) { |
| close(fd); |
| } |
| } |
| |
| private: |
| bool mInitialized; |
| |
| // Some existing gralloc drivers do not support retaining more than once, |
| // when we are in passthrough mode. |
| #ifdef BINDERIZED |
| bool openGralloc() |
| { |
| const hw_module_t* module; |
| int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err) { |
| ALOGE("failed to get gralloc module"); |
| return false; |
| } |
| |
| uint8_t major = (module->module_api_version >> 8) & 0xff; |
| if (major > 1) { |
| ALOGE("unknown gralloc module major version %d", major); |
| return false; |
| } |
| |
| if (major == 1) { |
| err = gralloc1_open(module, &mDevice); |
| if (err) { |
| ALOGE("failed to open gralloc1 device"); |
| return false; |
| } |
| |
| mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>( |
| mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN)); |
| mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>( |
| mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE)); |
| if (!mRetain || !mRelease) { |
| ALOGE("invalid gralloc1 device"); |
| gralloc1_close(mDevice); |
| return false; |
| } |
| } else { |
| mModule = reinterpret_cast<const gralloc_module_t*>(module); |
| } |
| |
| return true; |
| } |
| |
| void closeGralloc() |
| { |
| if (mDevice) { |
| gralloc1_close(mDevice); |
| } |
| } |
| |
| buffer_handle_t cloneBuffer(buffer_handle_t handle) |
| { |
| native_handle_t* clone = native_handle_clone(handle); |
| if (!clone) { |
| ALOGE("failed to clone buffer %p", handle); |
| return nullptr; |
| } |
| |
| bool err; |
| if (mDevice) { |
| err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE); |
| } else { |
| err = (mModule->registerBuffer(mModule, clone) != 0); |
| } |
| |
| if (err) { |
| ALOGE("failed to retain/register buffer %p", clone); |
| native_handle_close(clone); |
| native_handle_delete(clone); |
| return nullptr; |
| } |
| |
| return clone; |
| } |
| |
| void releaseBuffer(buffer_handle_t handle) |
| { |
| if (mDevice) { |
| mRelease(mDevice, handle); |
| } else { |
| mModule->unregisterBuffer(mModule, handle); |
| native_handle_close(handle); |
| native_handle_delete(const_cast<native_handle_t*>(handle)); |
| } |
| } |
| |
| // gralloc1 |
| gralloc1_device_t* mDevice; |
| GRALLOC1_PFN_RETAIN mRetain; |
| GRALLOC1_PFN_RELEASE mRelease; |
| |
| // gralloc0 |
| const gralloc_module_t* mModule; |
| #else |
| bool openGralloc() { return true; } |
| void closeGralloc() {} |
| buffer_handle_t cloneBuffer(buffer_handle_t handle) { return handle; } |
| void releaseBuffer(buffer_handle_t) {} |
| #endif |
| }; |
| |
| HandleImporter sHandleImporter; |
| |
| class BufferClone { |
| public: |
| BufferClone() : mHandle(nullptr) {} |
| |
| BufferClone(BufferClone&& other) |
| { |
| mHandle = other.mHandle; |
| other.mHandle = nullptr; |
| } |
| |
| BufferClone(const BufferClone& other) = delete; |
| BufferClone& operator=(const BufferClone& other) = delete; |
| |
| BufferClone& operator=(buffer_handle_t handle) |
| { |
| clear(); |
| mHandle = handle; |
| return *this; |
| } |
| |
| ~BufferClone() |
| { |
| clear(); |
| } |
| |
| private: |
| void clear() |
| { |
| if (mHandle) { |
| sHandleImporter.freeBuffer(mHandle); |
| } |
| } |
| |
| buffer_handle_t mHandle; |
| }; |
| |
| } // anonymous namespace |
| |
| class HwcHal : public IComposer { |
| public: |
| HwcHal(const hw_module_t* module); |
| virtual ~HwcHal(); |
| |
| // IComposer interface |
| Return<void> getCapabilities(getCapabilities_cb hidl_cb) override; |
| Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override; |
| Return<void> registerCallback(const sp<IComposerCallback>& callback) override; |
| Return<uint32_t> getMaxVirtualDisplayCount() override; |
| Return<void> createVirtualDisplay(uint32_t width, uint32_t height, |
| PixelFormat formatHint, createVirtualDisplay_cb hidl_cb) override; |
| Return<Error> destroyVirtualDisplay(Display display) override; |
| Return<Error> acceptDisplayChanges(Display display) override; |
| Return<void> createLayer(Display display, |
| createLayer_cb hidl_cb) override; |
| Return<Error> destroyLayer(Display display, Layer layer) override; |
| Return<void> getActiveConfig(Display display, |
| getActiveConfig_cb hidl_cb) override; |
| Return<void> getChangedCompositionTypes(Display display, |
| getChangedCompositionTypes_cb hidl_cb) override; |
| Return<Error> getClientTargetSupport(Display display, |
| uint32_t width, uint32_t height, |
| PixelFormat format, Dataspace dataspace) override; |
| Return<void> getColorModes(Display display, |
| getColorModes_cb hidl_cb) override; |
| Return<void> getDisplayAttribute(Display display, |
| Config config, Attribute attribute, |
| getDisplayAttribute_cb hidl_cb) override; |
| Return<void> getDisplayConfigs(Display display, |
| getDisplayConfigs_cb hidl_cb) override; |
| Return<void> getDisplayName(Display display, |
| getDisplayName_cb hidl_cb) override; |
| Return<void> getDisplayRequests(Display display, |
| getDisplayRequests_cb hidl_cb) override; |
| Return<void> getDisplayType(Display display, |
| getDisplayType_cb hidl_cb) override; |
| Return<void> getDozeSupport(Display display, |
| getDozeSupport_cb hidl_cb) override; |
| Return<void> getHdrCapabilities(Display display, |
| getHdrCapabilities_cb hidl_cb) override; |
| Return<void> getReleaseFences(Display display, |
| getReleaseFences_cb hidl_cb) override; |
| Return<void> presentDisplay(Display display, |
| presentDisplay_cb hidl_cb) override; |
| Return<Error> setActiveConfig(Display display, Config config) override; |
| Return<Error> setClientTarget(Display display, |
| const native_handle_t* target, |
| const native_handle_t* acquireFence, |
| Dataspace dataspace, const hidl_vec<Rect>& damage) override; |
| Return<Error> setColorMode(Display display, ColorMode mode) override; |
| Return<Error> setColorTransform(Display display, |
| const hidl_vec<float>& matrix, ColorTransform hint) override; |
| Return<Error> setOutputBuffer(Display display, |
| const native_handle_t* buffer, |
| const native_handle_t* releaseFence) override; |
| Return<Error> setPowerMode(Display display, PowerMode mode) override; |
| Return<Error> setVsyncEnabled(Display display, Vsync enabled) override; |
| Return<void> validateDisplay(Display display, |
| validateDisplay_cb hidl_cb) override; |
| Return<Error> setCursorPosition(Display display, |
| Layer layer, int32_t x, int32_t y) override; |
| Return<Error> setLayerBuffer(Display display, |
| Layer layer, const native_handle_t* buffer, |
| const native_handle_t* acquireFence) override; |
| Return<Error> setLayerSurfaceDamage(Display display, |
| Layer layer, const hidl_vec<Rect>& damage) override; |
| Return<Error> setLayerBlendMode(Display display, |
| Layer layer, BlendMode mode) override; |
| Return<Error> setLayerColor(Display display, |
| Layer layer, const Color& color) override; |
| Return<Error> setLayerCompositionType(Display display, |
| Layer layer, Composition type) override; |
| Return<Error> setLayerDataspace(Display display, |
| Layer layer, Dataspace dataspace) override; |
| Return<Error> setLayerDisplayFrame(Display display, |
| Layer layer, const Rect& frame) override; |
| Return<Error> setLayerPlaneAlpha(Display display, |
| Layer layer, float alpha) override; |
| Return<Error> setLayerSidebandStream(Display display, |
| Layer layer, const native_handle_t* stream) override; |
| Return<Error> setLayerSourceCrop(Display display, |
| Layer layer, const FRect& crop) override; |
| Return<Error> setLayerTransform(Display display, |
| Layer layer, Transform transform) override; |
| Return<Error> setLayerVisibleRegion(Display display, |
| Layer layer, const hidl_vec<Rect>& visible) override; |
| Return<Error> setLayerZOrder(Display display, |
| Layer layer, uint32_t z) override; |
| |
| private: |
| void initCapabilities(); |
| |
| template<typename T> |
| void initDispatch(T& func, hwc2_function_descriptor_t desc); |
| void initDispatch(); |
| |
| bool hasCapability(Capability capability) const; |
| |
| static void hotplugHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int32_t connected); |
| static void refreshHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display); |
| static void vsyncHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp); |
| |
| hwc2_device_t* mDevice; |
| |
| std::unordered_set<Capability> mCapabilities; |
| |
| struct { |
| HWC2_PFN_ACCEPT_DISPLAY_CHANGES acceptDisplayChanges; |
| HWC2_PFN_CREATE_LAYER createLayer; |
| HWC2_PFN_CREATE_VIRTUAL_DISPLAY createVirtualDisplay; |
| HWC2_PFN_DESTROY_LAYER destroyLayer; |
| HWC2_PFN_DESTROY_VIRTUAL_DISPLAY destroyVirtualDisplay; |
| HWC2_PFN_DUMP dump; |
| HWC2_PFN_GET_ACTIVE_CONFIG getActiveConfig; |
| HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES getChangedCompositionTypes; |
| HWC2_PFN_GET_CLIENT_TARGET_SUPPORT getClientTargetSupport; |
| HWC2_PFN_GET_COLOR_MODES getColorModes; |
| HWC2_PFN_GET_DISPLAY_ATTRIBUTE getDisplayAttribute; |
| HWC2_PFN_GET_DISPLAY_CONFIGS getDisplayConfigs; |
| HWC2_PFN_GET_DISPLAY_NAME getDisplayName; |
| HWC2_PFN_GET_DISPLAY_REQUESTS getDisplayRequests; |
| HWC2_PFN_GET_DISPLAY_TYPE getDisplayType; |
| HWC2_PFN_GET_DOZE_SUPPORT getDozeSupport; |
| HWC2_PFN_GET_HDR_CAPABILITIES getHdrCapabilities; |
| HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT getMaxVirtualDisplayCount; |
| HWC2_PFN_GET_RELEASE_FENCES getReleaseFences; |
| HWC2_PFN_PRESENT_DISPLAY presentDisplay; |
| HWC2_PFN_REGISTER_CALLBACK registerCallback; |
| HWC2_PFN_SET_ACTIVE_CONFIG setActiveConfig; |
| HWC2_PFN_SET_CLIENT_TARGET setClientTarget; |
| HWC2_PFN_SET_COLOR_MODE setColorMode; |
| HWC2_PFN_SET_COLOR_TRANSFORM setColorTransform; |
| HWC2_PFN_SET_CURSOR_POSITION setCursorPosition; |
| HWC2_PFN_SET_LAYER_BLEND_MODE setLayerBlendMode; |
| HWC2_PFN_SET_LAYER_BUFFER setLayerBuffer; |
| HWC2_PFN_SET_LAYER_COLOR setLayerColor; |
| HWC2_PFN_SET_LAYER_COMPOSITION_TYPE setLayerCompositionType; |
| HWC2_PFN_SET_LAYER_DATASPACE setLayerDataspace; |
| HWC2_PFN_SET_LAYER_DISPLAY_FRAME setLayerDisplayFrame; |
| HWC2_PFN_SET_LAYER_PLANE_ALPHA setLayerPlaneAlpha; |
| HWC2_PFN_SET_LAYER_SIDEBAND_STREAM setLayerSidebandStream; |
| HWC2_PFN_SET_LAYER_SOURCE_CROP setLayerSourceCrop; |
| HWC2_PFN_SET_LAYER_SURFACE_DAMAGE setLayerSurfaceDamage; |
| HWC2_PFN_SET_LAYER_TRANSFORM setLayerTransform; |
| HWC2_PFN_SET_LAYER_VISIBLE_REGION setLayerVisibleRegion; |
| HWC2_PFN_SET_LAYER_Z_ORDER setLayerZOrder; |
| HWC2_PFN_SET_OUTPUT_BUFFER setOutputBuffer; |
| HWC2_PFN_SET_POWER_MODE setPowerMode; |
| HWC2_PFN_SET_VSYNC_ENABLED setVsyncEnabled; |
| HWC2_PFN_VALIDATE_DISPLAY validateDisplay; |
| } mDispatch; |
| |
| // cloned buffers for a display |
| struct DisplayBuffers { |
| BufferClone ClientTarget; |
| BufferClone OutputBuffer; |
| |
| std::unordered_map<Layer, BufferClone> LayerBuffers; |
| std::unordered_map<Layer, BufferClone> LayerSidebandStreams; |
| }; |
| |
| std::mutex mCallbackMutex; |
| sp<IComposerCallback> mCallback; |
| |
| std::mutex mDisplayMutex; |
| std::unordered_map<Display, DisplayBuffers> mDisplays; |
| }; |
| |
| HwcHal::HwcHal(const hw_module_t* module) |
| : mDevice(nullptr), mDispatch() |
| { |
| if (!sHandleImporter.initialize()) { |
| LOG_ALWAYS_FATAL("failed to initialize handle importer"); |
| } |
| |
| int status = hwc2_open(module, &mDevice); |
| if (status) { |
| LOG_ALWAYS_FATAL("failed to open hwcomposer2 device: %s", |
| strerror(-status)); |
| } |
| |
| initCapabilities(); |
| initDispatch(); |
| } |
| |
| HwcHal::~HwcHal() |
| { |
| hwc2_close(mDevice); |
| mDisplays.clear(); |
| sHandleImporter.cleanup(); |
| } |
| |
| void HwcHal::initCapabilities() |
| { |
| uint32_t count = 0; |
| mDevice->getCapabilities(mDevice, &count, nullptr); |
| |
| std::vector<Capability> caps(count); |
| mDevice->getCapabilities(mDevice, &count, reinterpret_cast< |
| std::underlying_type<Capability>::type*>(caps.data())); |
| caps.resize(count); |
| |
| mCapabilities.insert(caps.cbegin(), caps.cend()); |
| } |
| |
| template<typename T> |
| void HwcHal::initDispatch(T& func, hwc2_function_descriptor_t desc) |
| { |
| auto pfn = mDevice->getFunction(mDevice, desc); |
| if (!pfn) { |
| LOG_ALWAYS_FATAL("failed to get hwcomposer2 function %d", desc); |
| } |
| |
| func = reinterpret_cast<T>(pfn); |
| } |
| |
| void HwcHal::initDispatch() |
| { |
| initDispatch(mDispatch.acceptDisplayChanges, |
| HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES); |
| initDispatch(mDispatch.createLayer, HWC2_FUNCTION_CREATE_LAYER); |
| initDispatch(mDispatch.createVirtualDisplay, |
| HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY); |
| initDispatch(mDispatch.destroyLayer, HWC2_FUNCTION_DESTROY_LAYER); |
| initDispatch(mDispatch.destroyVirtualDisplay, |
| HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY); |
| initDispatch(mDispatch.dump, HWC2_FUNCTION_DUMP); |
| initDispatch(mDispatch.getActiveConfig, HWC2_FUNCTION_GET_ACTIVE_CONFIG); |
| initDispatch(mDispatch.getChangedCompositionTypes, |
| HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES); |
| initDispatch(mDispatch.getClientTargetSupport, |
| HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT); |
| initDispatch(mDispatch.getColorModes, HWC2_FUNCTION_GET_COLOR_MODES); |
| initDispatch(mDispatch.getDisplayAttribute, |
| HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE); |
| initDispatch(mDispatch.getDisplayConfigs, |
| HWC2_FUNCTION_GET_DISPLAY_CONFIGS); |
| initDispatch(mDispatch.getDisplayName, HWC2_FUNCTION_GET_DISPLAY_NAME); |
| initDispatch(mDispatch.getDisplayRequests, |
| HWC2_FUNCTION_GET_DISPLAY_REQUESTS); |
| initDispatch(mDispatch.getDisplayType, HWC2_FUNCTION_GET_DISPLAY_TYPE); |
| initDispatch(mDispatch.getDozeSupport, HWC2_FUNCTION_GET_DOZE_SUPPORT); |
| initDispatch(mDispatch.getHdrCapabilities, |
| HWC2_FUNCTION_GET_HDR_CAPABILITIES); |
| initDispatch(mDispatch.getMaxVirtualDisplayCount, |
| HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT); |
| initDispatch(mDispatch.getReleaseFences, |
| HWC2_FUNCTION_GET_RELEASE_FENCES); |
| initDispatch(mDispatch.presentDisplay, HWC2_FUNCTION_PRESENT_DISPLAY); |
| initDispatch(mDispatch.registerCallback, HWC2_FUNCTION_REGISTER_CALLBACK); |
| initDispatch(mDispatch.setActiveConfig, HWC2_FUNCTION_SET_ACTIVE_CONFIG); |
| initDispatch(mDispatch.setClientTarget, HWC2_FUNCTION_SET_CLIENT_TARGET); |
| initDispatch(mDispatch.setColorMode, HWC2_FUNCTION_SET_COLOR_MODE); |
| initDispatch(mDispatch.setColorTransform, |
| HWC2_FUNCTION_SET_COLOR_TRANSFORM); |
| initDispatch(mDispatch.setCursorPosition, |
| HWC2_FUNCTION_SET_CURSOR_POSITION); |
| initDispatch(mDispatch.setLayerBlendMode, |
| HWC2_FUNCTION_SET_LAYER_BLEND_MODE); |
| initDispatch(mDispatch.setLayerBuffer, HWC2_FUNCTION_SET_LAYER_BUFFER); |
| initDispatch(mDispatch.setLayerColor, HWC2_FUNCTION_SET_LAYER_COLOR); |
| initDispatch(mDispatch.setLayerCompositionType, |
| HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE); |
| initDispatch(mDispatch.setLayerDataspace, |
| HWC2_FUNCTION_SET_LAYER_DATASPACE); |
| initDispatch(mDispatch.setLayerDisplayFrame, |
| HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME); |
| initDispatch(mDispatch.setLayerPlaneAlpha, |
| HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA); |
| |
| if (hasCapability(Capability::SIDEBAND_STREAM)) { |
| initDispatch(mDispatch.setLayerSidebandStream, |
| HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM); |
| } |
| |
| initDispatch(mDispatch.setLayerSourceCrop, |
| HWC2_FUNCTION_SET_LAYER_SOURCE_CROP); |
| initDispatch(mDispatch.setLayerSurfaceDamage, |
| HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE); |
| initDispatch(mDispatch.setLayerTransform, |
| HWC2_FUNCTION_SET_LAYER_TRANSFORM); |
| initDispatch(mDispatch.setLayerVisibleRegion, |
| HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION); |
| initDispatch(mDispatch.setLayerZOrder, HWC2_FUNCTION_SET_LAYER_Z_ORDER); |
| initDispatch(mDispatch.setOutputBuffer, HWC2_FUNCTION_SET_OUTPUT_BUFFER); |
| initDispatch(mDispatch.setPowerMode, HWC2_FUNCTION_SET_POWER_MODE); |
| initDispatch(mDispatch.setVsyncEnabled, HWC2_FUNCTION_SET_VSYNC_ENABLED); |
| initDispatch(mDispatch.validateDisplay, HWC2_FUNCTION_VALIDATE_DISPLAY); |
| } |
| |
| bool HwcHal::hasCapability(Capability capability) const |
| { |
| return (mCapabilities.count(capability) > 0); |
| } |
| |
| Return<void> HwcHal::getCapabilities(getCapabilities_cb hidl_cb) |
| { |
| std::vector<Capability> caps( |
| mCapabilities.cbegin(), mCapabilities.cend()); |
| |
| hidl_vec<Capability> caps_reply; |
| caps_reply.setToExternal(caps.data(), caps.size()); |
| hidl_cb(caps_reply); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) |
| { |
| uint32_t len; |
| mDispatch.dump(mDevice, &len, nullptr); |
| |
| std::vector<char> buf(len + 1); |
| mDispatch.dump(mDevice, &len, buf.data()); |
| buf.resize(len + 1); |
| buf[len] = '\0'; |
| |
| hidl_string buf_reply; |
| buf_reply.setToExternal(buf.data(), len); |
| hidl_cb(buf_reply); |
| |
| return Void(); |
| } |
| |
| void HwcHal::hotplugHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int32_t connected) |
| { |
| auto hal = reinterpret_cast<HwcHal*>(callbackData); |
| |
| { |
| std::lock_guard<std::mutex> lock(hal->mDisplayMutex); |
| |
| if (connected == HWC2_CONNECTION_CONNECTED) { |
| hal->mDisplays.emplace(display, DisplayBuffers()); |
| } else if (connected == HWC2_CONNECTION_DISCONNECTED) { |
| hal->mDisplays.erase(display); |
| } |
| } |
| |
| hal->mCallback->onHotplug(display, |
| static_cast<IComposerCallback::Connection>(connected)); |
| } |
| |
| void HwcHal::refreshHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display) |
| { |
| auto hal = reinterpret_cast<HwcHal*>(callbackData); |
| hal->mCallback->onRefresh(display); |
| } |
| |
| void HwcHal::vsyncHook(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp) |
| { |
| auto hal = reinterpret_cast<HwcHal*>(callbackData); |
| hal->mCallback->onVsync(display, timestamp); |
| } |
| |
| Return<void> HwcHal::registerCallback(const sp<IComposerCallback>& callback) |
| { |
| std::lock_guard<std::mutex> lock(mCallbackMutex); |
| |
| mCallback = callback; |
| |
| mDispatch.registerCallback(mDevice, HWC2_CALLBACK_HOTPLUG, this, |
| reinterpret_cast<hwc2_function_pointer_t>(hotplugHook)); |
| mDispatch.registerCallback(mDevice, HWC2_CALLBACK_REFRESH, this, |
| reinterpret_cast<hwc2_function_pointer_t>(refreshHook)); |
| mDispatch.registerCallback(mDevice, HWC2_CALLBACK_VSYNC, this, |
| reinterpret_cast<hwc2_function_pointer_t>(vsyncHook)); |
| |
| return Void(); |
| } |
| |
| Return<uint32_t> HwcHal::getMaxVirtualDisplayCount() |
| { |
| return mDispatch.getMaxVirtualDisplayCount(mDevice); |
| } |
| |
| Return<void> HwcHal::createVirtualDisplay(uint32_t width, uint32_t height, |
| PixelFormat formatHint, createVirtualDisplay_cb hidl_cb) |
| { |
| int32_t format = static_cast<int32_t>(formatHint); |
| hwc2_display_t display; |
| auto error = mDispatch.createVirtualDisplay(mDevice, width, height, |
| &format, &display); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| mDisplays.emplace(display, DisplayBuffers()); |
| } |
| |
| hidl_cb(static_cast<Error>(error), display, |
| static_cast<PixelFormat>(format)); |
| |
| return Void(); |
| } |
| |
| Return<Error> HwcHal::destroyVirtualDisplay(Display display) |
| { |
| auto error = mDispatch.destroyVirtualDisplay(mDevice, display); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| mDisplays.erase(display); |
| } |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::acceptDisplayChanges(Display display) |
| { |
| auto error = mDispatch.acceptDisplayChanges(mDevice, display); |
| return static_cast<Error>(error); |
| } |
| |
| Return<void> HwcHal::createLayer(Display display, createLayer_cb hidl_cb) |
| { |
| hwc2_layer_t layer; |
| auto error = mDispatch.createLayer(mDevice, display, &layer); |
| |
| hidl_cb(static_cast<Error>(error), layer); |
| |
| return Void(); |
| } |
| |
| Return<Error> HwcHal::destroyLayer(Display display, Layer layer) |
| { |
| auto error = mDispatch.destroyLayer(mDevice, display, layer); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| auto dpy = mDisplays.find(display); |
| dpy->second.LayerBuffers.erase(layer); |
| dpy->second.LayerSidebandStreams.erase(layer); |
| } |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<void> HwcHal::getActiveConfig(Display display, |
| getActiveConfig_cb hidl_cb) |
| { |
| hwc2_config_t config; |
| auto error = mDispatch.getActiveConfig(mDevice, display, &config); |
| |
| hidl_cb(static_cast<Error>(error), config); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getChangedCompositionTypes(Display display, |
| getChangedCompositionTypes_cb hidl_cb) |
| { |
| uint32_t count = 0; |
| auto error = mDispatch.getChangedCompositionTypes(mDevice, display, |
| &count, nullptr, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<hwc2_layer_t> layers(count); |
| std::vector<Composition> types(count); |
| error = mDispatch.getChangedCompositionTypes(mDevice, display, |
| &count, layers.data(), |
| reinterpret_cast<std::underlying_type<Composition>::type*>( |
| types.data())); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| layers.resize(count); |
| types.resize(count); |
| |
| hidl_vec<Layer> layers_reply; |
| layers_reply.setToExternal(layers.data(), layers.size()); |
| |
| hidl_vec<Composition> types_reply; |
| types_reply.setToExternal(types.data(), types.size()); |
| |
| hidl_cb(static_cast<Error>(error), layers_reply, types_reply); |
| |
| return Void(); |
| } |
| |
| Return<Error> HwcHal::getClientTargetSupport(Display display, |
| uint32_t width, uint32_t height, |
| PixelFormat format, Dataspace dataspace) |
| { |
| auto error = mDispatch.getClientTargetSupport(mDevice, display, |
| width, height, static_cast<int32_t>(format), |
| static_cast<int32_t>(dataspace)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<void> HwcHal::getColorModes(Display display, getColorModes_cb hidl_cb) |
| { |
| uint32_t count = 0; |
| auto error = mDispatch.getColorModes(mDevice, display, &count, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<ColorMode> modes(count); |
| error = mDispatch.getColorModes(mDevice, display, &count, |
| reinterpret_cast<std::underlying_type<ColorMode>::type*>( |
| modes.data())); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| modes.resize(count); |
| |
| hidl_vec<ColorMode> modes_reply; |
| modes_reply.setToExternal(modes.data(), modes.size()); |
| hidl_cb(static_cast<Error>(error), modes_reply); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDisplayAttribute(Display display, |
| Config config, Attribute attribute, |
| getDisplayAttribute_cb hidl_cb) |
| { |
| int32_t value; |
| auto error = mDispatch.getDisplayAttribute(mDevice, display, config, |
| static_cast<int32_t>(attribute), &value); |
| |
| hidl_cb(static_cast<Error>(error), value); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDisplayConfigs(Display display, |
| getDisplayConfigs_cb hidl_cb) |
| { |
| uint32_t count = 0; |
| auto error = mDispatch.getDisplayConfigs(mDevice, display, |
| &count, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<hwc2_config_t> configs(count); |
| error = mDispatch.getDisplayConfigs(mDevice, display, |
| &count, configs.data()); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| configs.resize(count); |
| |
| hidl_vec<Config> configs_reply; |
| configs_reply.setToExternal(configs.data(), configs.size()); |
| hidl_cb(static_cast<Error>(error), configs_reply); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDisplayName(Display display, |
| getDisplayName_cb hidl_cb) |
| { |
| uint32_t count = 0; |
| auto error = mDispatch.getDisplayName(mDevice, display, &count, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<char> name(count + 1); |
| error = mDispatch.getDisplayName(mDevice, display, &count, name.data()); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| name.resize(count + 1); |
| name[count] = '\0'; |
| |
| hidl_string name_reply; |
| name_reply.setToExternal(name.data(), count); |
| hidl_cb(static_cast<Error>(error), name_reply); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDisplayRequests(Display display, |
| getDisplayRequests_cb hidl_cb) |
| { |
| int32_t display_reqs; |
| uint32_t count = 0; |
| auto error = mDispatch.getDisplayRequests(mDevice, display, |
| &display_reqs, &count, nullptr, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<hwc2_layer_t> layers(count); |
| std::vector<int32_t> layer_reqs(count); |
| error = mDispatch.getDisplayRequests(mDevice, display, |
| &display_reqs, &count, layers.data(), layer_reqs.data()); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| layers.resize(count); |
| layer_reqs.resize(count); |
| |
| hidl_vec<Layer> layers_reply; |
| layers_reply.setToExternal(layers.data(), layers.size()); |
| |
| hidl_vec<uint32_t> layer_reqs_reply; |
| layer_reqs_reply.setToExternal( |
| reinterpret_cast<uint32_t*>(layer_reqs.data()), |
| layer_reqs.size()); |
| |
| hidl_cb(static_cast<Error>(error), display_reqs, |
| layers_reply, layer_reqs_reply); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDisplayType(Display display, |
| getDisplayType_cb hidl_cb) |
| { |
| int32_t type; |
| auto error = mDispatch.getDisplayType(mDevice, display, &type); |
| |
| hidl_cb(static_cast<Error>(error), static_cast<DisplayType>(type)); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getDozeSupport(Display display, |
| getDozeSupport_cb hidl_cb) |
| { |
| int32_t support; |
| auto error = mDispatch.getDozeSupport(mDevice, display, &support); |
| |
| hidl_cb(static_cast<Error>(error), support); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getHdrCapabilities(Display display, |
| getHdrCapabilities_cb hidl_cb) |
| { |
| float max_lumi, max_avg_lumi, min_lumi; |
| uint32_t count = 0; |
| auto error = mDispatch.getHdrCapabilities(mDevice, display, |
| &count, nullptr, &max_lumi, &max_avg_lumi, &min_lumi); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<Hdr> types(count); |
| error = mDispatch.getHdrCapabilities(mDevice, display, &count, |
| reinterpret_cast<std::underlying_type<Hdr>::type*>(types.data()), |
| &max_lumi, &max_avg_lumi, &min_lumi); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| types.resize(count); |
| |
| hidl_vec<Hdr> types_reply; |
| types_reply.setToExternal(types.data(), types.size()); |
| hidl_cb(static_cast<Error>(error), types_reply, |
| max_lumi, max_avg_lumi, min_lumi); |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::getReleaseFences(Display display, |
| getReleaseFences_cb hidl_cb) |
| { |
| uint32_t count = 0; |
| auto error = mDispatch.getReleaseFences(mDevice, display, |
| &count, nullptr, nullptr); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| |
| std::vector<hwc2_layer_t> layers(count); |
| std::vector<int32_t> fences(count); |
| error = mDispatch.getReleaseFences(mDevice, display, |
| &count, layers.data(), fences.data()); |
| if (error != HWC2_ERROR_NONE) { |
| count = 0; |
| } |
| layers.resize(count); |
| fences.resize(count); |
| |
| // filter out layers with release fence -1 |
| std::vector<hwc2_layer_t> filtered_layers; |
| std::vector<int> filtered_fences; |
| for (size_t i = 0; i < layers.size(); i++) { |
| if (fences[i] >= 0) { |
| filtered_layers.push_back(layers[i]); |
| filtered_fences.push_back(fences[i]); |
| } |
| } |
| |
| hidl_vec<Layer> layers_reply; |
| native_handle_t* fences_reply = |
| native_handle_create(filtered_fences.size(), 0); |
| if (fences_reply) { |
| layers_reply.setToExternal(filtered_layers.data(), |
| filtered_layers.size()); |
| memcpy(fences_reply->data, filtered_fences.data(), |
| sizeof(int) * filtered_fences.size()); |
| |
| hidl_cb(static_cast<Error>(error), layers_reply, fences_reply); |
| |
| native_handle_close(fences_reply); |
| native_handle_delete(fences_reply); |
| } else { |
| NATIVE_HANDLE_DECLARE_STORAGE(fences_storage, 0, 0); |
| fences_reply = native_handle_init(fences_storage, 0, 0); |
| |
| hidl_cb(Error::NO_RESOURCES, layers_reply, fences_reply); |
| |
| for (auto fence : filtered_fences) { |
| close(fence); |
| } |
| } |
| |
| return Void(); |
| } |
| |
| Return<void> HwcHal::presentDisplay(Display display, |
| presentDisplay_cb hidl_cb) |
| { |
| int32_t fence = -1; |
| auto error = mDispatch.presentDisplay(mDevice, display, &fence); |
| |
| NATIVE_HANDLE_DECLARE_STORAGE(fence_storage, 1, 0); |
| native_handle_t* fence_reply; |
| if (fence >= 0) { |
| fence_reply = native_handle_init(fence_storage, 1, 0); |
| fence_reply->data[0] = fence; |
| } else { |
| fence_reply = native_handle_init(fence_storage, 0, 0); |
| } |
| |
| hidl_cb(static_cast<Error>(error), fence_reply); |
| |
| if (fence >= 0) { |
| close(fence); |
| } |
| |
| return Void(); |
| } |
| |
| Return<Error> HwcHal::setActiveConfig(Display display, Config config) |
| { |
| auto error = mDispatch.setActiveConfig(mDevice, display, config); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setClientTarget(Display display, |
| const native_handle_t* target, |
| const native_handle_t* acquireFence, |
| Dataspace dataspace, const hidl_vec<Rect>& damage) |
| { |
| if (!sHandleImporter.importBuffer(target)) { |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t fence; |
| if (!sHandleImporter.importFence(acquireFence, fence)) { |
| sHandleImporter.freeBuffer(target); |
| return Error::NO_RESOURCES; |
| } |
| |
| hwc_region_t damage_region = { damage.size(), |
| reinterpret_cast<const hwc_rect_t*>(&damage[0]) }; |
| |
| int32_t error = mDispatch.setClientTarget(mDevice, display, |
| target, fence, static_cast<int32_t>(dataspace), |
| damage_region); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| auto dpy = mDisplays.find(display); |
| dpy->second.ClientTarget = target; |
| } else { |
| sHandleImporter.freeBuffer(target); |
| sHandleImporter.closeFence(fence); |
| } |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setColorMode(Display display, ColorMode mode) |
| { |
| auto error = mDispatch.setColorMode(mDevice, display, |
| static_cast<int32_t>(mode)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setColorTransform(Display display, |
| const hidl_vec<float>& matrix, ColorTransform hint) |
| { |
| auto error = mDispatch.setColorTransform(mDevice, display, |
| &matrix[0], static_cast<int32_t>(hint)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setOutputBuffer(Display display, |
| const native_handle_t* buffer, |
| const native_handle_t* releaseFence) |
| { |
| if (!sHandleImporter.importBuffer(buffer)) { |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t fence; |
| if (!sHandleImporter.importFence(releaseFence, fence)) { |
| sHandleImporter.freeBuffer(buffer); |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t error = mDispatch.setOutputBuffer(mDevice, |
| display, buffer, fence); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| auto dpy = mDisplays.find(display); |
| dpy->second.OutputBuffer = buffer; |
| } else { |
| sHandleImporter.freeBuffer(buffer); |
| } |
| |
| // unlike in setClientTarget, fence is owned by us and is always closed |
| sHandleImporter.closeFence(fence); |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setPowerMode(Display display, PowerMode mode) |
| { |
| auto error = mDispatch.setPowerMode(mDevice, display, |
| static_cast<int32_t>(mode)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setVsyncEnabled(Display display, |
| Vsync enabled) |
| { |
| auto error = mDispatch.setVsyncEnabled(mDevice, display, |
| static_cast<int32_t>(enabled)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<void> HwcHal::validateDisplay(Display display, |
| validateDisplay_cb hidl_cb) |
| { |
| uint32_t types_count = 0; |
| uint32_t reqs_count = 0; |
| auto error = mDispatch.validateDisplay(mDevice, display, |
| &types_count, &reqs_count); |
| |
| hidl_cb(static_cast<Error>(error), types_count, reqs_count); |
| |
| return Void(); |
| } |
| |
| Return<Error> HwcHal::setCursorPosition(Display display, |
| Layer layer, int32_t x, int32_t y) |
| { |
| auto error = mDispatch.setCursorPosition(mDevice, display, layer, x, y); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerBuffer(Display display, |
| Layer layer, const native_handle_t* buffer, |
| const native_handle_t* acquireFence) |
| { |
| if (!sHandleImporter.importBuffer(buffer)) { |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t fence; |
| if (!sHandleImporter.importFence(acquireFence, fence)) { |
| sHandleImporter.freeBuffer(buffer); |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t error = mDispatch.setLayerBuffer(mDevice, |
| display, layer, buffer, fence); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| auto dpy = mDisplays.find(display); |
| dpy->second.LayerBuffers[layer] = buffer; |
| } else { |
| sHandleImporter.freeBuffer(buffer); |
| sHandleImporter.closeFence(fence); |
| } |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerSurfaceDamage(Display display, |
| Layer layer, const hidl_vec<Rect>& damage) |
| { |
| hwc_region_t damage_region = { damage.size(), |
| reinterpret_cast<const hwc_rect_t*>(&damage[0]) }; |
| |
| auto error = mDispatch.setLayerSurfaceDamage(mDevice, display, layer, |
| damage_region); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerBlendMode(Display display, |
| Layer layer, BlendMode mode) |
| { |
| auto error = mDispatch.setLayerBlendMode(mDevice, display, layer, |
| static_cast<int32_t>(mode)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerColor(Display display, |
| Layer layer, const Color& color) |
| { |
| hwc_color_t hwc_color{color.r, color.g, color.b, color.a}; |
| auto error = mDispatch.setLayerColor(mDevice, display, layer, hwc_color); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerCompositionType(Display display, |
| Layer layer, Composition type) |
| { |
| auto error = mDispatch.setLayerCompositionType(mDevice, display, layer, |
| static_cast<int32_t>(type)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerDataspace(Display display, |
| Layer layer, Dataspace dataspace) |
| { |
| auto error = mDispatch.setLayerDataspace(mDevice, display, layer, |
| static_cast<int32_t>(dataspace)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerDisplayFrame(Display display, |
| Layer layer, const Rect& frame) |
| { |
| hwc_rect_t hwc_frame{frame.left, frame.top, frame.right, frame.bottom}; |
| auto error = mDispatch.setLayerDisplayFrame(mDevice, display, layer, |
| hwc_frame); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerPlaneAlpha(Display display, |
| Layer layer, float alpha) |
| { |
| auto error = mDispatch.setLayerPlaneAlpha(mDevice, display, layer, alpha); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerSidebandStream(Display display, |
| Layer layer, const native_handle_t* stream) |
| { |
| if (!sHandleImporter.importBuffer(stream)) { |
| return Error::NO_RESOURCES; |
| } |
| |
| int32_t error = mDispatch.setLayerSidebandStream(mDevice, |
| display, layer, stream); |
| if (error == HWC2_ERROR_NONE) { |
| std::lock_guard<std::mutex> lock(mDisplayMutex); |
| |
| auto dpy = mDisplays.find(display); |
| dpy->second.LayerSidebandStreams[layer] = stream; |
| } else { |
| sHandleImporter.freeBuffer(stream); |
| } |
| |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerSourceCrop(Display display, |
| Layer layer, const FRect& crop) |
| { |
| hwc_frect_t hwc_crop{crop.left, crop.top, crop.right, crop.bottom}; |
| auto error = mDispatch.setLayerSourceCrop(mDevice, display, layer, |
| hwc_crop); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerTransform(Display display, |
| Layer layer, Transform transform) |
| { |
| auto error = mDispatch.setLayerTransform(mDevice, display, layer, |
| static_cast<int32_t>(transform)); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerVisibleRegion(Display display, |
| Layer layer, const hidl_vec<Rect>& visible) |
| { |
| hwc_region_t visible_region = { visible.size(), |
| reinterpret_cast<const hwc_rect_t*>(&visible[0]) }; |
| |
| auto error = mDispatch.setLayerVisibleRegion(mDevice, display, layer, |
| visible_region); |
| return static_cast<Error>(error); |
| } |
| |
| Return<Error> HwcHal::setLayerZOrder(Display display, |
| Layer layer, uint32_t z) |
| { |
| auto error = mDispatch.setLayerZOrder(mDevice, display, layer, z); |
| return static_cast<Error>(error); |
| } |
| |
| IComposer* HIDL_FETCH_IComposer(const char*) |
| { |
| const hw_module_t* module; |
| int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &module); |
| if (err) { |
| ALOGE("failed to get hwcomposer module"); |
| return nullptr; |
| } |
| |
| return new HwcHal(module); |
| } |
| |
| } // namespace implementation |
| } // namespace V2_1 |
| } // namespace composer |
| } // namespace graphics |
| } // namespace hardware |
| } // namespace android |