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

Commit a822d52f authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Separate Hwc2::Composer into interface and impl 

This makes the android::Hwc2::Composer substitutable. In this case the
intent is to allow a mock::Composer GMock class to be defined.

Hwc2::Composer now is a pure interface class. Hwc2::impl::Composer is
the normal implementation.

Also included is another minor change to allow HWC2::Device to be
constructed with a Hwc2::Composer (interface) pointer instead of a
service name. This means that now SurfaceFlinger itself constructs the
Hwc2::impl::Composer using the service name, rather than passing it down
a call chain.

Test: Code builds
Bug: None
Change-Id: Ic79f645cee40c534651b9c7b70f05497d98e51dc
parent 989fc50a

libs/vr/libvrflinger/hardware_composer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -244,7 +244,7 @@ void HardwareComposer::OnPostThreadResumed() { 
  // Standalones only create the composer client once and then use SetPowerMode

  // to control the screen on pause/resume.

  if (!is_standalone_device_ || !composer_) {

    composer_.reset(new Hwc2::Composer("default"));

    composer_.reset(new Hwc2::impl::Composer("default"));

    composer_callback_ = new ComposerCallback;

    composer_->registerCallback(composer_callback_);

    LOG_ALWAYS_FATAL_IF(!composer_callback_->HasDisplayId(),

services/surfaceflinger/DisplayHardware/ComposerHal.cpp

+8 −0
Original line number Diff line number Diff line
@@ -31,6 +31,8 @@ using hardware::hidl_handle; 


namespace Hwc2 {



Composer::~Composer() = default;



namespace {



class BufferHandle {
@@ -103,6 +105,8 @@ Error unwrapRet(Return<Error>& ret) 


} // anonymous namespace



namespace impl {



Composer::CommandWriter::CommandWriter(uint32_t initialMaxSize)

    : CommandWriterBase(initialMaxSize) {}
@@ -186,6 +190,8 @@ Composer::Composer(const std::string& serviceName) 
    }

}



Composer::~Composer() = default;



std::vector<IComposer::Capability> Composer::getCapabilities()

{

    std::vector<IComposer::Capability> capabilities;
@@ -1118,6 +1124,8 @@ void CommandReader::takePresentOrValidateStage(Display display, uint32_t* state) 
    *state = data.presentOrValidateState;

}



} // namespace impl



} // namespace Hwc2



} // namespace android

services/surfaceflinger/DisplayHardware/ComposerHal.h

+174 −72
Original line number Diff line number Diff line
@@ -58,6 +58,118 @@ using android::hardware::MQDescriptorSync; 
using android::hardware::hidl_vec;

using android::hardware::hidl_handle;



class Composer {

public:

    virtual ~Composer() = 0;



    virtual std::vector<IComposer::Capability> getCapabilities() = 0;

    virtual std::string dumpDebugInfo() = 0;



    virtual void registerCallback(const sp<IComposerCallback>& callback) = 0;



    // Returns true if the connected composer service is running in a remote

    // process, false otherwise. This will return false if the service is

    // configured in passthrough mode, for example.

    virtual bool isRemote() = 0;



    // Reset all pending commands in the command buffer. Useful if you want to

    // skip a frame but have already queued some commands.

    virtual void resetCommands() = 0;



    // Explicitly flush all pending commands in the command buffer.

    virtual Error executeCommands() = 0;



    virtual uint32_t getMaxVirtualDisplayCount() = 0;

    virtual bool isUsingVrComposer() const = 0;

    virtual Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,

                                       Display* outDisplay) = 0;

    virtual Error destroyVirtualDisplay(Display display) = 0;



    virtual Error acceptDisplayChanges(Display display) = 0;



    virtual Error createLayer(Display display, Layer* outLayer) = 0;

    virtual Error destroyLayer(Display display, Layer layer) = 0;



    virtual Error getActiveConfig(Display display, Config* outConfig) = 0;

    virtual Error getChangedCompositionTypes(

            Display display, std::vector<Layer>* outLayers,

            std::vector<IComposerClient::Composition>* outTypes) = 0;

    virtual Error getColorModes(Display display, std::vector<ColorMode>* outModes) = 0;

    virtual Error getDisplayAttribute(Display display, Config config,

                                      IComposerClient::Attribute attribute, int32_t* outValue) = 0;

    virtual Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs) = 0;

    virtual Error getDisplayName(Display display, std::string* outName) = 0;



    virtual Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,

                                     std::vector<Layer>* outLayers,

                                     std::vector<uint32_t>* outLayerRequestMasks) = 0;



    virtual Error getDisplayType(Display display, IComposerClient::DisplayType* outType) = 0;

    virtual Error getDozeSupport(Display display, bool* outSupport) = 0;

    virtual Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,

                                     float* outMaxLuminance, float* outMaxAverageLuminance,

                                     float* outMinLuminance) = 0;



    virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,

                                   std::vector<int>* outReleaseFences) = 0;



    virtual Error presentDisplay(Display display, int* outPresentFence) = 0;



    virtual Error setActiveConfig(Display display, Config config) = 0;



    /*

     * The composer caches client targets internally.  When target is nullptr,

     * the composer uses slot to look up the client target from its cache.

     * When target is not nullptr, the cache is updated with the new target.

     */

    virtual Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,

                                  int acquireFence, Dataspace dataspace,

                                  const std::vector<IComposerClient::Rect>& damage) = 0;

    virtual Error setColorMode(Display display, ColorMode mode) = 0;

    virtual Error setColorTransform(Display display, const float* matrix, ColorTransform hint) = 0;

    virtual Error setOutputBuffer(Display display, const native_handle_t* buffer,

                                  int releaseFence) = 0;

    virtual Error setPowerMode(Display display, IComposerClient::PowerMode mode) = 0;

    virtual Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) = 0;



    virtual Error setClientTargetSlotCount(Display display) = 0;



    virtual Error validateDisplay(Display display, uint32_t* outNumTypes,

                                  uint32_t* outNumRequests) = 0;



    virtual Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes,

                                           uint32_t* outNumRequests, int* outPresentFence,

                                           uint32_t* state) = 0;



    virtual Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) = 0;

    /* see setClientTarget for the purpose of slot */

    virtual Error setLayerBuffer(Display display, Layer layer, uint32_t slot,

                                 const sp<GraphicBuffer>& buffer, int acquireFence) = 0;

    virtual Error setLayerSurfaceDamage(Display display, Layer layer,

                                        const std::vector<IComposerClient::Rect>& damage) = 0;

    virtual Error setLayerBlendMode(Display display, Layer layer,

                                    IComposerClient::BlendMode mode) = 0;

    virtual Error setLayerColor(Display display, Layer layer,

                                const IComposerClient::Color& color) = 0;

    virtual Error setLayerCompositionType(Display display, Layer layer,

                                          IComposerClient::Composition type) = 0;

    virtual Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) = 0;

    virtual Error setLayerDisplayFrame(Display display, Layer layer,

                                       const IComposerClient::Rect& frame) = 0;

    virtual Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) = 0;

    virtual Error setLayerSidebandStream(Display display, Layer layer,

                                         const native_handle_t* stream) = 0;

    virtual Error setLayerSourceCrop(Display display, Layer layer,

                                     const IComposerClient::FRect& crop) = 0;

    virtual Error setLayerTransform(Display display, Layer layer, Transform transform) = 0;

    virtual Error setLayerVisibleRegion(Display display, Layer layer,

                                        const std::vector<IComposerClient::Rect>& visible) = 0;

    virtual Error setLayerZOrder(Display display, Layer layer, uint32_t z) = 0;

    virtual Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) = 0;

};



