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