blob: 1534fca790e66df04e8cd98decc924b886421b15 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2006 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
Mathias Agopian90ac7992012-02-25 18:48:35 -080017#ifndef ANDROID_GUI_ISURFACE_COMPOSER_H
18#define ANDROID_GUI_ISURFACE_COMPOSER_H
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080019
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <utils/RefBase.h>
24#include <utils/Errors.h>
Svetoslavd85084b2014-03-20 10:28:31 -070025#include <utils/Timers.h>
26#include <utils/Vector.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080027
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070028#include <binder/IInterface.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080029
Kevin DuBois1d4249a2018-08-29 10:45:14 -070030#include <ui/DisplayedFrameStats.h>
Svetoslavd85084b2014-03-20 10:28:31 -070031#include <ui/FrameStats.h>
Chavi Weingarten40482ff2017-11-30 01:51:40 +000032#include <ui/GraphicBuffer.h>
Peiyong Lin9f034472018-03-28 15:29:00 -070033#include <ui/GraphicTypes.h>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070034#include <ui/PixelFormat.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035
Brian Anderson069b3652016-07-22 10:32:47 -070036#include <vector>
37
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080038namespace android {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080039// ----------------------------------------------------------------------------
40
Colin Crossa2362b42016-09-26 13:48:25 -070041struct ComposerState;
42struct DisplayState;
Jesse Hall646f5412014-08-07 22:19:07 -070043struct DisplayInfo;
Lajos Molnare7bda062014-09-18 20:05:27 -070044struct DisplayStatInfo;
chaviw273171b2018-12-26 11:46:30 -080045struct InputWindowCommands;
Kalle Raitaa099a242017-01-11 11:17:29 -080046class LayerDebugInfo;
Dan Stozac4f471e2016-03-24 09:31:08 -070047class HdrCapabilities;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080048class IDisplayEventConnection;
Mathias Agopian2b5dd402017-02-07 17:36:19 -080049class IGraphicBufferProducer;
50class ISurfaceComposerClient;
Dan Stozac1879002014-05-22 15:59:05 -070051class Rect;
Brian Anderson3890c392016-07-25 12:48:08 -070052enum class FrameEvent;
Mathias Agopiana67932f2011-04-20 14:20:59 -070053
Andy McFadden882e3a32013-01-08 16:06:15 -080054/*
55 * This class defines the Binder IPC interface for accessing various
56 * SurfaceFlinger features.
57 */
Mathias Agopian3165cc22012-08-08 19:42:09 -070058class ISurfaceComposer: public IInterface {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080059public:
Colin Cross17576de2016-09-26 13:07:06 -070060 DECLARE_META_INTERFACE(SurfaceComposer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061
Mathias Agopian3165cc22012-08-08 19:42:09 -070062 // flags for setTransactionState()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080063 enum {
Mathias Agopian3165cc22012-08-08 19:42:09 -070064 eSynchronous = 0x01,
Jamie Gennis2d5e2302012-10-15 18:24:43 -070065 eAnimation = 0x02,
Dan Stoza84d619e2018-03-28 17:07:36 -070066
67 // Indicates that this transaction will likely result in a lot of layers being composed, and
68 // thus, SurfaceFlinger should wake-up earlier to avoid missing frame deadlines. In this
69 // case SurfaceFlinger will wake up at (sf vsync offset - debug.sf.early_phase_offset_ns)
70 eEarlyWakeup = 0x04
Jamie Gennis28378392011-10-12 17:39:00 -070071 };
72
Mathias Agopiane57f2922012-08-09 16:29:12 -070073 enum {
74 eDisplayIdMain = 0,
75 eDisplayIdHdmi = 1
76 };
77
Riley Andrewsc3ebe662014-09-04 16:20:31 -070078 enum Rotation {
79 eRotateNone = 0,
80 eRotate90 = 1,
81 eRotate180 = 2,
82 eRotate270 = 3
83 };
84
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -070085 enum VsyncSource {
86 eVsyncSourceApp = 0,
87 eVsyncSourceSurfaceFlinger = 1
88 };
89
Robert Carrb89ea9d2018-12-10 13:01:14 -080090 /*
91 * Create a connection with SurfaceFlinger.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080092 */
Mathias Agopian7e27f052010-05-28 14:22:23 -070093 virtual sp<ISurfaceComposerClient> createConnection() = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080094
Mathias Agopiane57f2922012-08-09 16:29:12 -070095 /* return an IDisplayEventConnection */
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -070096 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
97 VsyncSource vsyncSource = eVsyncSourceApp) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -070098
Jesse Hall6c913be2013-08-08 12:15:49 -070099 /* create a virtual display
Mathias Agopiane57f2922012-08-09 16:29:12 -0700100 * requires ACCESS_SURFACE_FLINGER permission.
101 */
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700102 virtual sp<IBinder> createDisplay(const String8& displayName,
103 bool secure) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700104
Jesse Hall6c913be2013-08-08 12:15:49 -0700105 /* destroy a virtual display
106 * requires ACCESS_SURFACE_FLINGER permission.
107 */
108 virtual void destroyDisplay(const sp<IBinder>& display) = 0;
109
Mathias Agopiane57f2922012-08-09 16:29:12 -0700110 /* get the token for the existing default displays. possible values
111 * for id are eDisplayIdMain and eDisplayIdHdmi.
112 */
113 virtual sp<IBinder> getBuiltInDisplay(int32_t id) = 0;
114
Mathias Agopian9cce3252010-02-09 17:46:37 -0800115 /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
Mathias Agopian3165cc22012-08-08 19:42:09 -0700116 virtual void setTransactionState(const Vector<ComposerState>& state,
Marissa Wall713b63f2018-10-17 15:42:43 -0700117 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -0800118 const sp<IBinder>& applyToken,
119 const InputWindowCommands& inputWindowCommands) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800120
121 /* signal that we're done booting.
Mathias Agopian9cce3252010-02-09 17:46:37 -0800122 * Requires ACCESS_SURFACE_FLINGER permission
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800123 */
124 virtual void bootFinished() = 0;
125
Andy McFadden2adaf042012-12-18 09:49:45 -0800126 /* verify that an IGraphicBufferProducer was created by SurfaceFlinger.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700127 */
128 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800129 const sp<IGraphicBufferProducer>& surface) const = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700130
Brian Anderson6b376712017-04-04 10:51:39 -0700131 /* Returns the frame timestamps supported by SurfaceFlinger.
132 */
133 virtual status_t getSupportedFrameTimestamps(
134 std::vector<FrameEvent>* outSupported) const = 0;
135
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700136 /* set display power mode. depending on the mode, it can either trigger
137 * screen on, off or low power mode and wait for it to complete.
Mathias Agopian041a0752013-03-15 18:31:56 -0700138 * requires ACCESS_SURFACE_FLINGER permission.
139 */
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700140 virtual void setPowerMode(const sp<IBinder>& display, int mode) = 0;
Mathias Agopian3094df32012-06-18 18:06:45 -0700141
Dan Stoza7f7da322014-05-02 15:26:25 -0700142 /* returns information for each configuration of the given display
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700143 * intended to be used to get information about built-in displays */
Dan Stoza7f7da322014-05-02 15:26:25 -0700144 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
145 Vector<DisplayInfo>* configs) = 0;
146
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700147 /* returns display statistics for a given display
148 * intended to be used by the media framework to properly schedule
149 * video frames */
150 virtual status_t getDisplayStats(const sp<IBinder>& display,
151 DisplayStatInfo* stats) = 0;
152
Dan Stoza7f7da322014-05-02 15:26:25 -0700153 /* indicates which of the configurations returned by getDisplayInfo is
154 * currently active */
155 virtual int getActiveConfig(const sp<IBinder>& display) = 0;
156
157 /* specifies which configuration (of those returned by getDisplayInfo)
158 * should be used */
159 virtual status_t setActiveConfig(const sp<IBinder>& display, int id) = 0;
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800160
Michael Wright28f24d02016-07-12 13:30:53 -0700161 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700162 Vector<ui::ColorMode>* outColorModes) = 0;
163 virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& display) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700164 virtual status_t setActiveColorMode(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700165 ui::ColorMode colorMode) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700166
Chia-I Wuff79ef82018-08-22 15:27:32 -0700167 /**
168 * Capture the specified screen. This requires READ_FRAME_BUFFER
169 * permission. This function will fail if there is a secure window on
170 * screen.
171 *
172 * This function can capture a subregion (the source crop) of the screen.
173 * The subregion can be optionally rotated. It will also be scaled to
174 * match the size of the output buffer.
175 *
Peiyong Lin0e003c92018-09-17 11:09:51 -0700176 * reqDataspace and reqPixelFormat specify the data space and pixel format
177 * of the buffer. The caller should pick the data space and pixel format
178 * that it can consume.
179 *
180 * At the moment, sourceCrop is ignored and is always set to the visible
181 * region (projected display viewport) of the screen.
182 *
183 * reqWidth and reqHeight specifies the size of the buffer. When either
184 * of them is 0, they are set to the size of the logical display viewport.
185 *
186 * When useIdentityTransform is true, layer transformations are disabled.
187 *
188 * rotation specifies the rotation of the source crop (and the pixels in
189 * it) around its center.
190 */
191 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
192 const ui::Dataspace reqDataspace,
193 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
194 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform,
195 Rotation rotation = eRotateNone) = 0;
196 /**
197 * Capture the specified screen. This requires READ_FRAME_BUFFER
198 * permission. This function will fail if there is a secure window on
199 * screen.
200 *
201 * This function can capture a subregion (the source crop) of the screen
202 * into an sRGB buffer with RGBA_8888 pixel format.
203 * The subregion can be optionally rotated. It will also be scaled to
204 * match the size of the output buffer.
205 *
Chia-I Wuff79ef82018-08-22 15:27:32 -0700206 * At the moment, sourceCrop is ignored and is always set to the visible
207 * region (projected display viewport) of the screen.
208 *
209 * reqWidth and reqHeight specifies the size of the buffer. When either
210 * of them is 0, they are set to the size of the logical display viewport.
211 *
212 * When useIdentityTransform is true, layer transformations are disabled.
213 *
214 * rotation specifies the rotation of the source crop (and the pixels in
215 * it) around its center.
Mathias Agopian041a0752013-03-15 18:31:56 -0700216 */
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000217 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
218 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700219 bool useIdentityTransform, Rotation rotation = eRotateNone) {
220 return captureScreen(display, outBuffer, ui::Dataspace::V0_SRGB, ui::PixelFormat::RGBA_8888,
221 sourceCrop, reqWidth, reqHeight, useIdentityTransform, rotation);
222 }
Svetoslavd85084b2014-03-20 10:28:31 -0700223
Robert Carr578038f2018-03-09 12:25:24 -0800224 /**
225 * Capture a subtree of the layer hierarchy, potentially ignoring the root node.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700226 *
227 * reqDataspace and reqPixelFormat specify the data space and pixel format
228 * of the buffer. The caller should pick the data space and pixel format
229 * that it can consume.
Robert Carr578038f2018-03-09 12:25:24 -0800230 */
chaviwa76b2712017-09-20 12:02:26 -0700231 virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700232 sp<GraphicBuffer>* outBuffer, const ui::Dataspace reqDataspace,
233 const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr578038f2018-03-09 12:25:24 -0800234 float frameScale = 1.0, bool childrenOnly = false) = 0;
chaviwa76b2712017-09-20 12:02:26 -0700235
Peiyong Lin0e003c92018-09-17 11:09:51 -0700236 /**
237 * Capture a subtree of the layer hierarchy into an sRGB buffer with RGBA_8888 pixel format,
238 * potentially ignoring the root node.
239 */
240 status_t captureLayers(const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
241 const Rect& sourceCrop, float frameScale = 1.0,
242 bool childrenOnly = false) {
243 return captureLayers(layerHandleBinder, outBuffer, ui::Dataspace::V0_SRGB,
244 ui::PixelFormat::RGBA_8888, sourceCrop, frameScale, childrenOnly);
245 }
246
Svetoslavd85084b2014-03-20 10:28:31 -0700247 /* Clears the frame statistics for animations.
248 *
249 * Requires the ACCESS_SURFACE_FLINGER permission.
250 */
251 virtual status_t clearAnimationFrameStats() = 0;
252
253 /* Gets the frame statistics for animations.
254 *
255 * Requires the ACCESS_SURFACE_FLINGER permission.
256 */
257 virtual status_t getAnimationFrameStats(FrameStats* outStats) const = 0;
Dan Stozac4f471e2016-03-24 09:31:08 -0700258
259 /* Gets the supported HDR capabilities of the given display.
260 *
261 * Requires the ACCESS_SURFACE_FLINGER permission.
262 */
263 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
264 HdrCapabilities* outCapabilities) const = 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700265
266 virtual status_t enableVSyncInjections(bool enable) = 0;
267
268 virtual status_t injectVSync(nsecs_t when) = 0;
Kalle Raitaa099a242017-01-11 11:17:29 -0800269
270 /* Gets the list of active layers in Z order for debugging purposes
271 *
272 * Requires the ACCESS_SURFACE_FLINGER permission.
273 */
274 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const = 0;
Peiyong Lin0256f722018-08-31 15:45:10 -0700275
Ady Abraham37965d42018-11-01 13:43:32 -0700276 virtual status_t getColorManagement(bool* outGetColorManagement) const = 0;
Peiyong Linc6780972018-10-28 15:24:08 -0700277
278 /* Gets the composition preference of the default data space and default pixel format,
279 * as well as the wide color gamut data space and wide color gamut pixel format.
280 * If the wide color gamut data space is V0_SRGB, then it implies that the platform
281 * has no wide color gamut support.
282 *
283 * Requires the ACCESS_SURFACE_FLINGER permission.
284 */
285 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
286 ui::PixelFormat* defaultPixelFormat,
287 ui::Dataspace* wideColorGamutDataspace,
288 ui::PixelFormat* wideColorGamutPixelFormat) const = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700289 /*
290 * Requires the ACCESS_SURFACE_FLINGER permission.
291 */
292 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
293 ui::PixelFormat* outFormat,
294 ui::Dataspace* outDataspace,
295 uint8_t* outComponentMask) const = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800296
297 /* Turns on the color sampling engine on the display.
298 *
299 * Requires the ACCESS_SURFACE_FLINGER permission.
300 */
301 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
302 uint8_t componentMask,
303 uint64_t maxFrames) const = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700304
305 /* Returns statistics on the color profile of the last frame displayed for a given display
306 *
307 * Requires the ACCESS_SURFACE_FLINGER permission.
308 */
309 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
310 uint64_t timestamp,
311 DisplayedFrameStats* outStats) const = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800312};
313
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800314// ----------------------------------------------------------------------------
315
Mathias Agopian3165cc22012-08-08 19:42:09 -0700316class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800317public:
Ana Krulec13be8ad2018-08-21 02:43:56 +0000318 enum ISurfaceComposerTag {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800319 // Note: BOOT_FINISHED must remain this value, it is called from
320 // Java by ActivityManagerService.
321 BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,
322 CREATE_CONNECTION,
Ana Krulec13be8ad2018-08-21 02:43:56 +0000323 CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED, // unused, fails permissions check
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800324 CREATE_DISPLAY_EVENT_CONNECTION,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700325 CREATE_DISPLAY,
Jesse Hall6c913be2013-08-08 12:15:49 -0700326 DESTROY_DISPLAY,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700327 GET_BUILT_IN_DISPLAY,
328 SET_TRANSACTION_STATE,
329 AUTHENTICATE_SURFACE,
Brian Anderson069b3652016-07-22 10:32:47 -0700330 GET_SUPPORTED_FRAME_TIMESTAMPS,
Dan Stoza7f7da322014-05-02 15:26:25 -0700331 GET_DISPLAY_CONFIGS,
332 GET_ACTIVE_CONFIG,
333 SET_ACTIVE_CONFIG,
Ana Krulec13be8ad2018-08-21 02:43:56 +0000334 CONNECT_DISPLAY_UNUSED, // unused, fails permissions check
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800335 CAPTURE_SCREEN,
chaviwa76b2712017-09-20 12:02:26 -0700336 CAPTURE_LAYERS,
Svetoslavd85084b2014-03-20 10:28:31 -0700337 CLEAR_ANIMATION_FRAME_STATS,
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700338 GET_ANIMATION_FRAME_STATS,
339 SET_POWER_MODE,
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700340 GET_DISPLAY_STATS,
Dan Stozac4f471e2016-03-24 09:31:08 -0700341 GET_HDR_CAPABILITIES,
Michael Wright28f24d02016-07-12 13:30:53 -0700342 GET_DISPLAY_COLOR_MODES,
343 GET_ACTIVE_COLOR_MODE,
344 SET_ACTIVE_COLOR_MODE,
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700345 ENABLE_VSYNC_INJECTIONS,
Robert Carr1db73f62016-12-21 12:58:51 -0800346 INJECT_VSYNC,
Kalle Raitaa099a242017-01-11 11:17:29 -0800347 GET_LAYER_DEBUG_INFO,
Peiyong Lin0256f722018-08-31 15:45:10 -0700348 GET_COMPOSITION_PREFERENCE,
Ady Abraham37965d42018-11-01 13:43:32 -0700349 GET_COLOR_MANAGEMENT,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700350 GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES,
Kevin DuBois74e53772018-11-19 10:52:38 -0800351 SET_DISPLAY_CONTENT_SAMPLING_ENABLED,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700352 GET_DISPLAYED_CONTENT_SAMPLE,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800353 };
354
Mathias Agopian3165cc22012-08-08 19:42:09 -0700355 virtual status_t onTransact(uint32_t code, const Parcel& data,
356 Parcel* reply, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800357};
358
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800359// ----------------------------------------------------------------------------
360
361}; // namespace android
362
Mathias Agopian90ac7992012-02-25 18:48:35 -0800363#endif // ANDROID_GUI_ISURFACE_COMPOSER_H