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

Commit 0dd5a587 authored by Chia-I Wu's avatar Chia-I Wu Committed by Android (Google) Code Review
Browse files

Merge changes from topic "hwcomposer-cleanup" 

* changes:
  graphics: add composer 2.2 default impl
  graphics: convert composer default impl to a library
  graphics: add Composer to HAL support library
  graphics: move ComposerClient to HAL support library
  graphics: add ComposerCommandEngine
  graphics: add ComposerResources
  graphics: move ComposerBase to HAL support library
  graphics: add libhwc2on{1,fb}adapter
  graphics: more reusable libVtsHalGraphicsComposerTestUtils
  graphics: clang-format composer VTS
  graphics: move libVtsHalGraphicsComposerTestUtils
parents d44414ea de0bd95d

graphics/composer/2.1/default/Android.bp

+8 −35
Original line number Diff line number Diff line 
cc_library_static {

    name: "libhwcomposer-client",

    vendor_available: true,

    defaults: ["hidl_defaults"],

    export_include_dirs: ["."],

    srcs: ["ComposerClient.cpp"],

    shared_libs: [

        "android.hardware.graphics.composer@2.1",

        "android.hardware.graphics.mapper@2.0",

        "libbase",

        "libcutils",

        "libfmq",

        "libhardware",

        "libhidlbase",

        "libhidltransport",

        "liblog",

        "libsync",

        "libutils",

    ],

    header_libs: [

        "android.hardware.graphics.composer@2.1-command-buffer",

    ],

}