namespace impl {



class CommandReader : public CommandReaderBase {

public:

    ~CommandReader();
@@ -134,123 +246,111 @@ private: 
};



// Composer is a wrapper to IComposer, a proxy to server-side composer.

class Composer {

class Composer final : public Hwc2::Composer {

public:

    Composer(const std::string& serviceName);

    ~Composer() override;



    std::vector<IComposer::Capability> getCapabilities();

    std::string dumpDebugInfo();

    std::vector<IComposer::Capability> getCapabilities() override;

    std::string dumpDebugInfo() override;



    void registerCallback(const sp<IComposerCallback>& callback);

    void registerCallback(const sp<IComposerCallback>& callback) override;



    // Returns true if the connected composer service is running in a remote

    // process, false otherwise. This will return false if the service is

    // configured in passthrough mode, for example.

    bool isRemote();

    bool isRemote() override;



    // Reset all pending commands in the command buffer. Useful if you want to

    // skip a frame but have already queued some commands.

    void resetCommands();

    void resetCommands() override;



    // Explicitly flush all pending commands in the command buffer.

    Error executeCommands();

    Error executeCommands() override;



    uint32_t getMaxVirtualDisplayCount();

    bool isUsingVrComposer() const { return mIsUsingVrComposer; }

    Error createVirtualDisplay(uint32_t width, uint32_t height,

            PixelFormat* format, Display* outDisplay);

