1 /* 2 * Copyright (C) 2008 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_OVERLAY_INTERFACE_H 18 #define ANDROID_OVERLAY_INTERFACE_H 19 20 #include <cutils/native_handle.h> 21 22 #include <hardware/hardware.h> 23 24 #include <stdint.h> 25 #include <sys/cdefs.h> 26 #include <sys/types.h> 27 28 __BEGIN_DECLS 29 30 /** 31 * The id of this module 32 */ 33 #define OVERLAY_HARDWARE_MODULE_ID "overlay" 34 35 /** 36 * Name of the overlay device to open 37 */ 38 #define OVERLAY_HARDWARE_CONTROL "control" 39 #define OVERLAY_HARDWARE_DATA "data" 40 41 /*****************************************************************************/ 42 43 /* possible overlay formats */ 44 enum { 45 OVERLAY_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888, 46 OVERLAY_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565, 47 OVERLAY_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, 48 OVERLAY_FORMAT_YCbYCr_422_I = 0x14, 49 OVERLAY_FORMAT_CbYCrY_422_I = 0x16, 50 OVERLAY_FORMAT_DEFAULT = 99 // The actual color format is determined 51 // by the overlay 52 }; 53 54 /* values for copybit_set_parameter(OVERLAY_TRANSFORM) */ 55 enum { 56 /* flip source image horizontally */ 57 OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H, 58 /* flip source image vertically */ 59 OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V, 60 /* rotate source image 90 degrees */ 61 OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90, 62 /* rotate source image 180 degrees */ 63 OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180, 64 /* rotate source image 270 degrees */ 65 OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270 66 }; 67 68 /* names for setParameter() */ 69 enum { 70 /* rotation of the source image in degrees (0 to 359) */ 71 OVERLAY_ROTATION_DEG = 1, 72 /* enable or disable dithering */ 73 OVERLAY_DITHER = 3, 74 /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */ 75 OVERLAY_TRANSFORM = 4, 76 }; 77 78 /* enable/disable value setParameter() */ 79 enum { 80 OVERLAY_DISABLE = 0, 81 OVERLAY_ENABLE = 1 82 }; 83 84 /* names for get() */ 85 enum { 86 /* Maximum amount of minification supported by the hardware*/ 87 OVERLAY_MINIFICATION_LIMIT = 1, 88 /* Maximum amount of magnification supported by the hardware */ 89 OVERLAY_MAGNIFICATION_LIMIT = 2, 90 /* Number of fractional bits support by the overlay scaling engine */ 91 OVERLAY_SCALING_FRAC_BITS = 3, 92 /* Supported rotation step in degrees. */ 93 OVERLAY_ROTATION_STEP_DEG = 4, 94 /* horizontal alignment in pixels */ 95 OVERLAY_HORIZONTAL_ALIGNMENT = 5, 96 /* vertical alignment in pixels */ 97 OVERLAY_VERTICAL_ALIGNMENT = 6, 98 /* width alignment restrictions. negative number for max. power-of-two */ 99 OVERLAY_WIDTH_ALIGNMENT = 7, 100 /* height alignment restrictions. negative number for max. power-of-two */ 101 OVERLAY_HEIGHT_ALIGNMENT = 8, 102 }; 103 104 /*****************************************************************************/ 105 106 /* opaque reference to an Overlay kernel object */ 107 typedef const native_handle* overlay_handle_t; 108 109 typedef struct overlay_t { 110 uint32_t w; 111 uint32_t h; 112 int32_t format; 113 uint32_t w_stride; 114 uint32_t h_stride; 115 uint32_t reserved[3]; 116 /* returns a reference to this overlay's handle (the caller doesn't 117 * take ownership) */ 118 overlay_handle_t (*getHandleRef)(struct overlay_t* overlay); 119 uint32_t reserved_procs[7]; 120 } overlay_t; 121 122 typedef void* overlay_buffer_t; 123 124 /*****************************************************************************/ 125 126 /** 127 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM 128 * and the fields of this data structure must begin with hw_module_t 129 * followed by module specific information. 130 */ 131 struct overlay_module_t { 132 struct hw_module_t common; 133 }; 134 135 /*****************************************************************************/ 136 137 /** 138 * Every device data structure must begin with hw_device_t 139 * followed by module specific public methods and attributes. 140 */ 141 142 struct overlay_control_device_t { 143 struct hw_device_t common; 144 145 /* get static informations about the capabilities of the overlay engine */ 146 int (*get)(struct overlay_control_device_t *dev, int name); 147 148 /* creates an overlay matching the given parameters as closely as possible. 149 * returns an error if no more overlays are available. The actual 150 * size and format is returned in overlay_t. */ 151 overlay_t* (*createOverlay)(struct overlay_control_device_t *dev, 152 uint32_t w, uint32_t h, int32_t format); 153 154 /* destroys an overlay. This call releases all 155 * resources associated with overlay_t and make it invalid */ 156 void (*destroyOverlay)(struct overlay_control_device_t *dev, 157 overlay_t* overlay); 158 159 /* set position and scaling of the given overlay as closely as possible. 160 * if scaling cannot be performed, overlay must be centered. */ 161 int (*setPosition)(struct overlay_control_device_t *dev, 162 overlay_t* overlay, 163 int x, int y, uint32_t w, uint32_t h); 164 165 /* returns the actual position and size of the overlay */ 166 int (*getPosition)(struct overlay_control_device_t *dev, 167 overlay_t* overlay, 168 int* x, int* y, uint32_t* w, uint32_t* h); 169 170 /* sets configurable parameters for this overlay. returns an error if not 171 * supported. */ 172 int (*setParameter)(struct overlay_control_device_t *dev, 173 overlay_t* overlay, int param, int value); 174 175 int (*stage)(struct overlay_control_device_t *dev, overlay_t* overlay); 176 int (*commit)(struct overlay_control_device_t *dev, overlay_t* overlay); 177 }; 178 179 180 struct overlay_data_device_t { 181 struct hw_device_t common; 182 183 /* initialize the overlay from the given handle. this associates this 184 * overlay data module to its control module */ 185 int (*initialize)(struct overlay_data_device_t *dev, 186 overlay_handle_t handle); 187 188 /* can be called to change the width and height of the overlay. */ 189 int (*resizeInput)(struct overlay_data_device_t *dev, 190 uint32_t w, uint32_t h); 191 192 int (*setCrop)(struct overlay_data_device_t *dev, 193 uint32_t x, uint32_t y, uint32_t w, uint32_t h) ; 194 195 int (*getCrop)(struct overlay_data_device_t *dev, 196 uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h) ; 197 198 int (*setParameter)(struct overlay_data_device_t *dev, 199 int param, int value); 200 201 /* blocks until an overlay buffer is available and return that buffer. */ 202 int (*dequeueBuffer)(struct overlay_data_device_t *dev, 203 overlay_buffer_t *buf); 204 205 /* release the overlay buffer and post it */ 206 int (*queueBuffer)(struct overlay_data_device_t *dev, 207 overlay_buffer_t buffer); 208 209 /* returns the address of a given buffer if supported, NULL otherwise. */ 210 void* (*getBufferAddress)(struct overlay_data_device_t *dev, 211 overlay_buffer_t buffer); 212 213 int (*getBufferCount)(struct overlay_data_device_t *dev); 214 }; 215 216 217 /*****************************************************************************/ 218 219 /** convenience API for opening and closing a device */ 220 221 static inline int overlay_control_open(const struct hw_module_t* module, 222 struct overlay_control_device_t** device) { 223 return module->methods->open(module, 224 OVERLAY_HARDWARE_CONTROL, (struct hw_device_t**)device); 225 } 226 227 static inline int overlay_control_close(struct overlay_control_device_t* device) { 228 return device->common.close(&device->common); 229 } 230 231 static inline int overlay_data_open(const struct hw_module_t* module, 232 struct overlay_data_device_t** device) { 233 return module->methods->open(module, 234 OVERLAY_HARDWARE_DATA, (struct hw_device_t**)device); 235 } 236 237 static inline int overlay_data_close(struct overlay_data_device_t* device) { 238 return device->common.close(&device->common); 239 } 240 241 __END_DECLS 242 243 #endif // ANDROID_OVERLAY_INTERFACE_H 244
