1 /* 2 * Copyright (C) 2016 ARM Limited. All rights reserved. 3 * 4 * Copyright (C) 2008 The Android Open Source Project 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 19 #ifndef MALI_GRALLOC_FORMATS_H_ 20 #define MALI_GRALLOC_FORMATS_H_ 21 22 #include <system/graphics.h> 23 24 /* Internal formats are represented in gralloc as a 64bit identifier 25 * where the 32 lower bits are a base format and the 32 upper bits are modifiers. 26 * 27 * Modifier bits are divided into mutually exclusive ones and those that are not. 28 */ 29 /* Internal format type */ 30 typedef uint64_t mali_gralloc_internal_format; 31 32 /* Internal format masks */ 33 #define MALI_GRALLOC_INTFMT_FMT_MASK 0x00000000ffffffffULL 34 #define MALI_GRALLOC_INTFMT_EXT_MASK 0xffffffff00000000ULL 35 #define MALI_GRALLOC_INTFMT_ME_EXT_MASK 0x0000ffff00000000ULL 36 #define MALI_GRALLOC_INTFMT_REG_EXT_MASK 0xffff000000000000ULL 37 38 /* Internal base formats */ 39 40 /* Base formats that do not have an identical HAL match 41 * are defined starting at the Android private range 42 */ 43 #define MALI_GRALLOC_FORMAT_INTERNAL_RANGE_BASE 0x100 44 45 typedef enum 46 { 47 /* Internal definitions for HAL formats. */ 48 MALI_GRALLOC_FORMAT_INTERNAL_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888, 49 MALI_GRALLOC_FORMAT_INTERNAL_RGBX_8888 = HAL_PIXEL_FORMAT_RGBX_8888, 50 MALI_GRALLOC_FORMAT_INTERNAL_RGB_888 = HAL_PIXEL_FORMAT_RGB_888, 51 MALI_GRALLOC_FORMAT_INTERNAL_RGB_565 = HAL_PIXEL_FORMAT_RGB_565 , 52 MALI_GRALLOC_FORMAT_INTERNAL_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, 53 MALI_GRALLOC_FORMAT_INTERNAL_YV12 = HAL_PIXEL_FORMAT_YV12 , 54 MALI_GRALLOC_FORMAT_INTERNAL_Y8 = HAL_PIXEL_FORMAT_Y8, 55 MALI_GRALLOC_FORMAT_INTERNAL_Y16 = HAL_PIXEL_FORMAT_Y16, 56 MALI_GRALLOC_FORMAT_INTERNAL_YUV420_888 = HAL_PIXEL_FORMAT_YCbCr_420_888, 57 58 /* Camera specific HAL formats */ 59 MALI_GRALLOC_FORMAT_INTERNAL_RAW16 = HAL_PIXEL_FORMAT_RAW16, 60 MALI_GRALLOC_FORMAT_INTERNAL_RAW12 = HAL_PIXEL_FORMAT_RAW12, 61 MALI_GRALLOC_FORMAT_INTERNAL_RAW10 = HAL_PIXEL_FORMAT_RAW10, 62 MALI_GRALLOC_FORMAT_INTERNAL_BLOB = HAL_PIXEL_FORMAT_BLOB, 63 64 /* Flexible YUV formats would be parsed but not have any representation as 65 * internal format itself but one of the ones below 66 */ 67 68 /* The internal private formats that have no HAL equivivalent are defined 69 * afterwards starting at a specific base range */ 70 MALI_GRALLOC_FORMAT_INTERNAL_NV12 = MALI_GRALLOC_FORMAT_INTERNAL_RANGE_BASE, 71 MALI_GRALLOC_FORMAT_INTERNAL_NV21, 72 MALI_GRALLOC_FORMAT_INTERNAL_YUV422_8BIT, 73 74 /* Extended YUV formats 75 * 76 * NOTE: P010, P210, and Y410 are only supported uncompressed. 77 */ 78 MALI_GRALLOC_FORMAT_INTERNAL_Y0L2, 79 MALI_GRALLOC_FORMAT_INTERNAL_P010, 80 MALI_GRALLOC_FORMAT_INTERNAL_P210, 81 MALI_GRALLOC_FORMAT_INTERNAL_Y210, 82 MALI_GRALLOC_FORMAT_INTERNAL_Y410, 83 84 /* Add more internal formats here. Make sure decode_internal_format() is updated. */ 85 86 /* These are legacy 0.3 gralloc formats used only by the wrap/unwrap macros. */ 87 MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP, 88 MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP, 89 MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP, 90 91 MALI_GRALLOC_FORMAT_INTERNAL_RANGE_LAST, 92 } mali_gralloc_pixel_format; 93 94 95 /* Format Modifier Bits Locations */ 96 #define MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START 32 97 #define MALI_GRALLOC_INTFMT_EXTENSION_BIT_START (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+16) 98 99 /* Mutually Exclusive Modifier Bits */ 100 101 /* This format will use AFBC */ 102 #define MALI_GRALLOC_INTFMT_AFBC_BASIC (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+0)) 103 104 /* This format uses AFBC split block mode */ 105 #define MALI_GRALLOC_INTFMT_AFBC_SPLITBLK (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+1)) 106 107 #define MALI_GRALLOC_INTFMT_UNUSED (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+2)) 108 109 /* This format uses AFBC wide block mode */ 110 #define MALI_GRALLOC_INTFMT_AFBC_WIDEBLK (1ULL << (MALI_GRALLOC_INTFMT_ME_EXTENSION_BIT_START+3)) 111 112 113 /* Regular Modifier Bits */ 114 #define MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS (1ULL << (MALI_GRALLOC_INTFMT_EXTENSION_BIT_START+0)) 115 116 117 /* This mask should be used to check or clear support for AFBC for an internal format 118 * These bits are mutually exclusive so this mask should not be used to enable support 119 */ 120 #define MALI_GRALLOC_INTFMT_AFBCENABLE_MASK ((uint64_t) (MALI_GRALLOC_INTFMT_AFBC_BASIC | \ 121 MALI_GRALLOC_INTFMT_AFBC_SPLITBLK | \ 122 MALI_GRALLOC_INTFMT_AFBC_WIDEBLK)) 123 124 /* Prototypes */ 125 uint64_t mali_gralloc_select_format(int req_format,int usage, int buffer_size); 126 127 /* These are legacy Gralloc 0.3 support macros for passing private formats through the 0.3 alloc interface. 128 * It packs modifier bits together with base format into a 32 bit format identifier. 129 * Gralloc 1.0 interface should use private functions to set private buffer format in the buffer descriptor. 130 * 131 * Packing: 132 * 133 * Bits 15-0: mali_gralloc_pixel_format format 134 * Bits 23-16: mutually exclusive modifier bits 135 * Bits 31-24: regular modifier bits 136 */ 137 static inline int mali_gralloc_format_wrapper(int format, int modifiers) 138 { 139 /* Internal formats that are identical to HAL formats 140 * have the same definition. This is convenient for 141 * client parsing code to not have to parse them separately. 142 * 143 * For 3 of the HAL YUV formats that have very large definitions 144 * this causes problems for packing in modifier bits. 145 * Because of this reason we redefine these three formats 146 * while packing/unpacking them. 147 */ 148 if(format == MALI_GRALLOC_FORMAT_INTERNAL_YV12) 149 { 150 format = MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP; 151 } 152 else if(format == MALI_GRALLOC_FORMAT_INTERNAL_Y8) 153 { 154 format = MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP; 155 } 156 else if(format == MALI_GRALLOC_FORMAT_INTERNAL_Y16) 157 { 158 format = MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP; 159 } 160 return (modifiers | format); 161 } 162 163 static inline uint64_t mali_gralloc_format_unwrap(int x) 164 { 165 uint64_t internal_format = (uint64_t) ( ((((uint64_t)(x)) & 0xff000000) << 24) | // Regular modifier bits 166 ((((uint64_t)(x)) & 0x00ff0000) << 16) | // Mutually exclusive modifier bits 167 (((uint64_t)(x)) & 0x0000ffff) ); // Private format 168 169 uint64_t base_format = internal_format & MALI_GRALLOC_INTFMT_FMT_MASK; 170 uint64_t modifiers = internal_format & MALI_GRALLOC_INTFMT_EXT_MASK; 171 172 if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_YV12_WRAP) 173 { 174 base_format = MALI_GRALLOC_FORMAT_INTERNAL_YV12; 175 } 176 else if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_Y8_WRAP) 177 { 178 base_format = MALI_GRALLOC_FORMAT_INTERNAL_Y8; 179 } 180 else if(base_format == MALI_GRALLOC_FORMAT_INTERNAL_Y16_WRAP) 181 { 182 base_format = MALI_GRALLOC_FORMAT_INTERNAL_Y16; 183 } 184 return (modifiers | base_format); 185 } 186 187 #define GRALLOC_PRIVATE_FORMAT_WRAPPER(x) ( mali_gralloc_format_wrapper(x, 0) ) 188 #define GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC(x) ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_BASIC >> 16)) ) 189 #define GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_SPLITBLK(x) ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_SPLITBLK >> 16)) ) 190 #define GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_WIDEBLK(x) ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_WIDEBLK >> 16)) ) 191 #define GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_TILED_HEADERS_BASIC(x) ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS >> 24) | \ 192 (MALI_GRALLOC_INTFMT_AFBC_BASIC >> 16))) 193 #define GRALLOC_PRIVATE_FORMAT_WRAPPER_AFBC_TILED_HEADERS_WIDE(x) ( mali_gralloc_format_wrapper(x, (MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS >> 24) | \ 194 (MALI_GRALLOC_INTFMT_AFBC_WIDEBLK >> 16))) 195 #define GRALLOC_PRIVATE_FORMAT_UNWRAP(x) mali_gralloc_format_unwrap(x) 196 197 /* IP block capability masks */ 198 #define MALI_GRALLOC_FORMAT_CAPABILITY_OPTIONS_PRESENT ((uint64_t) (1 << 0)) 199 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_BASIC ((uint64_t) (1 << 1)) 200 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_SPLITBLK ((uint64_t) (1 << 2)) 201 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK ((uint64_t) (1 << 3)) 202 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK_YUV_DISABLE ((uint64_t) (1 << 4)) 203 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_YUV_NOREAD ((uint64_t) (1 << 5)) 204 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_YUV_NOWRITE ((uint64_t) (1 << 6)) 205 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_TILED_HEADERS ((uint64_t) (1 << 7)) 206 207 #define MALI_GRALLOC_FORMAT_CAPABILITY_AFBCENABLE_MASK ((uint64_t) (MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_BASIC | \ 208 MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_SPLITBLK | \ 209 MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_WIDEBLK | \ 210 MALI_GRALLOC_FORMAT_CAPABILITY_AFBC_TILED_HEADERS)) 211 212 struct mali_gralloc_format_caps 213 { 214 uint64_t caps_mask; 215 }; 216 typedef struct mali_gralloc_format_caps mali_gralloc_format_caps; 217 218 #define MALI_GRALLOC_FORMATCAPS_SYM_NAME mali_gralloc_format_capabilities 219 #define MALI_GRALLOC_FORMATCAPS_SYM_NAME_STR "mali_gralloc_format_capabilities" 220 221 /* Producer and Consumer definitions */ 222 typedef enum 223 { 224 MALI_GRALLOC_PRODUCER_VIDEO_DECODER, 225 MALI_GRALLOC_PRODUCER_GPU, 226 MALI_GRALLOC_PRODUCER_CAMERA, 227 } mali_gralloc_producer_type; 228 229 typedef enum 230 { 231 232 /* For surface composition in SurfaceFlinger a producer 233 * will not know what consumer will process a buffer. 234 * 235 * MALI_GRALLOC_CONSUMER_GPU_OR_DISPLAY means the GPU 236 * MUST support the given format but it should be allocated 237 * with preference to the DPU. 238 */ 239 MALI_GRALLOC_CONSUMER_GPU_OR_DISPLAY, 240 MALI_GRALLOC_CONSUMER_VIDEO_ENCODER, 241 242 243 /* This is used when no known "premium" dpu is configured. 244 * For example, HDLCD/CLCD would be such a dpu. 245 */ 246 MALI_GRALLOC_CONSUMER_GPU_EXCL, 247 } mali_gralloc_consumer_type; 248 249 250 /* 251 * Below usage types overlap, this is intentional. 252 * The reason is that for Gralloc 0.3 there are very 253 * few usage flags we have at our disposal. 254 * 255 * The overlapping is handled by processing the definitions 256 * in a specific order. 257 * 258 * MALI_GRALLOC_USAGE_PRIVATE_FORMAT and MALI_GRALLOC_USAGE_NO_AFBC 259 * don't overlap and are processed first. 260 * 261 * MALI_GRALLOC_USAGE_YUV_CONF are only for YUV formats and clients 262 * using MALI_GRALLOC_USAGE_NO_AFBC must never allocate YUV formats. 263 * The latter is strictly enforced and allocations will fail. 264 * 265 * MALI_GRALLOC_USAGE_AFBC_PADDING is only valid if MALI_GRALLOC_USAGE_NO_AFBC 266 * is not present. 267 */ 268 typedef enum 269 { 270 /* The client has specified a private format in the format parameter */ 271 MALI_GRALLOC_USAGE_PRIVATE_FORMAT = (int) GRALLOC_USAGE_PRIVATE_3, 272 273 /* Buffer won't be allocated as AFBC */ 274 MALI_GRALLOC_USAGE_NO_AFBC = (int) (GRALLOC_USAGE_PRIVATE_1 | GRALLOC_USAGE_PRIVATE_2), 275 276 /* Valid only for YUV allocations */ 277 MALI_GRALLOC_USAGE_YUV_CONF_0 = 0, 278 MALI_GRALLOC_USAGE_YUV_CONF_1 = (int) GRALLOC_USAGE_PRIVATE_1, 279 MALI_GRALLOC_USAGE_YUV_CONF_2 = (int) GRALLOC_USAGE_PRIVATE_0, 280 MALI_GRALLOC_USAGE_YUV_CONF_3 = (int) (GRALLOC_USAGE_PRIVATE_0 | GRALLOC_USAGE_PRIVATE_1), 281 MALI_GRALLOC_USAGE_YUV_CONF_MASK = MALI_GRALLOC_USAGE_YUV_CONF_3, 282 283 /* A very specific alignment is requested on some buffers */ 284 MALI_GRALLOC_USAGE_AFBC_PADDING = GRALLOC_USAGE_PRIVATE_2, 285 286 } mali_gralloc_usage_type; 287 288 /* Prototypes */ 289 uint64_t mali_gralloc_select_format(int req_format,int usage, int buffer_size); 290 291 #ifdef __cplusplus 292 extern "C" 293 { 294 #endif 295 296 void mali_gralloc_get_gpu_caps(struct mali_gralloc_format_caps *gpu_caps); 297 298 #ifdef __cplusplus 299 } 300 #endif 301 302 #endif /* MALI_GRALLOC_FORMATS_H_ */ 303
