Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 651bf314 authored by Dan Stoza's avatar Dan Stoza
Browse files

SF: HWC2 C++ shim 

Provides an object-based C++ interface to the HWC 2.0 HAL

Change-Id: Ie1a7bfd2f6faa548bc45da845a4f50f1915b5806
parent c6998d23

services/surfaceflinger/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ LOCAL_SRC_FILES := \ 
    SurfaceFlingerConsumer.cpp \

    Transform.cpp \

    DisplayHardware/FramebufferSurface.cpp \

    DisplayHardware/HWC2.cpp \

    DisplayHardware/HWC2On1Adapter.cpp \

    DisplayHardware/HWComposer.cpp \

    DisplayHardware/PowerHAL.cpp \

services/surfaceflinger/DisplayHardware/FloatRect.h

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#ifndef ANDROID_SF_FLOAT_RECT

#define ANDROID_SF_FLOAT_RECT



#include <ui/Rect.h>

#include <utils/TypeHelpers.h>



namespace android {

services/surfaceflinger/DisplayHardware/HWC2.cpp

0 → 100644
+992 −0

File added.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/DisplayHardware/HWC2.h

0 → 100644
+377 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2015 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.

 */



#ifndef ANDROID_SF_HWC2_H

#define ANDROID_SF_HWC2_H



#define HWC2_INCLUDE_STRINGIFICATION

#define HWC2_USE_CPP11

#include <hardware/hwcomposer2.h>

#undef HWC2_INCLUDE_STRINGIFICATION

#undef HWC2_USE_CPP11



#include <utils/Log.h>

#include <utils/StrongPointer.h>

#include <utils/Timers.h>



#include <functional>

#include <string>

#include <unordered_map>

#include <vector>



namespace android {

    class Fence;

    class FloatRect;

    class GraphicBuffer;

    class Rect;

    class Region;

}



namespace HWC2 {



class Display;

class Layer;



typedef std::function<void(std::shared_ptr<Display>, Connection)>

        HotplugCallback;

typedef std::function<void(std::shared_ptr<Display>)> RefreshCallback;

typedef std::function<void(std::shared_ptr<Display>, nsecs_t)> VsyncCallback;



class Device

{

public:

    Device(hwc2_device_t* device);

    ~Device();



    friend class HWC2::Display;

    friend class HWC2::Layer;



    // Required by HWC2



    std::string dump() const;



    const std::vector<Capability>& getCapabilities() const {

        return mCapabilities;

    };



    uint32_t getMaxVirtualDisplayCount() const;

    Error createVirtualDisplay(uint32_t width, uint32_t height,

            std::shared_ptr<Display>* outDisplay);



    void registerHotplugCallback(HotplugCallback hotplug);

    void registerRefreshCallback(RefreshCallback refresh);

    void registerVsyncCallback(VsyncCallback vsync);



    // For use by callbacks



    void callHotplug(std::shared_ptr<Display> display, Connection connected);

    void callRefresh(std::shared_ptr<Display> display);

    void callVsync(std::shared_ptr<Display> display, nsecs_t timestamp);



    // Other Device methods



    // This will create a Display if one is not found, but it will not be marked

    // as connected

    std::shared_ptr<Display> getDisplayById(hwc2_display_t id);



private:

    // Initialization methods



    template <typename PFN>

    [[clang::warn_unused_result]] bool loadFunctionPointer(

            FunctionDescriptor desc, PFN& outPFN) {

        auto intDesc = static_cast<int32_t>(desc);

        auto pfn = mHwcDevice->getFunction(mHwcDevice, intDesc);

        if (pfn != nullptr) {

            outPFN = reinterpret_cast<PFN>(pfn);

            return true;

        } else {

            ALOGE("Failed to load function %s", to_string(desc).c_str());

            return false;

        }

    }



    template <typename PFN, typename HOOK>

    void registerCallback(Callback callback, HOOK hook) {

        static_assert(std::is_same<PFN, HOOK>::value,

                "Incompatible function pointer");

        auto intCallback = static_cast<int32_t>(callback);

        auto callbackData = static_cast<hwc2_callback_data_t>(this);

        auto pfn = reinterpret_cast<hwc2_function_pointer_t>(hook);

        mRegisterCallback(mHwcDevice, intCallback, callbackData, pfn);

    }



    void loadCapabilities();

    void loadFunctionPointers();

    void registerCallbacks();



    // For use by Display



    void destroyVirtualDisplay(hwc2_display_t display);



    // Member variables



    hwc2_device_t* mHwcDevice;



    // Device function pointers

    HWC2_PFN_CREATE_VIRTUAL_DISPLAY mCreateVirtualDisplay;

    HWC2_PFN_DESTROY_VIRTUAL_DISPLAY mDestroyVirtualDisplay;

    HWC2_PFN_DUMP mDump;

    HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT mGetMaxVirtualDisplayCount;

    HWC2_PFN_REGISTER_CALLBACK mRegisterCallback;



    // Display function pointers

    HWC2_PFN_ACCEPT_DISPLAY_CHANGES mAcceptDisplayChanges;

    HWC2_PFN_CREATE_LAYER mCreateLayer;

