Commit | Line | Data |
---|---|---|
1e494cf4 JB |
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 | #ifdef __cplusplus | |
21 | extern "C" { | |
22 | #endif | |
23 | ||
24 | /* | |
25 | * If the HAL needs to create service threads to handle graphics related | |
26 | * tasks, these threads need to run at HAL_PRIORITY_URGENT_DISPLAY priority | |
27 | * if they can block the main rendering thread in any way. | |
28 | * | |
29 | * the priority of the current thread can be set with: | |
30 | * | |
31 | * #include <sys/resource.h> | |
32 | * setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY); | |
33 | * | |
34 | */ | |
35 | ||
36 | #define HAL_PRIORITY_URGENT_DISPLAY (-8) | |
37 | ||
38 | /** | |
39 | * pixel format definitions | |
40 | */ | |
41 | ||
42 | enum { | |
43 | HAL_PIXEL_FORMAT_RGBA_8888 = 1, | |
44 | HAL_PIXEL_FORMAT_RGBX_8888 = 2, | |
45 | HAL_PIXEL_FORMAT_RGB_888 = 3, | |
46 | HAL_PIXEL_FORMAT_RGB_565 = 4, | |
47 | HAL_PIXEL_FORMAT_BGRA_8888 = 5, | |
48 | HAL_PIXEL_FORMAT_RGBA_5551 = 6, | |
49 | HAL_PIXEL_FORMAT_RGBA_4444 = 7, | |
50 | ||
51 | /* 0x8 - 0xFF range unavailable */ | |
52 | ||
53 | /* | |
54 | * 0x100 - 0x1FF | |
55 | * | |
56 | * This range is reserved for pixel formats that are specific to the HAL | |
57 | * implementation. Implementations can use any value in this range to | |
58 | * communicate video pixel formats between their HAL modules. These formats | |
59 | * must not have an alpha channel. Additionally, an EGLimage created from a | |
60 | * gralloc buffer of one of these formats must be supported for use with the | |
61 | * GL_OES_EGL_image_external OpenGL ES extension. | |
62 | */ | |
63 | ||
64 | /* | |
65 | * Android YUV format: | |
66 | * | |
67 | * This format is exposed outside of the HAL to software decoders and | |
68 | * applications. EGLImageKHR must support it in conjunction with the | |
69 | * OES_EGL_image_external extension. | |
70 | * | |
71 | * YV12 is a 4:2:0 YCrCb planar format comprised of a WxH Y plane followed | |
72 | * by (W/2) x (H/2) Cr and Cb planes. | |
73 | * | |
74 | * This format assumes | |
75 | * - an even width | |
76 | * - an even height | |
77 | * - a horizontal stride multiple of 16 pixels | |
78 | * - a vertical stride equal to the height | |
79 | * | |
80 | * y_size = stride * height | |
81 | * c_stride = ALIGN(stride/2, 16) | |
82 | * c_size = c_stride * height/2 | |
83 | * size = y_size + c_size * 2 | |
84 | * cr_offset = y_size | |
85 | * cb_offset = y_size + c_size | |
86 | * | |
87 | */ | |
88 | HAL_PIXEL_FORMAT_YV12 = 0x32315659, // YCrCb 4:2:0 Planar | |
89 | ||
90 | /* | |
91 | * Android RAW sensor format: | |
92 | * | |
93 | * This format is exposed outside of the HAL to applications. | |
94 | * | |
95 | * RAW_SENSOR is a single-channel 16-bit format, typically representing raw | |
96 | * Bayer-pattern images from an image sensor, with minimal processing. | |
97 | * | |
98 | * The exact pixel layout of the data in the buffer is sensor-dependent, and | |
99 | * needs to be queried from the camera device. | |
100 | * | |
101 | * Generally, not all 16 bits are used; more common values are 10 or 12 | |
102 | * bits. All parameters to interpret the raw data (black and white points, | |
103 | * color space, etc) must be queried from the camera device. | |
104 | * | |
105 | * This format assumes | |
106 | * - an even width | |
107 | * - an even height | |
108 | * - a horizontal stride multiple of 16 pixels (32 bytes). | |
109 | */ | |
110 | HAL_PIXEL_FORMAT_RAW_SENSOR = 0x20, | |
111 | ||
112 | /* | |
113 | * Android binary blob graphics buffer format: | |
114 | * | |
115 | * This format is used to carry task-specific data which does not have a | |
116 | * standard image structure. The details of the format are left to the two | |
117 | * endpoints. | |
118 | * | |
119 | * A typical use case is for transporting JPEG-compressed images from the | |
120 | * Camera HAL to the framework or to applications. | |
121 | * | |
122 | * Buffers of this format must have a height of 1, and width equal to their | |
123 | * size in bytes. | |
124 | */ | |
125 | HAL_PIXEL_FORMAT_BLOB = 0x21, | |
126 | ||
127 | /* | |
128 | * Android format indicating that the choice of format is entirely up to the | |
129 | * device-specific Gralloc implementation. | |
130 | * | |
131 | * The Gralloc implementation should examine the usage bits passed in when | |
132 | * allocating a buffer with this format, and it should derive the pixel | |
133 | * format from those usage flags. This format will never be used with any | |
134 | * of the GRALLOC_USAGE_SW_* usage flags. | |
135 | * | |
136 | * If a buffer of this format is to be used as an OpenGL ES texture, the | |
137 | * framework will assume that sampling the texture will always return an | |
138 | * alpha value of 1.0 (i.e. the buffer contains only opaque pixel values). | |
139 | * | |
140 | */ | |
141 | HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED = 0x22, | |
142 | ||
143 | /* Legacy formats (deprecated), used by ImageFormat.java */ | |
144 | HAL_PIXEL_FORMAT_YCbCr_422_SP = 0x10, // NV16 | |
145 | HAL_PIXEL_FORMAT_YCrCb_420_SP = 0x11, // NV21 | |
146 | HAL_PIXEL_FORMAT_YCbCr_422_I = 0x14, // YUY2 | |
147 | }; | |
148 | ||
149 | ||
150 | /** | |
151 | * Transformation definitions | |
152 | * | |
153 | * IMPORTANT NOTE: | |
154 | * HAL_TRANSFORM_ROT_90 is applied CLOCKWISE and AFTER HAL_TRANSFORM_FLIP_{H|V}. | |
155 | * | |
156 | */ | |
157 | ||
158 | enum { | |
159 | /* flip source image horizontally (around the vertical axis) */ | |
160 | HAL_TRANSFORM_FLIP_H = 0x01, | |
161 | /* flip source image vertically (around the horizontal axis)*/ | |
162 | HAL_TRANSFORM_FLIP_V = 0x02, | |
163 | /* rotate source image 90 degrees clockwise */ | |
164 | HAL_TRANSFORM_ROT_90 = 0x04, | |
165 | /* rotate source image 180 degrees */ | |
166 | HAL_TRANSFORM_ROT_180 = 0x03, | |
167 | /* rotate source image 270 degrees clockwise */ | |
168 | HAL_TRANSFORM_ROT_270 = 0x07, | |
169 | }; | |
170 | ||
171 | #ifdef __cplusplus | |
172 | } | |
173 | #endif | |
174 | ||
175 | #endif /* SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H */ |