services/surfaceflinger/DisplayHardware/ComposerHal.h

   1 /*
   2  * Copyright 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef ANDROID_SF_COMPOSER_HAL_H
  18 #define ANDROID_SF_COMPOSER_HAL_H
  19
  20 #include <memory>
  21 #include <string>
  22 #include <unordered_map>
  23 #include <utility>
  24 #include <vector>
  25
  26 #include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
  27 #include <android/hardware/graphics/composer/2.1/IComposer.h>
  28 #include <utils/StrongPointer.h>
  29 #include <IComposerCommandBuffer.h>
  30
  31 namespace android {
  32
  33 namespace Hwc2 {
  34
  35 using android::frameworks::vr::composer::V1_0::IVrComposerClient;
  36
  37 using android::hardware::graphics::common::V1_0::ColorMode;
  38 using android::hardware::graphics::common::V1_0::ColorTransform;
  39 using android::hardware::graphics::common::V1_0::Dataspace;
  40 using android::hardware::graphics::common::V1_0::Hdr;
  41 using android::hardware::graphics::common::V1_0::PixelFormat;
  42 using android::hardware::graphics::common::V1_0::Transform;
  43
  44 using android::hardware::graphics::composer::V2_1::IComposer;
  45 using android::hardware::graphics::composer::V2_1::IComposerCallback;
  46 using android::hardware::graphics::composer::V2_1::IComposerClient;
  47 using android::hardware::graphics::composer::V2_1::Error;
  48 using android::hardware::graphics::composer::V2_1::Display;
  49 using android::hardware::graphics::composer::V2_1::Layer;
  50 using android::hardware::graphics::composer::V2_1::Config;
  51
  52 using android::hardware::graphics::composer::V2_1::CommandWriterBase;
  53 using android::hardware::graphics::composer::V2_1::CommandReaderBase;
  54
  55 using android::hardware::kSynchronizedReadWrite;
  56 using android::hardware::MessageQueue;
  57 using android::hardware::MQDescriptorSync;
  58 using android::hardware::hidl_vec;
  59 using android::hardware::hidl_handle;
  60
  61 class CommandReader : public CommandReaderBase {
  62 public:
  63     ~CommandReader();
  64
  65     // Parse and execute commands from the command queue.  The commands are
  66     // actually return values from the server and will be saved in ReturnData.
  67     Error parse();
  68
  69     // Get and clear saved errors.
  70     struct CommandError {
  71         uint32_t location;
  72         Error error;
  73     };
  74     std::vector<CommandError> takeErrors();
  75
  76     bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
  77             uint32_t* outNumLayerRequestMasks) const;
  78
  79     // Get and clear saved changed composition types.
  80     void takeChangedCompositionTypes(Display display,
  81             std::vector<Layer>* outLayers,
  82             std::vector<IComposerClient::Composition>* outTypes);
  83
  84     // Get and clear saved display requests.
  85     void takeDisplayRequests(Display display,
  86         uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
  87         std::vector<uint32_t>* outLayerRequestMasks);
  88
  89     // Get and clear saved release fences.
  90     void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
  91             std::vector<int>* outReleaseFences);
  92
  93     // Get and clear saved present fence.
  94     void takePresentFence(Display display, int* outPresentFence);
  95
  96     // Get what stage succeeded during PresentOrValidate: Present or Validate
  97     void takePresentOrValidateStage(Display display, uint32_t * state);
  98
  99 private:
 100     void resetData();
 101
 102     bool parseSelectDisplay(uint16_t length);
 103     bool parseSetError(uint16_t length);
 104     bool parseSetChangedCompositionTypes(uint16_t length);
 105     bool parseSetDisplayRequests(uint16_t length);
 106     bool parseSetPresentFence(uint16_t length);
 107     bool parseSetReleaseFences(uint16_t length);
 108     bool parseSetPresentOrValidateDisplayResult(uint16_t length);
 109
 110     struct ReturnData {
 111         uint32_t displayRequests = 0;
 112
 113         std::vector<Layer> changedLayers;
 114         std::vector<IComposerClient::Composition> compositionTypes;
 115
 116         std::vector<Layer> requestedLayers;
 117         std::vector<uint32_t> requestMasks;
 118
 119         int presentFence = -1;
 120
 121         std::vector<Layer> releasedLayers;
 122         std::vector<int> releaseFences;
 123
 124         uint32_t presentOrValidateState;
 125     };
 126
 127     std::vector<CommandError> mErrors;
 128     std::unordered_map<Display, ReturnData> mReturnData;
 129
 130     // When SELECT_DISPLAY is parsed, this is updated to point to the
 131     // display's return data in mReturnData.  We use it to avoid repeated
 132     // map lookups.
 133     ReturnData* mCurrentReturnData;
 134 };
 135
 136 // Composer is a wrapper to IComposer, a proxy to server-side composer.
 137 class Composer {
 138 public:
 139     Composer(bool useVrComposer);
 140
 141     std::vector<IComposer::Capability> getCapabilities();
 142     std::string dumpDebugInfo();
 143
 144     void registerCallback(const sp<IComposerCallback>& callback);
 145
 146     // Reset all pending commands in the command buffer. Useful if you want to
 147     // skip a frame but have already queued some commands.
 148     void resetCommands();
 149
 150     uint32_t getMaxVirtualDisplayCount();
 151     bool isUsingVrComposer() const { return mIsUsingVrComposer; }
 152     Error createVirtualDisplay(uint32_t width, uint32_t height,
 153             PixelFormat* format, Display* outDisplay);
 154     Error destroyVirtualDisplay(Display display);
 155
 156     Error acceptDisplayChanges(Display display);
 157
 158     Error createLayer(Display display, Layer* outLayer);
 159     Error destroyLayer(Display display, Layer layer);
 160
 161     Error getActiveConfig(Display display, Config* outConfig);
 162     Error getChangedCompositionTypes(Display display,
 163             std::vector<Layer>* outLayers,
 164             std::vector<IComposerClient::Composition>* outTypes);
 165     Error getColorModes(Display display, std::vector<ColorMode>* outModes);
 166     Error getDisplayAttribute(Display display, Config config,
 167             IComposerClient::Attribute attribute, int32_t* outValue);
 168     Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
 169     Error getDisplayName(Display display, std::string* outName);
 170
 171     Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
 172             std::vector<Layer>* outLayers,
 173             std::vector<uint32_t>* outLayerRequestMasks);
 174
 175     Error getDisplayType(Display display,
 176             IComposerClient::DisplayType* outType);
 177     Error getDozeSupport(Display display, bool* outSupport);
 178     Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,
 179             float* outMaxLuminance, float* outMaxAverageLuminance,
 180             float* outMinLuminance);
 181
 182     Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
 183             std::vector<int>* outReleaseFences);
 184
 185     Error presentDisplay(Display display, int* outPresentFence);
 186
 187     Error setActiveConfig(Display display, Config config);
 188
 189     /*
 190      * The composer caches client targets internally.  When target is nullptr,
 191      * the composer uses slot to look up the client target from its cache.
 192      * When target is not nullptr, the cache is updated with the new target.
 193      */
 194     Error setClientTarget(Display display, uint32_t slot,
 195             const sp<GraphicBuffer>& target,
 196             int acquireFence, Dataspace dataspace,
 197             const std::vector<IComposerClient::Rect>& damage);
 198     Error setColorMode(Display display, ColorMode mode);
 199     Error setColorTransform(Display display, const float* matrix,
 200             ColorTransform hint);
 201     Error setOutputBuffer(Display display, const native_handle_t* buffer,
 202             int releaseFence);
 203     Error setPowerMode(Display display, IComposerClient::PowerMode mode);
 204     Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);
 205
 206     Error setClientTargetSlotCount(Display display);
 207
 208     Error validateDisplay(Display display, uint32_t* outNumTypes,
 209             uint32_t* outNumRequests);
 210
 211     Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
 212                                    uint32_t* outNumRequests,
 213                                    int* outPresentFence,
 214                                    uint32_t* state);
 215
 216     Error setCursorPosition(Display display, Layer layer,
 217             int32_t x, int32_t y);
 218     /* see setClientTarget for the purpose of slot */
 219     Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
 220             const sp<GraphicBuffer>& buffer, int acquireFence);
 221     Error setLayerSurfaceDamage(Display display, Layer layer,
 222             const std::vector<IComposerClient::Rect>& damage);
 223     Error setLayerBlendMode(Display display, Layer layer,
 224             IComposerClient::BlendMode mode);
 225     Error setLayerColor(Display display, Layer layer,
 226             const IComposerClient::Color& color);
 227     Error setLayerCompositionType(Display display, Layer layer,
 228             IComposerClient::Composition type);
 229     Error setLayerDataspace(Display display, Layer layer,
 230             Dataspace dataspace);
 231     Error setLayerDisplayFrame(Display display, Layer layer,
 232             const IComposerClient::Rect& frame);
 233     Error setLayerPlaneAlpha(Display display, Layer layer,
 234             float alpha);
 235     Error setLayerSidebandStream(Display display, Layer layer,
 236             const native_handle_t* stream);
 237     Error setLayerSourceCrop(Display display, Layer layer,
 238             const IComposerClient::FRect& crop);
 239     Error setLayerTransform(Display display, Layer layer,
 240             Transform transform);
 241     Error setLayerVisibleRegion(Display display, Layer layer,
 242             const std::vector<IComposerClient::Rect>& visible);
 243     Error setLayerZOrder(Display display, Layer layer, uint32_t z);
 244     Error setLayerInfo(Display display, Layer layer, uint32_t type,
 245                        uint32_t appId);
 246 private:
 247     class CommandWriter : public CommandWriterBase {
 248     public:
 249         CommandWriter(uint32_t initialMaxSize);
 250         ~CommandWriter() override;
 251
 252         void setLayerInfo(uint32_t type, uint32_t appId);
 253         void setClientTargetMetadata(
 254                 const IVrComposerClient::BufferMetadata& metadata);
 255         void setLayerBufferMetadata(
 256                 const IVrComposerClient::BufferMetadata& metadata);
 257
 258     private:
 259         void writeBufferMetadata(
 260                 const IVrComposerClient::BufferMetadata& metadata);
 261     };
 262
 263     // Many public functions above simply write a command into the command
 264     // queue to batch the calls.  validateDisplay and presentDisplay will call
 265     // this function to execute the command queue.
 266     Error execute();
 267
 268     sp<IComposer> mComposer;
 269     sp<IComposerClient> mClient;
 270
 271     // 64KiB minus a small space for metadata such as read/write pointers
 272     static constexpr size_t kWriterInitialSize =
 273         64 * 1024 / sizeof(uint32_t) - 16;
 274     CommandWriter mWriter;
 275     CommandReader mReader;
 276
 277     // When true, the we attach to the vr_hwcomposer service instead of the
 278     // hwcomposer. This allows us to redirect surfaces to 3d surfaces in vr.
 279     const bool mIsUsingVrComposer;
 280 };
 281
 282 } // namespace Hwc2
 283
 284 } // namespace android
 285
 286 #endif // ANDROID_SF_COMPOSER_HAL_H