blob: 3640bb5a98c4f54a1563e67eecdd5424447ee397 [file] [log] [blame]
Mathias Agopiana350ff92010-08-10 17:14:02 -07001/*
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
Fabien Sanglard9d96de42016-10-11 00:15:18 +000017#ifndef USE_HWC2
18#include "HWComposer_hwc1.h"
19#else
20
Mathias Agopiana350ff92010-08-10 17:14:02 -070021#ifndef ANDROID_SF_HWCOMPOSER_H
22#define ANDROID_SF_HWCOMPOSER_H
23
Dan Stoza9e56aa02015-11-02 13:00:03 -080024#include "HWC2.h"
25
Mathias Agopiana350ff92010-08-10 17:14:02 -070026#include <stdint.h>
27#include <sys/types.h>
28
Jamie Gennis2ec3e072012-11-11 16:24:33 -080029#include <ui/Fence.h>
30
31#include <utils/BitSet.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070032#include <utils/Condition.h>
33#include <utils/Mutex.h>
Mathias Agopianc7d14e22011-08-01 16:32:21 -070034#include <utils/StrongPointer.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070035#include <utils/Thread.h>
36#include <utils/Timers.h>
Mathias Agopian22da60c2011-09-09 00:49:11 -070037#include <utils/Vector.h>
Mathias Agopianc7d14e22011-08-01 16:32:21 -070038
Dan Stoza9e56aa02015-11-02 13:00:03 -080039#include <memory>
40#include <set>
41#include <vector>
42
Mathias Agopian3eb38cb2012-04-03 22:09:52 -070043extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
44 const struct timespec *request,
45 struct timespec *remain);
46
Mathias Agopian8b736f12012-08-13 17:54:26 -070047struct framebuffer_device_t;
Mathias Agopian3e8b8532012-05-13 20:42:01 -070048
Dan Stoza9e56aa02015-11-02 13:00:03 -080049namespace HWC2 {
50 class Device;
51 class Display;
52}
53
Mathias Agopiana350ff92010-08-10 17:14:02 -070054namespace android {
55// ---------------------------------------------------------------------------
56
Dan Stoza9e56aa02015-11-02 13:00:03 -080057class DisplayDevice;
Mathias Agopianda27af92012-09-13 18:17:13 -070058class Fence;
Mathias Agopian6b442672013-07-09 21:24:52 -070059class FloatRect;
Jesse Hall399184a2014-03-03 15:42:54 -080060class GraphicBuffer;
61class NativeHandle;
Jamie Gennis1a4d8832012-08-02 20:11:05 -070062class Region;
Mathias Agopian83727852010-09-23 18:13:21 -070063class String8;
64
Mathias Agopiana350ff92010-08-10 17:14:02 -070065class HWComposer
66{
67public:
Kalle Raitaa099a242017-01-11 11:17:29 -080068 // Uses the named composer service. Valid choices for normal use
69 // are 'default' and 'vr'.
70 HWComposer(const std::string& serviceName);
Mathias Agopian8b736f12012-08-13 17:54:26 -070071
Mathias Agopiana350ff92010-08-10 17:14:02 -070072 ~HWComposer();
73
Steven Thomas94e35b92017-07-26 18:48:28 -070074 void registerCallback(HWC2::ComposerCallback* callback,
75 int32_t sequenceId);
Mathias Agopiana350ff92010-08-10 17:14:02 -070076
Dan Stoza9f26a9c2016-06-22 14:51:09 -070077 bool hasCapability(HWC2::Capability capability) const;
78
Dan Stoza9e56aa02015-11-02 13:00:03 -080079 // Attempts to allocate a virtual display. If the virtual display is created
80 // on the HWC device, outId will contain its HWC ID.
81 status_t allocateVirtualDisplay(uint32_t width, uint32_t height,
Dan Stoza5cf424b2016-05-20 14:02:39 -070082 android_pixel_format_t* format, int32_t* outId);
Mathias Agopiane60b0682012-08-21 23:34:09 -070083
Dan Stoza9e56aa02015-11-02 13:00:03 -080084 // Attempts to create a new layer on this display
Steven Thomas94e35b92017-07-26 18:48:28 -070085 HWC2::Layer* createLayer(int32_t displayId);
86 // Destroy a previously created layer
87 void destroyLayer(int32_t displayId, HWC2::Layer* layer);
Mathias Agopiane60b0682012-08-21 23:34:09 -070088
Mathias Agopiana350ff92010-08-10 17:14:02 -070089 // Asks the HAL what it can do
Dan Stoza9e56aa02015-11-02 13:00:03 -080090 status_t prepare(DisplayDevice& displayDevice);
Mathias Agopiana350ff92010-08-10 17:14:02 -070091
Chia-I Wu06d63de2017-01-04 14:58:51 +080092 status_t setClientTarget(int32_t displayId, uint32_t slot,
93 const sp<Fence>& acquireFence,
Dan Stoza9e56aa02015-11-02 13:00:03 -080094 const sp<GraphicBuffer>& target, android_dataspace_t dataspace);
95
Fabien Sanglarda87aa7b2016-11-30 16:27:22 -080096 // Present layers to the display and read releaseFences.
97 status_t presentAndGetReleaseFences(int32_t displayId);
Mathias Agopiana350ff92010-08-10 17:14:02 -070098
Prashant Malani2c9b11f2014-05-25 01:36:31 -070099 // set power mode
Dan Stoza9e56aa02015-11-02 13:00:03 -0800100 status_t setPowerMode(int32_t displayId, int mode);
Colin Cross10fbdb62012-07-12 17:56:34 -0700101
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700102 // set active config
Dan Stoza9e56aa02015-11-02 13:00:03 -0800103 status_t setActiveConfig(int32_t displayId, size_t configId);
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700104
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700105 // Sets a color transform to be applied to the result of composition
106 status_t setColorTransform(int32_t displayId, const mat4& transform);
107
Andy McFadden27ec5732012-10-02 19:04:45 -0700108 // reset state when an external, non-virtual display is disconnected
Dan Stoza9e56aa02015-11-02 13:00:03 -0800109 void disconnectDisplay(int32_t displayId);
Mathias Agopianda27af92012-09-13 18:17:13 -0700110
Mathias Agopiane60b0682012-08-21 23:34:09 -0700111 // does this display have layers handled by HWC
Dan Stoza9e56aa02015-11-02 13:00:03 -0800112 bool hasDeviceComposition(int32_t displayId) const;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700113
114 // does this display have layers handled by GLES
Dan Stoza9e56aa02015-11-02 13:00:03 -0800115 bool hasClientComposition(int32_t displayId) const;
Mathias Agopian9c6e2972011-09-20 17:21:56 -0700116
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800117 // get the present fence received from the last call to present.
118 sp<Fence> getPresentFence(int32_t displayId) const;
Mathias Agopianda27af92012-09-13 18:17:13 -0700119
Dan Stoza9e56aa02015-11-02 13:00:03 -0800120 // Get last release fence for the given layer
121 sp<Fence> getLayerReleaseFence(int32_t displayId,
Steven Thomas94e35b92017-07-26 18:48:28 -0700122 HWC2::Layer* layer) const;
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700123
Jesse Hall851cfe82013-03-20 13:44:00 -0700124 // Set the output buffer and acquire fence for a virtual display.
Dan Stoza9e56aa02015-11-02 13:00:03 -0800125 // Returns INVALID_OPERATION if displayId is not a virtual display.
126 status_t setOutputBuffer(int32_t displayId, const sp<Fence>& acquireFence,
Jesse Hall851cfe82013-03-20 13:44:00 -0700127 const sp<GraphicBuffer>& buf);
128
Dan Stoza9e56aa02015-11-02 13:00:03 -0800129 // After SurfaceFlinger has retrieved the release fences for all the frames,
130 // it can call this to clear the shared pointers in the release fence map
131 void clearReleaseFences(int32_t displayId);
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700132
Dan Stozac4f471e2016-03-24 09:31:08 -0700133 // Returns the HDR capabilities of the given display
134 std::unique_ptr<HdrCapabilities> getHdrCapabilities(int32_t displayId);
135
Mathias Agopian3eb38cb2012-04-03 22:09:52 -0700136 // Events handling ---------------------------------------------------------
137
Steven Thomas94e35b92017-07-26 18:48:28 -0700138 // Returns true if successful, false otherwise. The
139 // DisplayDevice::DisplayType of the display is returned as an output param.
140 bool onVsync(hwc2_display_t displayId, int64_t timestamp,
141 int32_t* outDisplay);
142 void onHotplug(hwc2_display_t displayId, HWC2::Connection connection);
143
Fabien Sanglarddf0b7052016-11-30 15:51:53 -0800144 void setVsyncEnabled(int32_t displayId, HWC2::Vsync enabled);
Mathias Agopian3eb38cb2012-04-03 22:09:52 -0700145
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700146 // Query display parameters. Pass in a display index (e.g.
147 // HWC_DISPLAY_PRIMARY).
Fabien Sanglarddf0b7052016-11-30 15:51:53 -0800148 nsecs_t getRefreshTimestamp(int32_t displayId) const;
149 bool isConnected(int32_t displayId) const;
Dan Stoza7f7da322014-05-02 15:26:25 -0700150
Dan Stoza9e56aa02015-11-02 13:00:03 -0800151 // Non-const because it can update configMap inside of mDisplayData
152 std::vector<std::shared_ptr<const HWC2::Display::Config>>
153 getConfigs(int32_t displayId) const;
Dan Stoza7f7da322014-05-02 15:26:25 -0700154
Dan Stoza9e56aa02015-11-02 13:00:03 -0800155 std::shared_ptr<const HWC2::Display::Config>
156 getActiveConfig(int32_t displayId) const;
Mathias Agopian3eb38cb2012-04-03 22:09:52 -0700157
Michael Wright28f24d02016-07-12 13:30:53 -0700158 std::vector<android_color_mode_t> getColorModes(int32_t displayId) const;
159
160 status_t setActiveColorMode(int32_t displayId, android_color_mode_t mode);
Courtney Goeltzenleuchterfad9d8c2016-06-23 11:49:50 -0600161
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800162 bool isUsingVrComposer() const;
163
Mathias Agopian3eb38cb2012-04-03 22:09:52 -0700164 // for debugging ----------------------------------------------------------
Mathias Agopian74d211a2013-04-22 16:55:35 +0200165 void dump(String8& out) const;
Mathias Agopian83727852010-09-23 18:13:21 -0700166
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800167 android::Hwc2::Composer* getComposer() const { return mHwcDevice->getComposer(); }
Mathias Agopiana350ff92010-08-10 17:14:02 -0700168private:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800169 static const int32_t VIRTUAL_DISPLAY_ID_BASE = 2;
Jesse Hallb685c542012-07-31 14:32:56 -0700170
Dan Stoza9e56aa02015-11-02 13:00:03 -0800171 bool isValidDisplay(int32_t displayId) const;
172 static void validateChange(HWC2::Composition from, HWC2::Composition to);
Mathias Agopian31d28432012-04-03 16:31:39 -0700173
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700174 struct cb_context;
Mathias Agopian31d28432012-04-03 16:31:39 -0700175
Mathias Agopiane60b0682012-08-21 23:34:09 -0700176 struct DisplayData {
Jesse Halla9a1b002013-02-27 16:39:25 -0800177 DisplayData();
178 ~DisplayData();
Dan Stoza9e56aa02015-11-02 13:00:03 -0800179 void reset();
180
181 bool hasClientComposition;
182 bool hasDeviceComposition;
Steven Thomas94e35b92017-07-26 18:48:28 -0700183 HWC2::Display* hwcDisplay;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800184 HWC2::DisplayRequest displayRequests;
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800185 sp<Fence> lastPresentFence; // signals when the last set op retires
Steven Thomas94e35b92017-07-26 18:48:28 -0700186 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Jesse Hall851cfe82013-03-20 13:44:00 -0700187 buffer_handle_t outbufHandle;
188 sp<Fence> outbufAcquireFence;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800189 mutable std::unordered_map<int32_t,
190 std::shared_ptr<const HWC2::Display::Config>> configMap;
Jamie Gennis2ec3e072012-11-11 16:24:33 -0800191
Dan Stoza9e56aa02015-11-02 13:00:03 -0800192 // protected by mVsyncLock
193 HWC2::Vsync vsyncEnabled;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700194
195 bool validateWasSkipped;
196 HWC2::Error presentError;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700197 };
198
Dan Stoza9e56aa02015-11-02 13:00:03 -0800199 std::unique_ptr<HWC2::Device> mHwcDevice;
200 std::vector<DisplayData> mDisplayData;
201 std::set<size_t> mFreeDisplaySlots;
202 std::unordered_map<hwc2_display_t, int32_t> mHwcDisplaySlots;
Manoj Kumar AVMe04e4ed2015-06-11 14:18:14 -0700203 // protect mDisplayData from races between prepare and dump
204 mutable Mutex mDisplayLock;
Mathias Agopian1e260872012-08-08 18:35:12 -0700205
Jesse Hall5880cc52012-06-05 23:40:32 -0700206 cb_context* mCBContext;
Mathias Agopianbef42c52013-08-21 17:45:46 -0700207 size_t mVSyncCounts[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
Dan Stoza9e56aa02015-11-02 13:00:03 -0800208 uint32_t mRemainingHwcVirtualDisplays;
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700209
210 // protected by mLock
211 mutable Mutex mLock;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800212 mutable std::unordered_map<int32_t, nsecs_t> mLastHwVSync;
Mathias Agopian81cd5d32012-10-04 02:34:38 -0700213
214 // thread-safe
Dan Stoza9e56aa02015-11-02 13:00:03 -0800215 mutable Mutex mVsyncLock;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700216};
217
Mathias Agopiana350ff92010-08-10 17:14:02 -0700218// ---------------------------------------------------------------------------
219}; // namespace android
220
221#endif // ANDROID_SF_HWCOMPOSER_H
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000222
223#endif // #ifdef USE_HWC2