    Error destroyVirtualDisplay(Display display);

    uint32_t getMaxVirtualDisplayCount() override;

    bool isUsingVrComposer() const override { return mIsUsingVrComposer; }

    Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,

                               Display* outDisplay) override;

    Error destroyVirtualDisplay(Display display) override;



    Error acceptDisplayChanges(Display display);

    Error acceptDisplayChanges(Display display) override;



    Error createLayer(Display display, Layer* outLayer);

    Error destroyLayer(Display display, Layer layer);

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

    Error destroyLayer(Display display, Layer layer) override;



    Error getActiveConfig(Display display, Config* outConfig);

    Error getChangedCompositionTypes(Display display,

            std::vector<Layer>* outLayers,

            std::vector<IComposerClient::Composition>* outTypes);

    Error getColorModes(Display display, std::vector<ColorMode>* outModes);

    Error getDisplayAttribute(Display display, Config config,

            IComposerClient::Attribute attribute, int32_t* outValue);

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

    Error getChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,

                                     std::vector<IComposerClient::Composition>* outTypes) override;

    Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;

    Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,

                              int32_t* outValue) override;

    Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);

    Error getDisplayName(Display display, std::string* outName);

    Error getDisplayName(Display display, std::string* outName) override;



    Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,

                             std::vector<Layer>* outLayers,

            std::vector<uint32_t>* outLayerRequestMasks);

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



    Error getDisplayType(Display display,

            IComposerClient::DisplayType* outType);

    Error getDozeSupport(Display display, bool* outSupport);

    Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,

            float* outMaxLuminance, float* outMaxAverageLuminance,

            float* outMinLuminance);

    Error getDisplayType(Display display, IComposerClient::DisplayType* outType) override;

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

    Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,

                             float* outMaxAverageLuminance, float* outMinLuminance) override;



    Error getReleaseFences(Display display, std::vector<Layer>* outLayers,

            std::vector<int>* outReleaseFences);

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



    Error presentDisplay(Display display, int* outPresentFence);

    Error presentDisplay(Display display, int* outPresentFence) override;



    Error setActiveConfig(Display display, Config config);

    Error setActiveConfig(Display display, Config config) override;



    /*

     * The composer caches client targets internally.  When target is nullptr,

     * the composer uses slot to look up the client target from its cache.

     * When target is not nullptr, the cache is updated with the new target.

     */

    Error setClientTarget(Display display, uint32_t slot,

            const sp<GraphicBuffer>& target,

    Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,

                          int acquireFence, Dataspace dataspace,

            const std::vector<IComposerClient::Rect>& damage);

    Error setColorMode(Display display, ColorMode mode);

    Error setColorTransform(Display display, const float* matrix,

            ColorTransform hint);

                          const std::vector<IComposerClient::Rect>& damage) override;

    Error setColorMode(Display display, ColorMode mode) override;

    Error setColorTransform(Display display, const float* matrix, ColorTransform hint) override;

    Error setOutputBuffer(Display display, const native_handle_t* buffer,

            int releaseFence);

    Error setPowerMode(Display display, IComposerClient::PowerMode mode);

    Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);

                          int releaseFence) override;

    Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;

    Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;



    Error setClientTargetSlotCount(Display display);

    Error setClientTargetSlotCount(Display display) override;



    Error validateDisplay(Display display, uint32_t* outNumTypes,

            uint32_t* outNumRequests);

                          uint32_t* outNumRequests) override;



    Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes,

                                   uint32_t* outNumRequests,

                                   int* outPresentFence,

                                   uint32_t* state);

    Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes, uint32_t* outNumRequests,

                                   int* outPresentFence, uint32_t* state) override;



    Error setCursorPosition(Display display, Layer layer,

            int32_t x, int32_t y);

    Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;

    /* see setClientTarget for the purpose of slot */

    Error setLayerBuffer(Display display, Layer layer, uint32_t slot,

            const sp<GraphicBuffer>& buffer, int acquireFence);

                         const sp<GraphicBuffer>& buffer, int acquireFence) override;

    Error setLayerSurfaceDamage(Display display, Layer layer,

            const std::vector<IComposerClient::Rect>& damage);

    Error setLayerBlendMode(Display display, Layer layer,

            IComposerClient::BlendMode mode);

    Error setLayerColor(Display display, Layer layer,

            const IComposerClient::Color& color);

                                const std::vector<IComposerClient::Rect>& damage) override;

    Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;

    Error setLayerColor(Display display, Layer layer, const IComposerClient::Color& color) override;

    Error setLayerCompositionType(Display display, Layer layer,

            IComposerClient::Composition type);

    Error setLayerDataspace(Display display, Layer layer,

            Dataspace dataspace);

                                  IComposerClient::Composition type) override;

    Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;

    Error setLayerDisplayFrame(Display display, Layer layer,

            const IComposerClient::Rect& frame);

    Error setLayerPlaneAlpha(Display display, Layer layer,

            float alpha);

                               const IComposerClient::Rect& frame) override;

    Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;

    Error setLayerSidebandStream(Display display, Layer layer,

            const native_handle_t* stream);

                                 const native_handle_t* stream) override;

    Error setLayerSourceCrop(Display display, Layer layer,

            const IComposerClient::FRect& crop);

    Error setLayerTransform(Display display, Layer layer,

            Transform transform);

                             const IComposerClient::FRect& crop) override;

    Error setLayerTransform(Display display, Layer layer, Transform transform) override;

    Error setLayerVisibleRegion(Display display, Layer layer,

            const std::vector<IComposerClient::Rect>& visible);

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

    Error setLayerInfo(Display display, Layer layer, uint32_t type,

                       uint32_t appId);

                                const std::vector<IComposerClient::Rect>& visible) override;

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

    Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) override;



