services/surfaceflinger/DisplayHardware/HWComposer.h

   1 /*
   2  * Copyright (C) 2010 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 USE_HWC2
  18 #include "HWComposer_hwc1.h"
  19 #else
  20
  21 #ifndef ANDROID_SF_HWCOMPOSER_H
  22 #define ANDROID_SF_HWCOMPOSER_H
  23
  24 #include "HWC2.h"
  25
  26 #include <stdint.h>
  27 #include <sys/types.h>
  28
  29 #include <ui/Fence.h>
  30
  31 #include <utils/BitSet.h>
  32 #include <utils/Condition.h>
  33 #include <utils/Mutex.h>
  34 #include <utils/StrongPointer.h>
  35 #include <utils/Thread.h>
  36 #include <utils/Timers.h>
  37 #include <utils/Vector.h>
  38
  39 #include <memory>
  40 #include <set>
  41 #include <vector>
  42
  43 extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
  44                            const struct timespec *request,
  45                            struct timespec *remain);
  46
  47 struct framebuffer_device_t;
  48
  49 namespace HWC2 {
  50     class Device;
  51     class Display;
  52 }
  53
  54 namespace android {
  55 // ---------------------------------------------------------------------------
  56
  57 class DisplayDevice;
  58 class Fence;
  59 class FloatRect;
  60 class GraphicBuffer;
  61 class HWC2On1Adapter;
  62 class NativeHandle;
  63 class Region;
  64 class String8;
  65 class SurfaceFlinger;
  66
  67 class HWComposer
  68 {
  69 public:
  70     class EventHandler {
  71         friend class HWComposer;
  72         virtual void onVSyncReceived(int32_t disp, nsecs_t timestamp) = 0;
  73         virtual void onHotplugReceived(int32_t disp, bool connected) = 0;
  74     protected:
  75         virtual ~EventHandler() {}
  76     };
  77
  78     HWComposer(const sp<SurfaceFlinger>& flinger);
  79
  80     ~HWComposer();
  81
  82     void setEventHandler(EventHandler* handler);
  83
  84     bool hasCapability(HWC2::Capability capability) const;
  85
  86     // Attempts to allocate a virtual display. If the virtual display is created
  87     // on the HWC device, outId will contain its HWC ID.
  88     status_t allocateVirtualDisplay(uint32_t width, uint32_t height,
  89             android_pixel_format_t* format, int32_t* outId);
  90
  91     // Attempts to create a new layer on this display
  92     std::shared_ptr<HWC2::Layer> createLayer(int32_t displayId);
  93
  94     // Asks the HAL what it can do
  95     status_t prepare(DisplayDevice& displayDevice);
  96
  97     status_t setClientTarget(int32_t displayId, const sp<Fence>& acquireFence,
  98             const sp<GraphicBuffer>& target, android_dataspace_t dataspace);
  99
 100     // Finalize the layers and present them
 101     status_t commit(int32_t displayId);
 102
 103     // set power mode
 104     status_t setPowerMode(int32_t displayId, int mode);
 105
 106     // set active config
 107     status_t setActiveConfig(int32_t displayId, size_t configId);
 108
 109     // Sets a color transform to be applied to the result of composition
 110     status_t setColorTransform(int32_t displayId, const mat4& transform);
 111
 112     // reset state when an external, non-virtual display is disconnected
 113     void disconnectDisplay(int32_t displayId);
 114
 115     // does this display have layers handled by HWC
 116     bool hasDeviceComposition(int32_t displayId) const;
 117
 118     // does this display have layers handled by GLES
 119     bool hasClientComposition(int32_t displayId) const;
 120
 121     // get the retire fence for the previous frame (i.e., corresponding to the
 122     // last call to presentDisplay
 123     sp<Fence> getRetireFence(int32_t displayId) const;
 124
 125     // Get last release fence for the given layer
 126     sp<Fence> getLayerReleaseFence(int32_t displayId,
 127             const std::shared_ptr<HWC2::Layer>& layer) const;
 128
 129     // Set the output buffer and acquire fence for a virtual display.
 130     // Returns INVALID_OPERATION if displayId is not a virtual display.
 131     status_t setOutputBuffer(int32_t displayId, const sp<Fence>& acquireFence,
 132             const sp<GraphicBuffer>& buf);
 133
 134     // After SurfaceFlinger has retrieved the release fences for all the frames,
 135     // it can call this to clear the shared pointers in the release fence map
 136     void clearReleaseFences(int32_t displayId);
 137
 138     // Returns the HDR capabilities of the given display
 139     std::unique_ptr<HdrCapabilities> getHdrCapabilities(int32_t displayId);
 140
 141     // Events handling ---------------------------------------------------------
 142
 143     void setVsyncEnabled(int32_t disp, HWC2::Vsync enabled);
 144
 145     // Query display parameters.  Pass in a display index (e.g.
 146     // HWC_DISPLAY_PRIMARY).
 147     nsecs_t getRefreshTimestamp(int32_t disp) const;
 148     bool isConnected(int32_t disp) const;
 149
 150     // Non-const because it can update configMap inside of mDisplayData
 151     std::vector<std::shared_ptr<const HWC2::Display::Config>>
 152             getConfigs(int32_t displayId) const;
 153
 154     std::shared_ptr<const HWC2::Display::Config>
 155             getActiveConfig(int32_t displayId) const;
 156
 157     std::vector<android_color_mode_t> getColorModes(int32_t displayId) const;
 158
 159     status_t setActiveColorMode(int32_t displayId, android_color_mode_t mode);
 160
 161     // for debugging ----------------------------------------------------------
 162     void dump(String8& out) const;
 163
 164 private:
 165     static const int32_t VIRTUAL_DISPLAY_ID_BASE = 2;
 166
 167     void loadHwcModule();
 168
 169     bool isValidDisplay(int32_t displayId) const;
 170     static void validateChange(HWC2::Composition from, HWC2::Composition to);
 171
 172     struct cb_context;
 173
 174     void invalidate(const std::shared_ptr<HWC2::Display>& display);
 175     void vsync(const std::shared_ptr<HWC2::Display>& display,
 176             int64_t timestamp);
 177     void hotplug(const std::shared_ptr<HWC2::Display>& display,
 178             HWC2::Connection connected);
 179
 180     struct DisplayData {
 181         DisplayData();
 182         ~DisplayData();
 183         void reset();
 184
 185         bool hasClientComposition;
 186         bool hasDeviceComposition;
 187         std::shared_ptr<HWC2::Display> hwcDisplay;
 188         HWC2::DisplayRequest displayRequests;
 189         sp<Fence> lastRetireFence;  // signals when the last set op retires
 190         std::unordered_map<std::shared_ptr<HWC2::Layer>, sp<Fence>>
 191                 releaseFences;
 192         buffer_handle_t outbufHandle;
 193         sp<Fence> outbufAcquireFence;
 194         mutable std::unordered_map<int32_t,
 195                 std::shared_ptr<const HWC2::Display::Config>> configMap;
 196
 197         // protected by mVsyncLock
 198         HWC2::Vsync vsyncEnabled;
 199     };
 200
 201     sp<SurfaceFlinger>              mFlinger;
 202     std::unique_ptr<HWC2On1Adapter> mAdapter;
 203     std::unique_ptr<HWC2::Device>   mHwcDevice;
 204     std::vector<DisplayData>        mDisplayData;
 205     std::set<size_t>                mFreeDisplaySlots;
 206     std::unordered_map<hwc2_display_t, int32_t> mHwcDisplaySlots;
 207     // protect mDisplayData from races between prepare and dump
 208     mutable Mutex mDisplayLock;
 209
 210     cb_context*                     mCBContext;
 211     EventHandler*                   mEventHandler;
 212     size_t                          mVSyncCounts[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
 213     uint32_t                        mRemainingHwcVirtualDisplays;
 214
 215     // protected by mLock
 216     mutable Mutex mLock;
 217     mutable std::unordered_map<int32_t, nsecs_t> mLastHwVSync;
 218
 219     // thread-safe
 220     mutable Mutex mVsyncLock;
 221 };
 222
 223 // ---------------------------------------------------------------------------
 224 }; // namespace android
 225
 226 #endif // ANDROID_SF_HWCOMPOSER_H
 227
 228 #endif // #ifdef USE_HWC2