hardware/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 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
 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
 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 */