• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 #pragma once
2 /*
3  * Copyright (C) 2016 The Android Open Source Project
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 #include <stdint.h>
18 #include <limits.h>
19 #include <sys/cdefs.h>
20 #include <sys/mman.h>
21 #include <hardware/gralloc.h>
22 #include <errno.h>
23 #include <unistd.h>
24 #include <string.h>
25 
26 #include <cutils/native_handle.h>
27 #include <cutils/log.h>
28 
29 #include <linux/fb.h>
30 
31 #include "common/vsoc/lib/screen_region_view.h"
32 #include "guest/libs/platform_support/api_level_fixes.h"
33 
34 #ifndef GRALLOC_MODULE_API_VERSION_0_2
35 // This structure will be defined in later releases of Android. Declare it
36 // here to allow us to structure the code well.
37 struct android_ycbcr {
38   void* y;
39   void* cb;
40   void* cr;
41   size_t ystride;
42   size_t cstride;
43   size_t chroma_step;
44   uint32_t reserved[8];
45 };
46 #endif
47 
48 /*****************************************************************************/
49 
50 struct private_handle_t;
51 
52 struct private_module_t {
53   gralloc_module_t base;
54 };
55 
56 /*****************************************************************************/
57 
58 struct priv_alloc_device_t {
59   alloc_device_t  device;
60 };
61 
62 /*****************************************************************************/
63 
64 struct private_handle_t : public native_handle {
65   // file-descriptors
66   int     fd;
67   // ints
68   int     magic;
69   int     flags;
70   int     format;
71   int     x_res;
72   int     y_res;
73   int     stride_in_pixels;
74   // Use to indicate which frame we're using.
75   int     frame_offset;
76   int     total_size;
77   int     lock_level;
78 
79   static inline int sNumInts() {
80     return (((sizeof(private_handle_t) - sizeof(native_handle_t))/sizeof(int)) - sNumFds);
81   }
82   static const int sNumFds = 1;
83   static const int sMagic = 0x3141592;
84 
85   private_handle_t(int fd, int size, int format, int x_res, int y_res,
86                    int stride_in_pixels, int flags, int frame_offset = 0)
87       : fd(fd),
88         magic(sMagic),
89         flags(flags),
90         format(format),
91         x_res(x_res),
92         y_res(y_res),
93         stride_in_pixels(stride_in_pixels),
94         frame_offset(frame_offset),
95         total_size(size),
96         lock_level(0) {
97     version = sizeof(native_handle);
98     numInts = sNumInts();
99     numFds = sNumFds;
100   }
101 
102   ~private_handle_t() {
103     magic = 0;
104   }
105 
106   static int validate(const native_handle* h) {
107     const private_handle_t* hnd = (const private_handle_t*)h;
108     if (!h) {
109       ALOGE("invalid gralloc handle (at %p): NULL pointer", h);
110       return -EINVAL;
111     }
112     if (h->version != sizeof(native_handle)) {
113       ALOGE(
114           "invalid gralloc handle (at %p): Wrong version(observed: %d, "
115           "expected: %zu)",
116           h,
117           h->version,
118           sizeof(native_handle));
119       return -EINVAL;
120     }
121     if (h->numInts != sNumInts()) {
122       ALOGE(
123           "invalid gralloc handle (at %p): Wrong number of ints(observed: %d, "
124           "expected: %d)",
125           h,
126           h->numInts,
127           sNumInts());
128       return -EINVAL;
129     }
130     if (h->numFds != sNumFds) {
131       ALOGE(
132           "invalid gralloc handle (at %p): Wrong number of file "
133           "descriptors(observed: %d, expected: %d)",
134           h,
135           h->numFds,
136           sNumFds);
137       return -EINVAL;
138     }
139     if (hnd->magic != sMagic) {
140       ALOGE(
141           "invalid gralloc handle (at %p): Wrong magic number(observed: %d, "
142           "expected: %d)",
143           h,
144           hnd->magic,
145           sMagic);
146       return -EINVAL;
147     }
148     return 0;
149   }
150 };
151 
152 
153 static inline int formatToBytesPerPixel(int format) {
154   switch (format) {
155 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
156     case HAL_PIXEL_FORMAT_RGBA_FP16:
157       return 8;
158 #endif
159     case HAL_PIXEL_FORMAT_RGBA_8888:
160     case HAL_PIXEL_FORMAT_RGBX_8888:
161     case HAL_PIXEL_FORMAT_BGRA_8888:
162 #if VSOC_PLATFORM_SDK_AFTER(J)
163     // The camera 3.0 implementation assumes that IMPLEMENTATION_DEFINED
164     // means HAL_PIXEL_FORMAT_RGBA_8888
165     case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
166 #endif
167       return 4;
168     case HAL_PIXEL_FORMAT_RGB_888:
169       return 3;
170     case HAL_PIXEL_FORMAT_RGB_565:
171     case HAL_PIXEL_FORMAT_YV12:
172 #ifdef GRALLOC_MODULE_API_VERSION_0_2
173     case HAL_PIXEL_FORMAT_YCbCr_420_888:
174 #endif
175       return 2;
176 #if VSOC_PLATFORM_SDK_AFTER(J)
177     case HAL_PIXEL_FORMAT_BLOB:
178       return 1;
179 #endif
180     default:
181       ALOGE("%s: unknown format=%d", __FUNCTION__, format);
182       return 8;
183   }
184 }
185 
186 inline const char* pixel_format_to_string(int format) {
187   switch (format) {
188     // Formats that are universal across versions
189     case HAL_PIXEL_FORMAT_RGBA_8888:
190       return "RGBA_8888";
191     case HAL_PIXEL_FORMAT_RGBX_8888:
192       return "RGBX_8888";
193     case HAL_PIXEL_FORMAT_BGRA_8888:
194       return "BGRA_8888";
195     case HAL_PIXEL_FORMAT_RGB_888:
196       return "RGB_888";
197     case HAL_PIXEL_FORMAT_RGB_565:
198       return "RGB_565";
199     case HAL_PIXEL_FORMAT_YV12:
200       return "YV12";
201     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
202       return "YCrCb_420_SP";
203     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
204       return "YCbCr_422_SP";
205     case HAL_PIXEL_FORMAT_YCbCr_422_I:
206       return "YCbCr_422_I";
207 
208 #if VSOC_PLATFORM_SDK_AFTER(J)
209     // First supported on JBMR1 (API 17)
210     case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
211       return "IMPLEMENTATION_DEFINED";
212     case HAL_PIXEL_FORMAT_BLOB:
213       return "BLOB";
214 #endif
215 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
216     // First supported on JBMR2 (API 18)
217     case HAL_PIXEL_FORMAT_YCbCr_420_888:
218       return "YCbCr_420_888";
219     case HAL_PIXEL_FORMAT_Y8:
220       return "Y8";
221     case HAL_PIXEL_FORMAT_Y16:
222       return "Y16";
223 #endif
224 #if VSOC_PLATFORM_SDK_AFTER(K)
225     // Support was added in L (API 21)
226     case HAL_PIXEL_FORMAT_RAW_OPAQUE:
227       return "RAW_OPAQUE";
228     // This is an alias for RAW_SENSOR in L and replaces it in M.
229     case HAL_PIXEL_FORMAT_RAW16:
230       return "RAW16";
231     case HAL_PIXEL_FORMAT_RAW10:
232       return "RAW10";
233 #endif
234 #if VSOC_PLATFORM_SDK_AFTER(L_MR1)
235     case HAL_PIXEL_FORMAT_YCbCr_444_888:
236       return "YCbCr_444_888";
237     case HAL_PIXEL_FORMAT_YCbCr_422_888:
238       return "YCbCr_422_888";
239     case HAL_PIXEL_FORMAT_RAW12:
240       return "RAW12";
241     case HAL_PIXEL_FORMAT_FLEX_RGBA_8888:
242       return "FLEX_RGBA_8888";
243     case HAL_PIXEL_FORMAT_FLEX_RGB_888:
244       return "FLEX_RGB_888";
245 #endif
246 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
247     case HAL_PIXEL_FORMAT_RGBA_FP16:
248       return "RGBA_FP16";
249 #endif
250 
251       // Formats that have been removed
252 #if VSOC_PLATFORM_SDK_BEFORE(K)
253     // Support was dropped on K (API 19)
254     case HAL_PIXEL_FORMAT_RGBA_5551:
255       return "RGBA_5551";
256     case HAL_PIXEL_FORMAT_RGBA_4444:
257       return "RGBA_4444";
258 #endif
259 #if VSOC_PLATFORM_SDK_BEFORE(L)
260     // Renamed to RAW_16 in L. Both were present for L, but it was completely
261     // removed in M.
262     case HAL_PIXEL_FORMAT_RAW_SENSOR:
263       return "RAW_SENSOR";
264 #endif
265 #if VSOC_PLATFORM_SDK_AFTER(J_MR2) && VSOC_PLATFORM_SDK_BEFORE(M)
266     // Supported K, L, and LMR1. Not supported on JBMR0, JBMR1, JBMR2, and M
267     case HAL_PIXEL_FORMAT_sRGB_X_8888:
268       return "sRGB_X_8888";
269     case HAL_PIXEL_FORMAT_sRGB_A_8888:
270       return "sRGB_A_8888";
271 #endif
272   }
273   return "UNKNOWN";
274 }
275 
276 
277 static inline void formatToYcbcr(
278     int format, int width, int height, void* base_v, android_ycbcr* out) {
279   char* it = static_cast<char*>(base_v);
280   // Clear reserved fields;
281   memset(out, 0, sizeof(*out));
282   switch (format) {
283     case HAL_PIXEL_FORMAT_YV12:
284 #ifdef GRALLOC_MODULE_API_VERSION_0_2
285     case HAL_PIXEL_FORMAT_YCbCr_420_888:
286 #endif
287       out->ystride = vsoc::screen::ScreenRegionView::align(width, 16);
288       out->cstride =
289           vsoc::screen::ScreenRegionView::align(out->ystride / 2, 16);
290       out->chroma_step = 1;
291       out->y = it;
292       it += out->ystride * height;
293       out->cr = it;
294       it += out->cstride * height / 2;
295       out->cb = it;
296       break;
297     default:
298       ALOGE("%s: can't deal with format=0x%x (%s)",
299             __FUNCTION__, format, pixel_format_to_string(format));
300   }
301 }
302 
303 static inline int formatToBytesPerFrame(int format, int w, int h) {
304   int bytes_per_pixel = formatToBytesPerPixel(format);
305   int w16, h16;
306   int y_size, c_size;
307 
308   switch (format) {
309 #if VSOC_PLATFORM_SDK_AFTER(J)
310     // BLOB is used to allocate buffers for JPEG formatted data. Bytes per pixel
311     // is 1, the desired buffer size is in w, and h should be 1. We refrain from
312     // adding additional padding, although the caller is likely to round
313     // up to a page size.
314     case HAL_PIXEL_FORMAT_BLOB:
315       return bytes_per_pixel * w * h;
316 #endif
317     case HAL_PIXEL_FORMAT_YV12:
318 #ifdef GRALLOC_MODULE_API_VERSION_0_2
319     case HAL_PIXEL_FORMAT_YCbCr_420_888:
320 #endif
321       android_ycbcr strides;
322       formatToYcbcr(format, w, h, NULL, &strides);
323       y_size = strides.ystride * h;
324       c_size = strides.cstride * h / 2;
325       return (y_size + 2 * c_size +
326               vsoc::screen::ScreenRegionView::kSwiftShaderPadding);
327     /*case HAL_PIXEL_FORMAT_RGBA_8888:
328     case HAL_PIXEL_FORMAT_RGBX_8888:
329     case HAL_PIXEL_FORMAT_BGRA_8888:
330     case HAL_PIXEL_FORMAT_RGB_888:
331     case HAL_PIXEL_FORMAT_RGB_565:*/
332     default:
333       w16 = vsoc::screen::ScreenRegionView::align(w, 16);
334       h16 = vsoc::screen::ScreenRegionView::align(h, 16);
335       return bytes_per_pixel * w16 * h16 +
336              vsoc::screen::ScreenRegionView::kSwiftShaderPadding;
337   }
338 }
339 
340 int fb_device_open(
341     const hw_module_t* module, const char* name, hw_device_t** device);
342 
343 int gralloc_lock(
344     gralloc_module_t const* module,
345     buffer_handle_t handle, int usage,
346     int l, int t, int w, int h,
347     void** vaddr);
348 
349 int gralloc_unlock(
350     gralloc_module_t const* module, buffer_handle_t handle);
351 
352 int gralloc_register_buffer(
353     gralloc_module_t const* module, buffer_handle_t handle);
354 
355 int gralloc_unregister_buffer(
356     gralloc_module_t const* module, buffer_handle_t handle);
357 
358 int gralloc_lock_ycbcr(
359     struct gralloc_module_t const* module,
360     buffer_handle_t handle, int usage,
361     int l, int t, int w, int h,
362     struct android_ycbcr *ycbcr);
363