    HWC2_PFN_DESTROY_LAYER mDestroyLayer;

    HWC2_PFN_GET_ACTIVE_CONFIG mGetActiveConfig;

    HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES mGetChangedCompositionTypes;

    HWC2_PFN_GET_DISPLAY_ATTRIBUTE mGetDisplayAttribute;

    HWC2_PFN_GET_DISPLAY_CONFIGS mGetDisplayConfigs;

    HWC2_PFN_GET_DISPLAY_NAME mGetDisplayName;

    HWC2_PFN_GET_DISPLAY_REQUESTS mGetDisplayRequests;

    HWC2_PFN_GET_DISPLAY_TYPE mGetDisplayType;

    HWC2_PFN_GET_DOZE_SUPPORT mGetDozeSupport;

    HWC2_PFN_GET_RELEASE_FENCES mGetReleaseFences;

    HWC2_PFN_PRESENT_DISPLAY mPresentDisplay;

    HWC2_PFN_SET_ACTIVE_CONFIG mSetActiveConfig;

    HWC2_PFN_SET_CLIENT_TARGET mSetClientTarget;

    HWC2_PFN_SET_OUTPUT_BUFFER mSetOutputBuffer;

    HWC2_PFN_SET_POWER_MODE mSetPowerMode;

    HWC2_PFN_SET_VSYNC_ENABLED mSetVsyncEnabled;

    HWC2_PFN_VALIDATE_DISPLAY mValidateDisplay;



    // Layer function pointers

    HWC2_PFN_SET_CURSOR_POSITION mSetCursorPosition;

    HWC2_PFN_SET_LAYER_BUFFER mSetLayerBuffer;

    HWC2_PFN_SET_LAYER_SURFACE_DAMAGE mSetLayerSurfaceDamage;

    HWC2_PFN_SET_LAYER_BLEND_MODE mSetLayerBlendMode;

    HWC2_PFN_SET_LAYER_COLOR mSetLayerColor;

    HWC2_PFN_SET_LAYER_COMPOSITION_TYPE mSetLayerCompositionType;

    HWC2_PFN_SET_LAYER_DISPLAY_FRAME mSetLayerDisplayFrame;

    HWC2_PFN_SET_LAYER_PLANE_ALPHA mSetLayerPlaneAlpha;

    HWC2_PFN_SET_LAYER_SIDEBAND_STREAM mSetLayerSidebandStream;

    HWC2_PFN_SET_LAYER_SOURCE_CROP mSetLayerSourceCrop;

    HWC2_PFN_SET_LAYER_TRANSFORM mSetLayerTransform;

    HWC2_PFN_SET_LAYER_VISIBLE_REGION mSetLayerVisibleRegion;

    HWC2_PFN_SET_LAYER_Z_ORDER mSetLayerZOrder;



    std::vector<Capability> mCapabilities;

    std::unordered_map<hwc2_display_t, std::shared_ptr<Display>> mDisplays;



    HotplugCallback mHotplug;

    std::vector<std::pair<std::shared_ptr<Display>, Connection>>

            mPendingHotplugs;

    RefreshCallback mRefresh;

    std::vector<std::shared_ptr<Display>> mPendingRefreshes;

    VsyncCallback mVsync;

    std::vector<std::pair<std::shared_ptr<Display>, nsecs_t>> mPendingVsyncs;

};



class Display : public std::enable_shared_from_this<Display>

{

public:

    Display(Device& device, hwc2_display_t id);

    ~Display();



    friend class HWC2::Device;

    friend class HWC2::Layer;



    class Config

    {

    public:

        class Builder

        {

        public:

            Builder(Display& display, hwc2_config_t id);



            std::shared_ptr<const Config> build() {

                return std::const_pointer_cast<const Config>(

                        std::move(mConfig));

            }



            Builder& setWidth(int32_t width) {

                mConfig->mWidth = width;

                return *this;

            }

            Builder& setHeight(int32_t height) {

                mConfig->mHeight = height;

                return *this;

            }

            Builder& setVsyncPeriod(int32_t vsyncPeriod) {

                mConfig->mVsyncPeriod = vsyncPeriod;

                return *this;

            }

            Builder& setDpiX(int32_t dpiX) {

                if (dpiX == -1) {

                    mConfig->mDpiX = getDefaultDensity();

                } else {

                    mConfig->mDpiX = dpiX / 1000.0f;

                }

                return *this;

            }

            Builder& setDpiY(int32_t dpiY) {

                if (dpiY == -1) {

                    mConfig->mDpiY = getDefaultDensity();

                } else {

                    mConfig->mDpiY = dpiY / 1000.0f;

                }

                return *this;

            }



        private:

            float getDefaultDensity();

            std::shared_ptr<Config> mConfig;

        };



        hwc2_display_t getDisplayId() const { return mDisplay.getId(); }

        hwc2_config_t getId() const { return mId; }



        int32_t getWidth() const { return mWidth; }

        int32_t getHeight() const { return mHeight; }

        nsecs_t getVsyncPeriod() const { return mVsyncPeriod; }

        float getDpiX() const { return mDpiX; }

        float getDpiY() const { return mDpiY; }