cc_library_shared {

    name: "android.hardware.graphics.composer@2.1-impl",

    defaults: ["hidl_defaults"],

    proprietary: true,

    vendor: true,

    relative_install_path: "hw",

    srcs: ["Hwc.cpp"],

    static_libs: ["libhwcomposer-client"],

    srcs: ["passthrough.cpp"],

    header_libs: [

        "android.hardware.graphics.composer@2.1-passthrough",

    ],

    shared_libs: [

        "android.hardware.graphics.composer@2.1",

        "android.hardware.graphics.mapper@2.0",
@@ -44,26 +22,21 @@ cc_library_shared { 
        "libhwc2on1adapter",

        "libhwc2onfbadapter",

    ],

    header_libs: [

        "android.hardware.graphics.composer@2.1-command-buffer",

    cflags: [

        "-DLOG_TAG=\"ComposerHal\""

    ],

}



cc_binary {

    name: "android.hardware.graphics.composer@2.1-service",

    defaults: ["hidl_defaults"],

    proprietary: true,

    vendor: true,

    relative_install_path: "hw",

    srcs: ["service.cpp"],

    init_rc: ["android.hardware.graphics.composer@2.1-service.rc"],

    static_libs: ["libhwcomposer-client"],

    shared_libs: [

        "android.hardware.graphics.composer@2.1",

        "libbase",

        "libbinder",

        "libcutils",

        "libfmq",

        "libhardware",

        "libhidlbase",

        "libhidltransport",

        "liblog",

graphics/composer/2.1/default/ComposerClient.cpp

deleted100644 → 0
+0 −1205

File deleted.

Preview size limit exceeded, changes collapsed.

graphics/composer/2.1/default/ComposerClient.h

deleted100644 → 0
+0 −225
Original line number Diff line number Diff line 
/*

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

 */



#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H

#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H



#include <mutex>

#include <unordered_map>

#include <vector>



#include <composer-command-buffer/2.1/ComposerCommandBuffer.h>

#include <hardware/hwcomposer2.h>

#include "ComposerBase.h"



namespace android {

namespace hardware {

namespace graphics {

namespace composer {

namespace V2_1 {

namespace implementation {



class BufferCacheEntry {

public:

    BufferCacheEntry();

    BufferCacheEntry(BufferCacheEntry&& other);



    BufferCacheEntry(const BufferCacheEntry& other) = delete;

    BufferCacheEntry& operator=(const BufferCacheEntry& other) = delete;



    BufferCacheEntry& operator=(buffer_handle_t handle);

    ~BufferCacheEntry();



    buffer_handle_t getHandle() const { return mHandle; }



private:

    void clear();



    buffer_handle_t mHandle;

};



class ComposerClient : public IComposerClient {

public:

    ComposerClient(ComposerBase& hal);

    virtual ~ComposerClient();



    void initialize();



    void onHotplug(Display display, IComposerCallback::Connection connected);

    void onRefresh(Display display);

    void onVsync(Display display, int64_t timestamp);



    // IComposerClient interface

    Return<void> registerCallback(

            const sp<IComposerCallback>& callback) override;

    Return<uint32_t> getMaxVirtualDisplayCount() override;

    Return<void> createVirtualDisplay(uint32_t width, uint32_t height,

            PixelFormat formatHint, uint32_t outputBufferSlotCount,

            createVirtualDisplay_cb hidl_cb) override;

    Return<Error> destroyVirtualDisplay(Display display) override;

    Return<void> createLayer(Display display, uint32_t bufferSlotCount,

            createLayer_cb hidl_cb) override;

    Return<Error> destroyLayer(Display display, Layer layer) override;

    Return<void> getActiveConfig(Display display,

            getActiveConfig_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> 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<Error> setActiveConfig(Display display, Config config) override;

    Return<Error> setColorMode(Display display, ColorMode mode) override;

    Return<Error> setPowerMode(Display display, PowerMode mode) override;

    Return<Error> setVsyncEnabled(Display display, Vsync enabled) override;

    Return<Error> setClientTargetSlotCount(Display display,

            uint32_t clientTargetSlotCount) override;

    Return<Error> setInputCommandQueue(

            const MQDescriptorSync<uint32_t>& descriptor) override;

    Return<void> getOutputCommandQueue(

            getOutputCommandQueue_cb hidl_cb) override;

    Return<void> executeCommands(uint32_t inLength,

            const hidl_vec<hidl_handle>& inHandles,

            executeCommands_cb hidl_cb) override;



protected:

    struct LayerBuffers {

        std::vector<BufferCacheEntry> Buffers;

        // the handle is a sideband stream handle, not a buffer handle

        BufferCacheEntry SidebandStream;

    };



    struct DisplayData {

        bool IsVirtual;



        std::vector<BufferCacheEntry> ClientTargets;

        std::vector<BufferCacheEntry> OutputBuffers;



        std::unordered_map<Layer, LayerBuffers> Layers;



        DisplayData(bool isVirtual) : IsVirtual(isVirtual) {}

    };



    class CommandReader : public CommandReaderBase {

    public:

        CommandReader(ComposerClient& client);

        virtual ~CommandReader();



        Error parse();



    protected:

        virtual bool parseCommand(IComposerClient::Command command,

                uint16_t length);



        bool parseSelectDisplay(uint16_t length);

        bool parseSelectLayer(uint16_t length);

        bool parseSetColorTransform(uint16_t length);

        bool parseSetClientTarget(uint16_t length);

        bool parseSetOutputBuffer(uint16_t length);

        bool parseValidateDisplay(uint16_t length);

        bool parsePresentOrValidateDisplay(uint16_t length);

        bool parseAcceptDisplayChanges(uint16_t length);

        bool parsePresentDisplay(uint16_t length);

        bool parseSetLayerCursorPosition(uint16_t length);

        bool parseSetLayerBuffer(uint16_t length);

        bool parseSetLayerSurfaceDamage(uint16_t length);

        bool parseSetLayerBlendMode(uint16_t length);

        bool parseSetLayerColor(uint16_t length);

        bool parseSetLayerCompositionType(uint16_t length);

        bool parseSetLayerDataspace(uint16_t length);

        bool parseSetLayerDisplayFrame(uint16_t length);

        bool parseSetLayerPlaneAlpha(uint16_t length);

        bool parseSetLayerSidebandStream(uint16_t length);

        bool parseSetLayerSourceCrop(uint16_t length);

        bool parseSetLayerTransform(uint16_t length);

        bool parseSetLayerVisibleRegion(uint16_t length);

        bool parseSetLayerZOrder(uint16_t length);



        hwc_rect_t readRect();

        std::vector<hwc_rect_t> readRegion(size_t count);

        hwc_frect_t readFRect();



        enum class BufferCache {

            CLIENT_TARGETS,

            OUTPUT_BUFFERS,

            LAYER_BUFFERS,

            LAYER_SIDEBAND_STREAMS,

        };

        Error lookupBufferCacheEntryLocked(BufferCache cache, uint32_t slot,

                BufferCacheEntry** outEntry);

        Error lookupBuffer(BufferCache cache, uint32_t slot,

                bool useCache, buffer_handle_t handle,

                buffer_handle_t* outHandle);

        Error updateBuffer(BufferCache cache, uint32_t slot,

                bool useCache, buffer_handle_t handle);



        Error lookupLayerSidebandStream(buffer_handle_t handle,

                buffer_handle_t* outHandle)

        {

            return lookupBuffer(BufferCache::LAYER_SIDEBAND_STREAMS,

                    0, false, handle, outHandle);

        }

        Error updateLayerSidebandStream(buffer_handle_t handle)

        {

            return updateBuffer(BufferCache::LAYER_SIDEBAND_STREAMS,

                    0, false, handle);

        }



        ComposerClient& mClient;

        ComposerBase& mHal;

        CommandWriterBase& mWriter;



        Display mDisplay;

        Layer mLayer;

    };



    virtual std::unique_ptr<CommandReader> createCommandReader();



    ComposerBase& mHal;



    // 64KiB minus a small space for metadata such as read/write pointers

    static constexpr size_t kWriterInitialSize =

        64 * 1024 / sizeof(uint32_t) - 16;

    std::mutex mCommandMutex;

    std::unique_ptr<CommandReader> mReader;

    CommandWriterBase mWriter;



    sp<IComposerCallback> mCallback;



    std::mutex mDisplayDataMutex;

    std::unordered_map<Display, DisplayData> mDisplayData;

};



} // namespace implementation

} // namespace V2_1

} // namespace composer

} // namespace graphics

} // namespace hardware

} // namespace android



#endif  // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H

graphics/composer/2.1/default/Hwc.cpp

deleted100644 → 0
+0 −817

File deleted.

Preview size limit exceeded, changes collapsed.

graphics/composer/2.1/default/Hwc.h

deleted100644 → 0
+0 −242
Original line number Diff line number Diff line 
/*

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

 */



#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_H

#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_H



#include <atomic>

#include <condition_variable>

#include <memory>

#include <mutex>

#include <unordered_set>

#include <vector>



#include <android/hardware/graphics/composer/2.1/IComposer.h>

#define HWC2_INCLUDE_STRINGIFICATION

#define HWC2_USE_CPP11

#include <hardware/hwcomposer2.h>

#undef HWC2_INCLUDE_STRINGIFICATION

#undef HWC2_USE_CPP11

#include "ComposerBase.h"



namespace android {

    class HWC2On1Adapter;

    class HWC2OnFbAdapter;

}



namespace android {

namespace hardware {

namespace graphics {

namespace composer {

namespace V2_1 {

namespace implementation {



using android::hardware::graphics::common::V1_0::PixelFormat;

using android::hardware::graphics::common::V1_0::Transform;

using android::hardware::graphics::common::V1_0::Dataspace;

using android::hardware::graphics::common::V1_0::ColorMode;

using android::hardware::graphics::common::V1_0::ColorTransform;

using android::hardware::graphics::common::V1_0::Hdr;



class ComposerClient;



class HwcHal : public IComposer, public ComposerBase {

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> createClient(createClient_cb hidl_cb) override;



    // ComposerBase interface

    bool hasCapability(hwc2_capability_t capability) override;

    void removeClient() override;

    void enableCallback(bool enable) override;

    uint32_t getMaxVirtualDisplayCount() override;

    Error createVirtualDisplay(uint32_t width, uint32_t height,

        PixelFormat* format, Display* outDisplay) override;

    Error destroyVirtualDisplay(Display display) override;



    Error createLayer(Display display, Layer* outLayer) override;

    Error destroyLayer(Display display, Layer layer) override;



    Error getActiveConfig(Display display, Config* outConfig) override;

    Error getClientTargetSupport(Display display,

            uint32_t width, uint32_t height,

            PixelFormat format, Dataspace dataspace) override;

    Error getColorModes(Display display,

            hidl_vec<ColorMode>* outModes) override;

    Error getDisplayAttribute(Display display, Config config,

            IComposerClient::Attribute attribute, int32_t* outValue) override;

    Error getDisplayConfigs(Display display,

            hidl_vec<Config>* outConfigs) override;

    Error getDisplayName(Display display, hidl_string* outName) override;

    Error getDisplayType(Display display,

            IComposerClient::DisplayType* outType) override;

    Error getDozeSupport(Display display, bool* outSupport) override;

    Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,

            float* outMaxLuminance, float* outMaxAverageLuminance,

            float* outMinLuminance) override;



    Error setActiveConfig(Display display, Config config) override;

    Error setColorMode(Display display, ColorMode mode) override;

    Error setPowerMode(Display display,

            IComposerClient::PowerMode mode) override;

    Error setVsyncEnabled(Display display,

            IComposerClient::Vsync enabled) override;



    Error setColorTransform(Display display, const float* matrix,

            int32_t hint) override;

    Error setClientTarget(Display display, buffer_handle_t target,

            int32_t acquireFence, int32_t dataspace,

            const std::vector<hwc_rect_t>& damage) override;

    Error setOutputBuffer(Display display, buffer_handle_t buffer,

            int32_t releaseFence) override;

    Error validateDisplay(Display display,

            std::vector<Layer>* outChangedLayers,

            std::vector<IComposerClient::Composition>* outCompositionTypes,

            uint32_t* outDisplayRequestMask,

            std::vector<Layer>* outRequestedLayers,

            std::vector<uint32_t>* outRequestMasks) override;

    Error acceptDisplayChanges(Display display) override;

    Error presentDisplay(Display display, int32_t* outPresentFence,

            std::vector<Layer>* outLayers,

            std::vector<int32_t>* outReleaseFences) override;



    Error setLayerCursorPosition(Display display, Layer layer,

            int32_t x, int32_t y) override;

    Error setLayerBuffer(Display display, Layer layer,

            buffer_handle_t buffer, int32_t acquireFence) override;

    Error setLayerSurfaceDamage(Display display, Layer layer,

            const std::vector<hwc_rect_t>& damage) override;

    Error setLayerBlendMode(Display display, Layer layer,

            int32_t mode) override;

    Error setLayerColor(Display display, Layer layer,

            IComposerClient::Color color) override;

    Error setLayerCompositionType(Display display, Layer layer,

            int32_t type) override;

    Error setLayerDataspace(Display display, Layer layer,

            int32_t dataspace) override;

    Error setLayerDisplayFrame(Display display, Layer layer,

            const hwc_rect_t& frame) override;

    Error setLayerPlaneAlpha(Display display, Layer layer,

            float alpha) override;

    Error setLayerSidebandStream(Display display, Layer layer,

            buffer_handle_t stream) override;

    Error setLayerSourceCrop(Display display, Layer layer,

            const hwc_frect_t& crop) override;

    Error setLayerTransform(Display display, Layer layer,

            int32_t transform) override;

    Error setLayerVisibleRegion(Display display, Layer layer,

            const std::vector<hwc_rect_t>& visible) override;

    Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;



private:

    uint32_t initWithHwc(const hw_module_t* module);

    uint32_t initWithFb(const hw_module_t* module);



    void initCapabilities();



    template<typename T>

    void initDispatch(hwc2_function_descriptor_t desc, T* outPfn);

    void initDispatch();



    sp<ComposerClient> getClient();



    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<hwc2_capability_t> 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;



    std::mutex mClientMutex;

    std::condition_variable mClientDestroyedWait;

    wp<ComposerClient> mClient;



    std::atomic<bool> mMustValidateDisplay;



    // If the HWC implementation version is < 2.0, use an adapter to interface

    // between HWC 2.0 <-> HWC 1.X.

    std::unique_ptr<HWC2On1Adapter> mAdapter;



    // If there is no HWC implementation, use an adapter to interface between

    // HWC 2.0 <-> FB HAL.

    std::unique_ptr<HWC2OnFbAdapter> mFbAdapter;

};



extern "C" IComposer* HIDL_FETCH_IComposer(const char* name);



} // namespace implementation

} // namespace V2_1

} // namespace composer

} // namespace graphics

} // namespace hardware

} // namespace android



#endif  // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_H