1/*
2 * Copyright (C) 2011 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 SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H
18#define SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H
19
20#include <stddef.h>
21#include <stdint.h>
22
23/*
24 * Some of the enums are now defined in HIDL in hardware/interfaces and are
25 * generated.
26 */
27#include "graphics-base.h"
28#include "graphics-sw.h"
29
30#ifdef __cplusplus
31extern "C" {
32#endif
33
34/* for compatibility */
35#define HAL_PIXEL_FORMAT_YCbCr_420_888 HAL_PIXEL_FORMAT_YCBCR_420_888
36#define HAL_PIXEL_FORMAT_YCbCr_422_SP HAL_PIXEL_FORMAT_YCBCR_422_SP
37#define HAL_PIXEL_FORMAT_YCrCb_420_SP HAL_PIXEL_FORMAT_YCRCB_420_SP
38#define HAL_PIXEL_FORMAT_YCbCr_422_I HAL_PIXEL_FORMAT_YCBCR_422_I
39typedef android_pixel_format_t android_pixel_format;
40typedef android_transform_t android_transform;
41typedef android_dataspace_t android_dataspace;
42typedef android_color_mode_t android_color_mode;
43typedef android_color_transform_t android_color_transform;
44typedef android_hdr_t android_hdr;
45
46/*
47 * If the HAL needs to create service threads to handle graphics related
48 * tasks, these threads need to run at HAL_PRIORITY_URGENT_DISPLAY priority
49 * if they can block the main rendering thread in any way.
50 *
51 * the priority of the current thread can be set with:
52 *
53 *      #include <sys/resource.h>
54 *      setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
55 *
56 */
57
58#define HAL_PRIORITY_URGENT_DISPLAY     (-8)
59
60/*
61 * Structure for describing YCbCr formats for consumption by applications.
62 * This is used with HAL_PIXEL_FORMAT_YCbCr_*_888.
63 *
64 * Buffer chroma subsampling is defined in the format.
65 * e.g. HAL_PIXEL_FORMAT_YCbCr_420_888 has subsampling 4:2:0.
66 *
67 * Buffers must have a 8 bit depth.
68 *
69 * y, cb, and cr point to the first byte of their respective planes.
70 *
71 * Stride describes the distance in bytes from the first value of one row of
72 * the image to the first value of the next row.  It includes the width of the
73 * image plus padding.
74 * ystride is the stride of the luma plane.
75 * cstride is the stride of the chroma planes.
76 *
77 * chroma_step is the distance in bytes from one chroma pixel value to the
78 * next.  This is 2 bytes for semiplanar (because chroma values are interleaved
79 * and each chroma value is one byte) and 1 for planar.
80 */
81
82struct android_ycbcr {
83    void *y;
84    void *cb;
85    void *cr;
86    size_t ystride;
87    size_t cstride;
88    size_t chroma_step;
89
90    /** reserved for future use, set to 0 by gralloc's (*lock_ycbcr)() */
91    uint32_t reserved[8];
92};
93
94/*
95 * Structures for describing flexible YUVA/RGBA formats for consumption by
96 * applications. Such flexible formats contain a plane for each component (e.g.
97 * red, green, blue), where each plane is laid out in a grid-like pattern
98 * occupying unique byte addresses and with consistent byte offsets between
99 * neighboring pixels.
100 *
101 * The android_flex_layout structure is used with any pixel format that can be
102 * represented by it, such as:
103 *  - HAL_PIXEL_FORMAT_YCbCr_*_888
104 *  - HAL_PIXEL_FORMAT_FLEX_RGB*_888
105 *  - HAL_PIXEL_FORMAT_RGB[AX]_888[8],BGRA_8888,RGB_888
106 *  - HAL_PIXEL_FORMAT_YV12,Y8,Y16,YCbCr_422_SP/I,YCrCb_420_SP
107 *  - even implementation defined formats that can be represented by
108 *    the structures
109 *
110 * Vertical increment (aka. row increment or stride) describes the distance in
111 * bytes from the first pixel of one row to the first pixel of the next row
112 * (below) for the component plane. This can be negative.
113 *
114 * Horizontal increment (aka. column or pixel increment) describes the distance
115 * in bytes from one pixel to the next pixel (to the right) on the same row for
116 * the component plane. This can be negative.
117 *
118 * Each plane can be subsampled either vertically or horizontally by
119 * a power-of-two factor.
120 *
121 * The bit-depth of each component can be arbitrary, as long as the pixels are
122 * laid out on whole bytes, in native byte-order, using the most significant
123 * bits of each unit.
124 */
125
126typedef enum android_flex_component {
127    /* luma */
128    FLEX_COMPONENT_Y = 1 << 0,
129    /* chroma blue */
130    FLEX_COMPONENT_Cb = 1 << 1,
131    /* chroma red */
132    FLEX_COMPONENT_Cr = 1 << 2,
133
134    /* red */
135    FLEX_COMPONENT_R = 1 << 10,
136    /* green */
137    FLEX_COMPONENT_G = 1 << 11,
138    /* blue */
139    FLEX_COMPONENT_B = 1 << 12,
140
141    /* alpha */
142    FLEX_COMPONENT_A = 1 << 30,
143} android_flex_component_t;
144
145typedef struct android_flex_plane {
146    /* pointer to the first byte of the top-left pixel of the plane. */
147    uint8_t *top_left;
148
149    android_flex_component_t component;
150
151    /* bits allocated for the component in each pixel. Must be a positive
152       multiple of 8. */
153    int32_t bits_per_component;
154    /* number of the most significant bits used in the format for this
155       component. Must be between 1 and bits_per_component, inclusive. */
156    int32_t bits_used;
157
158    /* horizontal increment */
159    int32_t h_increment;
160    /* vertical increment */
161    int32_t v_increment;
162    /* horizontal subsampling. Must be a positive power of 2. */
163    int32_t h_subsampling;
164    /* vertical subsampling. Must be a positive power of 2. */
165    int32_t v_subsampling;
166} android_flex_plane_t;
167
168typedef enum android_flex_format {
169    /* not a flexible format */
170    FLEX_FORMAT_INVALID = 0x0,
171    FLEX_FORMAT_Y = FLEX_COMPONENT_Y,
172    FLEX_FORMAT_YCbCr = FLEX_COMPONENT_Y | FLEX_COMPONENT_Cb | FLEX_COMPONENT_Cr,
173    FLEX_FORMAT_YCbCrA = FLEX_FORMAT_YCbCr | FLEX_COMPONENT_A,
174    FLEX_FORMAT_RGB = FLEX_COMPONENT_R | FLEX_COMPONENT_G | FLEX_COMPONENT_B,
175    FLEX_FORMAT_RGBA = FLEX_FORMAT_RGB | FLEX_COMPONENT_A,
176} android_flex_format_t;
177
178typedef struct android_flex_layout {
179    /* the kind of flexible format */
180    android_flex_format_t format;
181
182    /* number of planes; 0 for FLEX_FORMAT_INVALID */
183    uint32_t num_planes;
184    /* a plane for each component; ordered in increasing component value order.
185       E.g. FLEX_FORMAT_RGBA maps 0 -> R, 1 -> G, etc.
186       Can be NULL for FLEX_FORMAT_INVALID */
187    android_flex_plane_t *planes;
188} android_flex_layout_t;
189
190/**
191 * Structure used to define depth point clouds for format HAL_PIXEL_FORMAT_BLOB
192 * with dataSpace value of HAL_DATASPACE_DEPTH.
193 * When locking a native buffer of the above format and dataSpace value,
194 * the vaddr pointer can be cast to this structure.
195 *
196 * A variable-length list of (x,y,z, confidence) 3D points, as floats.  (x, y,
197 * z) represents a measured point's position, with the coordinate system defined
198 * by the data source.  Confidence represents the estimated likelihood that this
199 * measurement is correct. It is between 0.f and 1.f, inclusive, with 1.f ==
200 * 100% confidence.
201 *
202 * num_points is the number of points in the list
203 *
204 * xyz_points is the flexible array of floating-point values.
205 *   It contains (num_points) * 4 floats.
206 *
207 *   For example:
208 *     android_depth_points d = get_depth_buffer();
209 *     struct {
210 *       float x; float y; float z; float confidence;
211 *     } firstPoint, lastPoint;
212 *
213 *     firstPoint.x = d.xyzc_points[0];
214 *     firstPoint.y = d.xyzc_points[1];
215 *     firstPoint.z = d.xyzc_points[2];
216 *     firstPoint.confidence = d.xyzc_points[3];
217 *     lastPoint.x = d.xyzc_points[(d.num_points - 1) * 4 + 0];
218 *     lastPoint.y = d.xyzc_points[(d.num_points - 1) * 4 + 1];
219 *     lastPoint.z = d.xyzc_points[(d.num_points - 1) * 4 + 2];
220 *     lastPoint.confidence = d.xyzc_points[(d.num_points - 1) * 4 + 3];
221 */
222
223struct android_depth_points {
224    uint32_t num_points;
225
226    /** reserved for future use, set to 0 by gralloc's (*lock)() */
227    uint32_t reserved[8];
228
229#if defined(__clang__)
230#pragma clang diagnostic push
231#pragma clang diagnostic ignored "-Wc99-extensions"
232#endif
233    float xyzc_points[];
234#if defined(__clang__)
235#pragma clang diagnostic pop
236#endif
237};
238
239/**
240  * These structures are used to define the reference display's
241  * capabilities for HDR content. Display engine can use this
242  * to better tone map content to user's display.
243  * Color is defined in CIE XYZ coordinates
244  */
245struct android_xy_color {
246    float x;
247    float y;
248};
249
250struct android_smpte2086_metadata {
251    struct android_xy_color displayPrimaryRed;
252    struct android_xy_color displayPrimaryGreen;
253    struct android_xy_color displayPrimaryBlue;
254    struct android_xy_color whitePoint;
255    float maxLuminance;
256    float minLuminance;
257};
258
259struct android_cta861_3_metadata {
260    float maxContentLightLevel;
261    float maxFrameAverageLightLevel;
262};
263
264#ifdef __cplusplus
265}
266#endif
267
268#endif /* SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H */
269