    private:

        Config(Display& display, hwc2_config_t id);



        Display& mDisplay;

        hwc2_config_t mId;



        int32_t mWidth;

        int32_t mHeight;

        nsecs_t mVsyncPeriod;

        float mDpiX;

        float mDpiY;

    };



    // Required by HWC2



    [[clang::warn_unused_result]] Error acceptChanges();

    [[clang::warn_unused_result]] Error createLayer(

            std::shared_ptr<Layer>* outLayer);

    [[clang::warn_unused_result]] Error getActiveConfig(

            std::shared_ptr<const Config>* outConfig) const;

    [[clang::warn_unused_result]] Error getChangedCompositionTypes(

            std::unordered_map<std::shared_ptr<Layer>, Composition>* outTypes);



    // Doesn't call into the HWC2 device, so no errors are possible

    std::vector<std::shared_ptr<const Config>> getConfigs() const;



    [[clang::warn_unused_result]] Error getName(std::string* outName) const;

    [[clang::warn_unused_result]] Error getRequests(

            DisplayRequest* outDisplayRequests,

            std::unordered_map<std::shared_ptr<Layer>, LayerRequest>*

                    outLayerRequests);

    [[clang::warn_unused_result]] Error getType(DisplayType* outType) const;

    [[clang::warn_unused_result]] Error supportsDoze(bool* outSupport) const;

    [[clang::warn_unused_result]] Error getReleaseFences(

            std::unordered_map<std::shared_ptr<Layer>,

                    android::sp<android::Fence>>* outFences) const;

    [[clang::warn_unused_result]] Error present(

            android::sp<android::Fence>* outRetireFence);

    [[clang::warn_unused_result]] Error setActiveConfig(

            const std::shared_ptr<const Config>& config);

    [[clang::warn_unused_result]] Error setClientTarget(

            buffer_handle_t target,

            const android::sp<android::Fence>& acquireFence,

            android_dataspace_t dataspace);

    [[clang::warn_unused_result]] Error setOutputBuffer(

            const android::sp<android::GraphicBuffer>& buffer,

            const android::sp<android::Fence>& releaseFence);

    [[clang::warn_unused_result]] Error setPowerMode(PowerMode mode);

    [[clang::warn_unused_result]] Error setVsyncEnabled(Vsync enabled);

    [[clang::warn_unused_result]] Error validate(uint32_t* outNumTypes,

            uint32_t* outNumRequests);



    // Other Display methods



    Device& getDevice() const { return mDevice; }

    hwc2_display_t getId() const { return mId; }

    bool isConnected() const { return mIsConnected; }



private:

    // For use by Device



    // Virtual displays are always connected

    void setVirtual() {

        mIsVirtual = true;

        mIsConnected = true;

    }



    void setConnected(bool connected) { mIsConnected = connected; }

    int32_t getAttribute(hwc2_config_t configId, Attribute attribute);

    void loadConfig(hwc2_config_t configId);

    void loadConfigs();



    // For use by Layer

    void destroyLayer(hwc2_layer_t layerId);



    // This may fail (and return a null pointer) if no layer with this ID exists

    // on this display

    std::shared_ptr<Layer> getLayerById(hwc2_layer_t id) const;



    // Member variables



    Device& mDevice;

    hwc2_display_t mId;

    bool mIsConnected;

    bool mIsVirtual;

    std::unordered_map<hwc2_layer_t, std::weak_ptr<Layer>> mLayers;

    std::unordered_map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs;

};



class Layer

{

public:

    Layer(const std::shared_ptr<Display>& display, hwc2_layer_t id);

    ~Layer();



    bool isAbandoned() const { return mDisplay.expired(); }

    hwc2_layer_t getId() const { return mId; }



    [[clang::warn_unused_result]] Error setCursorPosition(int32_t x, int32_t y);

    [[clang::warn_unused_result]] Error setBuffer(buffer_handle_t buffer,

            const android::sp<android::Fence>& acquireFence);

    [[clang::warn_unused_result]] Error setSurfaceDamage(

            const android::Region& damage);



    [[clang::warn_unused_result]] Error setBlendMode(BlendMode mode);

    [[clang::warn_unused_result]] Error setColor(hwc_color_t color);

    [[clang::warn_unused_result]] Error setCompositionType(Composition type);

    [[clang::warn_unused_result]] Error setDisplayFrame(

            const android::Rect& frame);

    [[clang::warn_unused_result]] Error setPlaneAlpha(float alpha);

    [[clang::warn_unused_result]] Error setSidebandStream(

            const native_handle_t* stream);

    [[clang::warn_unused_result]] Error setSourceCrop(

            const android::FloatRect& crop);

    [[clang::warn_unused_result]] Error setTransform(Transform transform);

    [[clang::warn_unused_result]] Error setVisibleRegion(

            const android::Region& region);

    [[clang::warn_unused_result]] Error setZOrder(uint32_t z);



private:

    std::weak_ptr<Display> mDisplay;

    hwc2_display_t mDisplayId;

    Device& mDevice;

    hwc2_layer_t mId;

};



} // namespace HWC2



#endif // ANDROID_SF_HWC2_H