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 ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_H
18 #define ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_H
19
20 #include <stdint.h>
21 #include <sys/cdefs.h>
22
23 #include <hardware/gralloc.h>
24 #include <hardware/hardware.h>
25 #include <cutils/native_handle.h>
26
27 #include <hardware/hwcomposer_defs.h>
28
29 __BEGIN_DECLS
30
31 /*****************************************************************************/
32
33 /* for compatibility */
34 #define HWC_MODULE_API_VERSION HWC_MODULE_API_VERSION_0_1
35 #define HWC_DEVICE_API_VERSION HWC_DEVICE_API_VERSION_0_1
36 #define HWC_API_VERSION HWC_DEVICE_API_VERSION
37
38 /* Users of this header can define HWC_REMOVE_DEPRECATED_VERSIONS to test that
39 * they still work with just the current version declared, before the
40 * deprecated versions are actually removed.
41 *
42 * To find code that still depends on the old versions, set the #define to 1
43 * here. Code that explicitly sets it to zero (rather than simply not defining
44 * it) will still see the old versions.
45 */
46 #if !defined(HWC_REMOVE_DEPRECATED_VERSIONS)
47 #define HWC_REMOVE_DEPRECATED_VERSIONS 0
48 #endif
49
50 /*****************************************************************************/
51
52 /**
53 * The id of this module
54 */
55 #define HWC_HARDWARE_MODULE_ID "hwcomposer"
56
57 /**
58 * Name of the sensors device to open
59 */
60 #define HWC_HARDWARE_COMPOSER "composer"
61
62 typedef struct hwc_rect {
63 int left;
64 int top;
65 int right;
66 int bottom;
67 } hwc_rect_t;
68
69 typedef struct hwc_region {
70 size_t numRects;
71 hwc_rect_t const* rects;
72 } hwc_region_t;
73
74 typedef struct hwc_color {
75 uint8_t r;
76 uint8_t g;
77 uint8_t b;
78 uint8_t a;
79 } hwc_color_t;
80
81 typedef struct hwc_layer_1 {
82 /*
83 * compositionType is used to specify this layer's type and is set by either
84 * the hardware composer implementation, or by the caller (see below).
85 *
86 * This field is always reset to HWC_BACKGROUND or HWC_FRAMEBUFFER
87 * before (*prepare)() is called when the HWC_GEOMETRY_CHANGED flag is
88 * also set, otherwise, this field is preserved between (*prepare)()
89 * calls.
90 *
91 * HWC_BACKGROUND
92 * Always set by the caller before calling (*prepare)(), this value
93 * indicates this is a special "background" layer. The only valid field
94 * is backgroundColor.
95 * The HWC can toggle this value to HWC_FRAMEBUFFER to indicate it CANNOT
96 * handle the background color.
97 *
98 *
99 * HWC_FRAMEBUFFER_TARGET
100 * Always set by the caller before calling (*prepare)(), this value
101 * indicates this layer is the framebuffer surface used as the target of
102 * OpenGL ES composition. If the HWC sets all other layers to HWC_OVERLAY
103 * or HWC_BACKGROUND, then no OpenGL ES composition will be done, and
104 * this layer should be ignored during set().
105 *
106 * This flag (and the framebuffer surface layer) will only be used if the
107 * HWC version is HWC_DEVICE_API_VERSION_1_1 or higher. In older versions,
108 * the OpenGL ES target surface is communicated by the (dpy, sur) fields
109 * in hwc_compositor_device_1_t.
110 *
111 * This value cannot be set by the HWC implementation.
112 *
113 *
114 * HWC_FRAMEBUFFER
115 * Set by the caller before calling (*prepare)() ONLY when the
116 * HWC_GEOMETRY_CHANGED flag is also set.
117 *
118 * Set by the HWC implementation during (*prepare)(), this indicates
119 * that the layer will be drawn into the framebuffer using OpenGL ES.
120 * The HWC can toggle this value to HWC_OVERLAY to indicate it will
121 * handle the layer.
122 *
123 *
124 * HWC_OVERLAY
125 * Set by the HWC implementation during (*prepare)(), this indicates
126 * that the layer will be handled by the HWC (ie: it must not be
127 * composited with OpenGL ES).
128 *
129 */
130 int32_t compositionType;
131
132 /*
133 * hints is bit mask set by the HWC implementation during (*prepare)().
134 * It is preserved between (*prepare)() calls, unless the
135 * HWC_GEOMETRY_CHANGED flag is set, in which case it is reset to 0.
136 *
137 * see hwc_layer_t::hints
138 */
139 uint32_t hints;
140
141 /* see hwc_layer_t::flags */
142 uint32_t flags;
143
144 union {
145 /* color of the background. hwc_color_t.a is ignored */
146 hwc_color_t backgroundColor;
147
148 struct {
149 /* handle of buffer to compose. This handle is guaranteed to have been
150 * allocated from gralloc using the GRALLOC_USAGE_HW_COMPOSER usage flag. If
151 * the layer's handle is unchanged across two consecutive prepare calls and
152 * the HWC_GEOMETRY_CHANGED flag is not set for the second call then the
153 * HWComposer implementation may assume that the contents of the buffer have
154 * not changed. */
155 buffer_handle_t handle;
156
157 /* transformation to apply to the buffer during composition */
158 uint32_t transform;
159
160 /* blending to apply during composition */
161 int32_t blending;
162
163 /* area of the source to consider, the origin is the top-left corner of
164 * the buffer */
165 hwc_rect_t sourceCrop;
166
167 /* where to composite the sourceCrop onto the display. The sourceCrop
168 * is scaled using linear filtering to the displayFrame. The origin is the
169 * top-left corner of the screen.
170 */
171 hwc_rect_t displayFrame;
172
173 /* visible region in screen space. The origin is the
174 * top-left corner of the screen.
175 * The visible region INCLUDES areas overlapped by a translucent layer.
176 */
177 hwc_region_t visibleRegionScreen;
178
179 /* Sync fence object that will be signaled when the buffer's
180 * contents are available. May be -1 if the contents are already
181 * available. This field is only valid during set(), and should be
182 * ignored during prepare(). The set() call must not wait for the
183 * fence to be signaled before returning, but the HWC must wait for
184 * all buffers to be signaled before reading from them.
185 *
186 * HWC_FRAMEBUFFER layers will never have an acquire fence, since
187 * reads from them are complete before the framebuffer is ready for
188 * display.
189 *
190 * The HWC takes ownership of the acquireFenceFd and is responsible
191 * for closing it when no longer needed.
192 */
193 int acquireFenceFd;
194
195 /* During set() the HWC must set this field to a file descriptor for
196 * a sync fence object that will signal after the HWC has finished
197 * reading from the buffer. The field is ignored by prepare(). Each
198 * layer should have a unique file descriptor, even if more than one
199 * refer to the same underlying fence object; this allows each to be
200 * closed independently.
201 *
202 * If buffer reads can complete at significantly different times,
203 * then using independent fences is preferred. For example, if the
204 * HWC handles some layers with a blit engine and others with
205 * overlays, then the blit layers can be reused immediately after
206 * the blit completes, but the overlay layers can't be reused until
207 * a subsequent frame has been displayed.
208 *
209 * Since HWC doesn't read from HWC_FRAMEBUFFER layers, it shouldn't
210 * produce a release fence for them. The releaseFenceFd will be -1
211 * for these layers when set() is called.
212 *
213 * The HWC client taks ownership of the releaseFenceFd and is
214 * responsible for closing it when no longer needed.
215 */
216 int releaseFenceFd;
217 };
218 };
219
220 /* Allow for expansion w/o breaking binary compatibility.
221 * Pad layer to 96 bytes, assuming 32-bit pointers.
222 */
223 int32_t reserved[24 - 18];
224
225 } hwc_layer_1_t;
226
227 /* This represents a display, typically an EGLDisplay object */
228 typedef void* hwc_display_t;
229
230 /* This represents a surface, typically an EGLSurface object */
231 typedef void* hwc_surface_t;
232
233 /*
234 * hwc_display_contents_1_t::flags values
235 */
236 enum {
237 /*
238 * HWC_GEOMETRY_CHANGED is set by SurfaceFlinger to indicate that the list
239 * passed to (*prepare)() has changed by more than just the buffer handles
240 * and acquire fences.
241 */
242 HWC_GEOMETRY_CHANGED = 0x00000001,
243 };
244
245 /*
246 * Description of the contents to output on a display.
247 *
248 * This is the top-level structure passed to the prepare and set calls to
249 * negotiate and commit the composition of a display image.
250 */
251 typedef struct hwc_display_contents_1 {
252 /* File descriptor referring to a Sync HAL fence object which will signal
253 * when this composition is retired. For a physical display, a composition
254 * is retired when it has been replaced on-screen by a subsequent set. For
255 * a virtual display, the composition is retired when the writes to
256 * outputBuffer are complete and can be read. The fence object is created
257 * and returned by the set call; this field will be -1 on entry to prepare
258 * and set. SurfaceFlinger will close the returned file descriptor.
259 */
260 int retireFenceFd;
261
262 union {
263 /* Fields only relevant for HWC_DEVICE_VERSION_1_0. */
264 struct {
265 /* (dpy, sur) is the target of SurfaceFlinger's OpenGL ES
266 * composition for HWC_DEVICE_VERSION_1_0. They aren't relevant to
267 * prepare. The set call should commit this surface atomically to
268 * the display along with any overlay layers.
269 */
270 hwc_display_t dpy;
271 hwc_surface_t sur;
272 };
273
274 /* Fields only relevant for HWC_DEVICE_VERSION_1_2 and later. */
275 struct {
276 /* outbuf is the buffer that receives the composed image for
277 * virtual displays. Writes to the outbuf must wait until
278 * outbufAcquireFenceFd signals. A fence that will signal when
279 * writes to outbuf are complete should be returned in
280 * retireFenceFd.
281 *
282 * For physical displays, outbuf will be NULL.
283 */
284 buffer_handle_t outbuf;
285
286 /* File descriptor for a fence that will signal when outbuf is
287 * ready to be written. The h/w composer is responsible for closing
288 * this when no longer needed.
289 *
290 * Will be -1 whenever outbuf is NULL, or when the outbuf can be
291 * written immediately.
292 */
293 int outbufAcquireFenceFd;
294 };
295 };
296
297 /* List of layers that will be composed on the display. The buffer handles
298 * in the list will be unique. If numHwLayers is 0, all composition will be
299 * performed by SurfaceFlinger.
300 */
301 uint32_t flags;
302 size_t numHwLayers;
303 hwc_layer_1_t hwLayers[0];
304
305 } hwc_display_contents_1_t;
306
307 /* see hwc_composer_device::registerProcs()
308 * All of the callbacks are required and non-NULL unless otherwise noted.
309 */
310 typedef struct hwc_procs {
311 /*
312 * (*invalidate)() triggers a screen refresh, in particular prepare and set
313 * will be called shortly after this call is made. Note that there is
314 * NO GUARANTEE that the screen refresh will happen after invalidate()
315 * returns (in particular, it could happen before).
316 * invalidate() is GUARANTEED TO NOT CALL BACK into the h/w composer HAL and
317 * it is safe to call invalidate() from any of hwc_composer_device
318 * hooks, unless noted otherwise.
319 */
320 void (*invalidate)(const struct hwc_procs* procs);
321
322 /*
323 * (*vsync)() is called by the h/w composer HAL when a vsync event is
324 * received and HWC_EVENT_VSYNC is enabled on a display
325 * (see: hwc_event_control).
326 *
327 * the "disp" parameter indicates which display the vsync event is for.
328 * the "timestamp" parameter is the system monotonic clock timestamp in
329 * nanosecond of when the vsync event happened.
330 *
331 * vsync() is GUARANTEED TO NOT CALL BACK into the h/w composer HAL.
332 *
333 * It is expected that vsync() is called from a thread of at least
334 * HAL_PRIORITY_URGENT_DISPLAY with as little latency as possible,
335 * typically less than 0.5 ms.
336 *
337 * It is a (silent) error to have HWC_EVENT_VSYNC enabled when calling
338 * hwc_composer_device.set(..., 0, 0, 0) (screen off). The implementation
339 * can either stop or continue to process VSYNC events, but must not
340 * crash or cause other problems.
341 */
342 void (*vsync)(const struct hwc_procs* procs, int disp, int64_t timestamp);
343
344 /*
345 * (*hotplug)() is called by the h/w composer HAL when a display is
346 * connected or disconnected. The PRIMARY display is always connected and
347 * the hotplug callback should not be called for it.
348 *
349 * The disp parameter indicates which display type this event is for.
350 * The connected parameter indicates whether the display has just been
351 * connected (1) or disconnected (0).
352 *
353 * The hotplug() callback may call back into the h/w composer on the same
354 * thread to query refresh rate and dpi for the display. Additionally,
355 * other threads may be calling into the h/w composer while the callback
356 * is in progress.
357 *
358 * The h/w composer must serialize calls to the hotplug callback; only
359 * one thread may call it at a time.
360 *
361 * This callback will be NULL if the h/w composer is using
362 * HWC_DEVICE_API_VERSION_1_0.
363 */
364 void (*hotplug)(const struct hwc_procs* procs, int disp, int connected);
365
366 } hwc_procs_t;
367
368
369 /*****************************************************************************/
370
371 typedef struct hwc_module {
372 struct hw_module_t common;
373 } hwc_module_t;
374
375 typedef struct hwc_composer_device_1 {
376 struct hw_device_t common;
377
378 /*
379 * (*prepare)() is called for each frame before composition and is used by
380 * SurfaceFlinger to determine what composition steps the HWC can handle.
381 *
382 * (*prepare)() can be called more than once, the last call prevails.
383 *
384 * The HWC responds by setting the compositionType field in each layer to
385 * either HWC_FRAMEBUFFER or HWC_OVERLAY. In the former case, the
386 * composition for the layer is handled by SurfaceFlinger with OpenGL ES,
387 * in the later case, the HWC will have to handle the layer's composition.
388 * compositionType and hints are preserved between (*prepare)() calles
389 * unless the HWC_GEOMETRY_CHANGED flag is set.
390 *
391 * (*prepare)() is called with HWC_GEOMETRY_CHANGED to indicate that the
392 * list's geometry has changed, that is, when more than just the buffer's
393 * handles have been updated. Typically this happens (but is not limited to)
394 * when a window is added, removed, resized or moved. In this case
395 * compositionType and hints are reset to their default value.
396 *
397 * For HWC 1.0, numDisplays will always be one, and displays[0] will be
398 * non-NULL.
399 *
400 * For HWC 1.1, numDisplays will always be HWC_NUM_DISPLAY_TYPES. Entries
401 * for unsupported or disabled/disconnected display types will be NULL.
402 *
403 * For HWC 1.2 and later, numDisplays will be HWC_NUM_DISPLAY_TYPES or more.
404 * The extra entries correspond to enabled virtual displays, and will be
405 * non-NULL. In HWC 1.2, support for one virtual display is required, and
406 * no more than one will be used. Future HWC versions might require more.
407 *
408 * returns: 0 on success. An negative error code on error. If an error is
409 * returned, SurfaceFlinger will assume that none of the layer will be
410 * handled by the HWC.
411 */
412 int (*prepare)(struct hwc_composer_device_1 *dev,
413 size_t numDisplays, hwc_display_contents_1_t** displays);
414
415 /*
416 * (*set)() is used in place of eglSwapBuffers(), and assumes the same
417 * functionality, except it also commits the work list atomically with
418 * the actual eglSwapBuffers().
419 *
420 * The layer lists are guaranteed to be the same as the ones returned from
421 * the last call to (*prepare)().
422 *
423 * When this call returns the caller assumes that the displays will be
424 * updated in the near future with the content of their work lists, without
425 * artifacts during the transition from the previous frame.
426 *
427 * A display with zero layers indicates that the entire composition has
428 * been handled by SurfaceFlinger with OpenGL ES. In this case, (*set)()
429 * behaves just like eglSwapBuffers().
430 *
431 * For HWC 1.0, numDisplays will always be one, and displays[0] will be
432 * non-NULL.
433 *
434 * For HWC 1.1, numDisplays will always be HWC_NUM_DISPLAY_TYPES. Entries
435 * for unsupported or disabled/disconnected display types will be NULL.
436 *
437 * For HWC 1.2 and later, numDisplays will be HWC_NUM_DISPLAY_TYPES or more.
438 * The extra entries correspond to enabled virtual displays, and will be
439 * non-NULL. In HWC 1.2, support for one virtual display is required, and
440 * no more than one will be used. Future HWC versions might require more.
441 *
442 * IMPORTANT NOTE: There is an implicit layer containing opaque black
443 * pixels behind all the layers in the list. It is the responsibility of
444 * the hwcomposer module to make sure black pixels are output (or blended
445 * from).
446 *
447 * IMPORTANT NOTE: In the event of an error this call *MUST* still cause
448 * any fences returned in the previous call to set to eventually become
449 * signaled. The caller may have already issued wait commands on these
450 * fences, and having set return without causing those fences to signal
451 * will likely result in a deadlock.
452 *
453 * returns: 0 on success. A negative error code on error:
454 * HWC_EGL_ERROR: eglGetError() will provide the proper error code (only
455 * allowed prior to HWComposer 1.1)
456 * Another code for non EGL errors.
457 */
458 int (*set)(struct hwc_composer_device_1 *dev,
459 size_t numDisplays, hwc_display_contents_1_t** displays);
460
461 /*
462 * eventControl(..., event, enabled)
463 * Enables or disables h/w composer events for a display.
464 *
465 * eventControl can be called from any thread and takes effect
466 * immediately.
467 *
468 * Supported events are:
469 * HWC_EVENT_VSYNC
470 *
471 * returns -EINVAL if the "event" parameter is not one of the value above
472 * or if the "enabled" parameter is not 0 or 1.
473 */
474 int (*eventControl)(struct hwc_composer_device_1* dev, int disp,
475 int event, int enabled);
476
477 /*
478 * blank(..., blank)
479 * Blanks or unblanks a display's screen.
480 *
481 * Turns the screen off when blank is nonzero, on when blank is zero.
482 * Multiple sequential calls with the same blank value must be supported.
483 * The screen state transition must be be complete when the function
484 * returns.
485 *
486 * returns 0 on success, negative on error.
487 */
488 int (*blank)(struct hwc_composer_device_1* dev, int disp, int blank);
489
490 /*
491 * Used to retrieve information about the h/w composer
492 *
493 * Returns 0 on success or -errno on error.
494 */
495 int (*query)(struct hwc_composer_device_1* dev, int what, int* value);
496
497 /*
498 * (*registerProcs)() registers callbacks that the h/w composer HAL can
499 * later use. It will be called immediately after the composer device is
500 * opened with non-NULL procs. It is FORBIDDEN to call any of the callbacks
501 * from within registerProcs(). registerProcs() must save the hwc_procs_t
502 * pointer which is needed when calling a registered callback.
503 */
504 void (*registerProcs)(struct hwc_composer_device_1* dev,
505 hwc_procs_t const* procs);
506
507 /*
508 * This field is OPTIONAL and can be NULL.
509 *
510 * If non NULL it will be called by SurfaceFlinger on dumpsys
511 */
512 void (*dump)(struct hwc_composer_device_1* dev, char *buff, int buff_len);
513
514 /*
515 * (*getDisplayConfigs)() returns handles for the configurations available
516 * on the connected display. These handles must remain valid as long as the
517 * display is connected.
518 *
519 * Configuration handles are written to configs. The number of entries
520 * allocated by the caller is passed in *numConfigs; getDisplayConfigs must
521 * not try to write more than this number of config handles. On return, the
522 * total number of configurations available for the display is returned in
523 * *numConfigs. If *numConfigs is zero on entry, then configs may be NULL.
524 *
525 * HWC_DEVICE_API_VERSION_1_1 does not provide a way to choose a config.
526 * For displays that support multiple configurations, the h/w composer
527 * implementation should choose one and report it as the first config in
528 * the list. Reporting the not-chosen configs is not required.
529 *
530 * Returns 0 on success or -errno on error. If disp is a hotpluggable
531 * display type and no display is connected, an error should be returned.
532 *
533 * This field is REQUIRED for HWC_DEVICE_API_VERSION_1_1 and later.
534 * It should be NULL for previous versions.
535 */
536 int (*getDisplayConfigs)(struct hwc_composer_device_1* dev, int disp,
537 uint32_t* configs, size_t* numConfigs);
538
539 /*
540 * (*getDisplayAttributes)() returns attributes for a specific config of a
541 * connected display. The config parameter is one of the config handles
542 * returned by getDisplayConfigs.
543 *
544 * The list of attributes to return is provided in the attributes
545 * parameter, terminated by HWC_DISPLAY_NO_ATTRIBUTE. The value for each
546 * requested attribute is written in order to the values array. The
547 * HWC_DISPLAY_NO_ATTRIBUTE attribute does not have a value, so the values
548 * array will have one less value than the attributes array.
549 *
550 * This field is REQUIRED for HWC_DEVICE_API_VERSION_1_1 and later.
551 * It should be NULL for previous versions.
552 *
553 * If disp is a hotpluggable display type and no display is connected,
554 * or if config is not a valid configuration for the display, a negative
555 * value should be returned.
556 */
557 int (*getDisplayAttributes)(struct hwc_composer_device_1* dev, int disp,
558 uint32_t config, const uint32_t* attributes, int32_t* values);
559
560 /*
561 * Reserved for future use. Must be NULL.
562 */
563 void* reserved_proc[4];
564
565 } hwc_composer_device_1_t;
566
567 /** convenience API for opening and closing a device */
568
hwc_open_1(const struct hw_module_t * module,hwc_composer_device_1_t ** device)569 static inline int hwc_open_1(const struct hw_module_t* module,
570 hwc_composer_device_1_t** device) {
571 return module->methods->open(module,
572 HWC_HARDWARE_COMPOSER, (struct hw_device_t**)device);
573 }
574
hwc_close_1(hwc_composer_device_1_t * device)575 static inline int hwc_close_1(hwc_composer_device_1_t* device) {
576 return device->common.close(&device->common);
577 }
578
579 /*****************************************************************************/
580
581 #if !HWC_REMOVE_DEPRECATED_VERSIONS
582 #include <hardware/hwcomposer_v0.h>
583 #endif
584
585 __END_DECLS
586
587 #endif /* ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_H */
588