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

Commit 9fc2805c authored by Ady Abraham's avatar Ady Abraham
Browse files

SF: split ComposerHal to Hidl/Aidl files 

Bug: 198690444
Test: build
Change-Id: I6b39e58f53065a04b4e6bb5426ae329b25a1dadb
parent e7385f74

libs/vr/libvrflinger/hardware_composer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -239,7 +239,7 @@ void HardwareComposer::UpdatePostThreadState(PostThreadStateType state, 
void HardwareComposer::CreateComposer() {

  if (composer_)

    return;

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

  composer_ = Hwc2::Composer::create("default");

  composer_callback_ = new ComposerCallback;

  composer_->registerCallback(composer_callback_);

  LOG_ALWAYS_FATAL_IF(!composer_callback_->GotFirstHotplug(),

services/surfaceflinger/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -153,6 +153,7 @@ filegroup { 
        "ContainerLayer.cpp",

        "DisplayDevice.cpp",

        "DisplayHardware/AidlComposerHal.cpp",

        "DisplayHardware/HidlComposerHal.cpp",

        "DisplayHardware/ComposerHal.cpp",

        "DisplayHardware/DisplayIdentification.cpp",

        "DisplayHardware/FramebufferSurface.cpp",

services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp

+11 −6
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
#define LOG_TAG "HwcComposer"

#define ATRACE_TAG ATRACE_TAG_GRAPHICS



#include "ComposerHal.h"

#include "AidlComposerHal.h"



#include <android/binder_ibinder_platform.h>

#include <android/binder_manager.h>
@@ -218,12 +218,18 @@ private: 
    sp<V2_4::IComposerCallback> mCallback;

};



namespace impl {

std::string AidlComposer::instance(const std::string& serviceName) {

    return std::string(AidlIComposer::descriptor) + "/" + serviceName;

}



bool AidlComposer::isDeclared(const std::string& serviceName) {

    return AServiceManager_isDeclared(instance(serviceName).c_str());

}



AidlComposer::AidlComposer(const std::string& serviceName) : mWriter(kWriterInitialSize) {

    // This only waits if the service is actually declared

    mAidlComposer = AidlIComposer::fromBinder(ndk::SpAIBinder(

            AServiceManager_waitForService((AidlIComposer::descriptor + serviceName).c_str())));

    mAidlComposer = AidlIComposer::fromBinder(

            ndk::SpAIBinder(AServiceManager_waitForService(instance(serviceName).c_str())));

    if (!mAidlComposer) {

        LOG_ALWAYS_FATAL("Failed to get AIDL composer service");

        return;
@@ -263,7 +269,7 @@ void AidlComposer::registerCallback(const sp<IComposerCallback>& callback) { 
    if (mAidlComposerCallback) {

        ALOGE("Callback already registered");

    }

    mAidlComposerCallback = std::make_shared<AidlIComposerCallbackWrapper>(callback);

    mAidlComposerCallback = ndk::SharedRefBase::make<AidlIComposerCallbackWrapper>(callback);

    AIBinder_setMinSchedulerPolicy(mAidlComposerCallback->asBinder().get(), SCHED_FIFO, 2);



    const auto status = mAidlComposerClient->registerCallback(mAidlComposerCallback);
@@ -1361,6 +1367,5 @@ void AidlCommandReader::takeClientTargetProperty( 
    *outClientTargetProperty = data.clientTargetProperty;

}



} // namespace impl

} // namespace Hwc2

} // namespace android

services/surfaceflinger/DisplayHardware/AidlComposerHal.h

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

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

 */



#pragma once



#include "ComposerHal.h"



#include <optional>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>



// TODO(b/129481165): remove the #pragma below and fix conversion issues

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wconversion"

#pragma clang diagnostic ignored "-Wextra"



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

#include <android/hardware/graphics/composer/2.4/IComposerClient.h>



#include <aidl/android/hardware/graphics/composer3/IComposer.h>

#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>

#include <android/hardware/graphics/composer3/command-buffer.h>



// TODO(b/129481165): remove the #pragma below and fix conversion issues

#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"



namespace android::Hwc2 {



using AidlCommandWriterBase = aidl::android::hardware::graphics::composer3::CommandWriterBase;

using AidlCommandReaderBase = aidl::android::hardware::graphics::composer3::CommandReaderBase;



class AidlIComposerCallbackWrapper;



class AidlCommandReader : public AidlCommandReaderBase {

public:

    ~AidlCommandReader();



    // Parse and execute commands from the command queue.  The commands are

    // actually return values from the server and will be saved in ReturnData.

    int parse();



    // Get and clear saved errors.

    struct CommandError {

        uint32_t location;

        Error error;

    };

    std::vector<CommandError> takeErrors();



    bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,

                    uint32_t* outNumLayerRequestMasks) const;



    // Get and clear saved changed composition types.

    void takeChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,

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



    // Get and clear saved display requests.

    void takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask,

                             std::vector<Layer>* outLayers,

                             std::vector<uint32_t>* outLayerRequestMasks);



    // Get and clear saved release fences.

    void takeReleaseFences(Display display, std::vector<Layer>* outLayers,

                           std::vector<int>* outReleaseFences);



    // Get and clear saved present fence.

    void takePresentFence(Display display, int* outPresentFence);



    // Get what stage succeeded during PresentOrValidate: Present or Validate

    void takePresentOrValidateStage(Display display, uint32_t* state);



    // Get the client target properties requested by hardware composer.

    void takeClientTargetProperty(Display display,

                                  IComposerClient::ClientTargetProperty* outClientTargetProperty);



private:

    void resetData();



    bool parseSelectDisplay(uint16_t length);

    bool parseSetError(uint16_t length);

    bool parseSetChangedCompositionTypes(uint16_t length);

    bool parseSetDisplayRequests(uint16_t length);

    bool parseSetPresentFence(uint16_t length);

    bool parseSetReleaseFences(uint16_t length);

    bool parseSetPresentOrValidateDisplayResult(uint16_t length);

    bool parseSetClientTargetProperty(uint16_t length);



    struct ReturnData {

        uint32_t displayRequests = 0;



        std::vector<Layer> changedLayers;

        std::vector<IComposerClient::Composition> compositionTypes;



        std::vector<Layer> requestedLayers;

        std::vector<uint32_t> requestMasks;



        int presentFence = -1;



        std::vector<Layer> releasedLayers;

        std::vector<int> releaseFences;



        uint32_t presentOrValidateState;



        // Composer 2.4 implementation can return a client target property

        // structure to indicate the client target properties that hardware

        // composer requests. The composer client must change the client target

        // properties to match this request.

        IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888,

                                                                   Dataspace::UNKNOWN};

    };



    std::vector<CommandError> mErrors;

    std::unordered_map<Display, ReturnData> mReturnData;



    // When SELECT_DISPLAY is parsed, this is updated to point to the

    // display's return data in mReturnData.  We use it to avoid repeated

    // map lookups.

    ReturnData* mCurrentReturnData;

};



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

class AidlComposer final : public Hwc2::Composer {

public:

    static bool isDeclared(const std::string& serviceName);



    explicit AidlComposer(const std::string& serviceName);

    ~AidlComposer() override;



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

    std::string dumpDebugInfo() override;



    void registerCallback(const sp<IComposerCallback>& callback) 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() override;



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

    Error executeCommands() override;



    uint32_t getMaxVirtualDisplayCount() override;

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

                               Display* outDisplay) override;

    Error destroyVirtualDisplay(Display display) override;



    Error acceptDisplayChanges(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 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) override;



    Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,

                             std::vector<Layer>* outLayers,

                             std::vector<uint32_t>* outLayerRequestMasks) 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) override;



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



    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,

                          int acquireFence, Dataspace dataspace,

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

    Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;

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

    Error setOutputBuffer(Display display, const native_handle_t* buffer,

                          int releaseFence) override;

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

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



    Error setClientTargetSlotCount(Display display) override;



    Error validateDisplay(Display display, uint32_t* outNumTypes,

                          uint32_t* outNumRequests) override;



    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) override;

    /* see setClientTarget for the purpose of slot */

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

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

    Error setLayerSurfaceDamage(Display display, Layer layer,

                                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) override;

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

    Error setLayerDisplayFrame(Display display, Layer layer,

                               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) override;

    Error setLayerSourceCrop(Display display, Layer layer,

                             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) override;

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



    // Composer HAL 2.2

    Error setLayerPerFrameMetadata(

            Display display, Layer layer,

            const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;

    std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(

            Display display) override;

    Error getRenderIntents(Display display, ColorMode colorMode,

                           std::vector<RenderIntent>* outRenderIntents) override;

    Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;



    // Composer HAL 2.3

    Error getDisplayIdentificationData(Display display, uint8_t* outPort,

                                       std::vector<uint8_t>* outData) override;

    Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;

    Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,

                                                Dataspace* outDataspace,

                                                uint8_t* outComponentMask) override;

    Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask,

                                           uint64_t maxFrames) override;

    Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,

                                    DisplayedFrameStats* outStats) override;

    Error setLayerPerFrameMetadataBlobs(

            Display display, Layer layer,

            const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override;

    Error setDisplayBrightness(Display display, float brightness) override;



    // Composer HAL 2.4

    bool isVsyncPeriodSwitchSupported() override { return true; }

    Error getDisplayCapabilities(Display display,

                                 std::vector<DisplayCapability>* outCapabilities) override;

    V2_4::Error getDisplayConnectionType(Display display,

                                         IComposerClient::DisplayConnectionType* outType) override;

    V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;

    V2_4::Error setActiveConfigWithConstraints(

            Display display, Config config,

            const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,

            VsyncPeriodChangeTimeline* outTimeline) override;

    V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override;

    V2_4::Error getSupportedContentTypes(

            Display displayId,

            std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override;

    V2_4::Error setContentType(Display displayId,

                               IComposerClient::ContentType contentType) override;

    V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key,

                                        bool mandatory, const std::vector<uint8_t>& value) override;

    V2_4::Error getLayerGenericMetadataKeys(

            std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override;

    Error getClientTargetProperty(

            Display display,

            IComposerClient::ClientTargetProperty* outClientTargetProperty) override;



private:

    class AidlCommandWriter : public AidlCommandWriterBase {

    public:

        explicit AidlCommandWriter(uint32_t initialMaxSize)

              : AidlCommandWriterBase(initialMaxSize) {}

        ~AidlCommandWriter() override {}

    };



    // Many public functions above simply write a command into the command

    // queue to batch the calls.  validateDisplay and presentDisplay will call

    // this function to execute the command queue.

    Error execute();



    // returns the default instance name for the given service

    static std::string instance(const std::string& serviceName);



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

    static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;

    // Max number of buffers that may be cached for a given layer

    // We obtain this number by:

    // 1. Tightly coupling this cache to the max size of BufferQueue

    // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)

    static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;

    AidlCommandWriter mWriter;

    AidlCommandReader mReader;



    // Aidl interface

    using AidlIComposer = aidl::android::hardware::graphics::composer3::IComposer;

    using AidlIComposerClient = aidl::android::hardware::graphics::composer3::IComposerClient;

    std::shared_ptr<AidlIComposer> mAidlComposer;

    std::shared_ptr<AidlIComposerClient> mAidlComposerClient;

    std::shared_ptr<AidlIComposerCallbackWrapper> mAidlComposerCallback;

};



} // namespace android::Hwc2

services/surfaceflinger/DisplayHardware/ComposerHal.cpp

+8 −1547

File changed.

Preview size limit exceeded, changes collapsed.