private:

    class CommandWriter : public CommandWriterBase {

    public:
@@ -287,6 +387,8 @@ private: 
    const bool mIsUsingVrComposer;

};



} // namespace impl



} // namespace Hwc2



} // namespace android

services/surfaceflinger/DisplayHardware/HWC2.cpp

+1 −6
Original line number Diff line number Diff line
@@ -84,12 +84,7 @@ private: 


// Device methods



Device::Device(const std::string& serviceName)

  : mComposer(std::make_unique<Hwc2::Composer>(serviceName)),

    mCapabilities(),

    mDisplays(),

    mRegisteredCallback(false)

{

Device::Device(std::unique_ptr<android::Hwc2::Composer> composer) : mComposer(std::move(composer)) {

    loadCapabilities();

}

services/surfaceflinger/DisplayHardware/HWC2.h

+2 −4
Original line number Diff line number Diff line
@@ -78,9 +78,7 @@ class ComposerCallback { 
class Device

{

public:

    // Service name is expected to be 'default' or 'vr' for normal use.

    // 'vr' will slightly modify the behavior of the mComposer.

    Device(const std::string& serviceName);

    explicit Device(std::unique_ptr<android::Hwc2::Composer> composer);



    void registerCallback(ComposerCallback* callback, int32_t sequenceId);
@@ -119,7 +117,7 @@ private: 
    std::unique_ptr<android::Hwc2::Composer> mComposer;

    std::unordered_set<Capability> mCapabilities;

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

    bool mRegisteredCallback;

    bool mRegisteredCallback = false;

};



// Convenience C++ class to access hwc2_device_t Display functions directly.