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 #include <string.h>
17 #include <pthread.h>
18 #include <limits.h>
19 #include <cutils/ashmem.h>
20 #include <unistd.h>
21 #include <errno.h>
22 #include <dlfcn.h>
23 #include <sys/mman.h>
24 #include "gralloc_cb.h"
25 #include "goldfish_dma.h"
26 #include "FormatConversions.h"
27 #include "HostConnection.h"
28 #include "ProcessPipe.h"
29 #include "glUtils.h"
30 #include <cutils/log.h>
31 #include <cutils/properties.h>
32
33 #include <set>
34 #include <string>
35 #include <sstream>
36
37 /* Set to 1 or 2 to enable debug traces */
38 #define DEBUG 0
39
40 #if DEBUG >= 1
41 # define D(...) ALOGD(__VA_ARGS__)
42 #else
43 # define D(...) ((void)0)
44 #endif
45
46 #if DEBUG >= 2
47 # define DD(...) ALOGD(__VA_ARGS__)
48 #else
49 # define DD(...) ((void)0)
50 #endif
51
52 #define DBG_FUNC DBG("%s\n", __FUNCTION__)
53
54 #ifdef GOLDFISH_HIDL_GRALLOC
55 static bool isHidlGralloc = true;
56 #else
57 static bool isHidlGralloc = false;
58 #endif
59
getOpenCountPtr(cb_handle_t * cb)60 int32_t* getOpenCountPtr(cb_handle_t* cb) {
61 return ((int32_t*)cb->ashmemBase) + 1;
62 }
63
getAshmemColorOffset(cb_handle_t * cb)64 uint32_t getAshmemColorOffset(cb_handle_t* cb) {
65 uint32_t res = 0;
66 if (cb->canBePosted()) res = sizeof(intptr_t);
67 if (isHidlGralloc) res = sizeof(intptr_t) * 2;
68 return res;
69 }
70
71 //
72 // our private gralloc module structure
73 //
74 struct private_module_t {
75 gralloc_module_t base;
76 };
77
78 /* If not NULL, this is a pointer to the fallback module.
79 * This really is gralloc.default, which we'll use if we detect
80 * that the emulator we're running in does not support GPU emulation.
81 */
82 static gralloc_module_t* sFallback;
83 static pthread_once_t sFallbackOnce = PTHREAD_ONCE_INIT;
84
85 static void fallback_init(void); // forward
86
87 typedef struct _alloc_list_node {
88 buffer_handle_t handle;
89 _alloc_list_node *next;
90 _alloc_list_node *prev;
91 } AllocListNode;
92
93 struct MemRegionInfo {
94 void* ashmemBase;
95 mutable uint32_t refCount;
96 };
97
98 struct MemRegionInfoCmp {
operator ()MemRegionInfoCmp99 bool operator()(const MemRegionInfo& a, const MemRegionInfo& b) const {
100 return a.ashmemBase < b.ashmemBase;
101 }
102 };
103
104 typedef std::set<MemRegionInfo, MemRegionInfoCmp> MemRegionSet;
105 typedef MemRegionSet::iterator mem_region_handle_t;
106
107 //
108 // Our gralloc device structure (alloc interface)
109 //
110 struct gralloc_device_t {
111 alloc_device_t device;
112
113 AllocListNode *allocListHead; // double linked list of allocated buffers
114 MemRegionSet ashmemRegions; // to track allocations of each ashmem region
115 pthread_mutex_t lock;
116 };
117
118 struct gralloc_memregions_t {
119 MemRegionSet ashmemRegions;
120 };
121
122 #define INITIAL_DMA_REGION_SIZE 4096
123 struct gralloc_dmaregion_t {
124 goldfish_dma_context goldfish_dma;
125 uint32_t sz;
126 uint32_t refcount;
127 pthread_mutex_t lock;
128 };
129
130 // global device instance
131 static gralloc_memregions_t* s_grdev = NULL;
132 static gralloc_dmaregion_t* s_grdma = NULL;
133
init_gralloc_memregions()134 void init_gralloc_memregions() {
135 if (s_grdev) return;
136 s_grdev = new gralloc_memregions_t;
137 }
138
init_gralloc_dmaregion()139 void init_gralloc_dmaregion() {
140 D("%s: call\n", __FUNCTION__);
141 if (s_grdma) return;
142
143 s_grdma = new gralloc_dmaregion_t;
144 s_grdma->sz = INITIAL_DMA_REGION_SIZE;
145 s_grdma->refcount = 0;
146
147 pthread_mutex_init(&s_grdma->lock, NULL);
148 pthread_mutex_lock(&s_grdma->lock);
149 goldfish_dma_create_region(s_grdma->sz, &s_grdma->goldfish_dma);
150 pthread_mutex_unlock(&s_grdma->lock);
151 }
152
get_gralloc_dmaregion()153 void get_gralloc_dmaregion() {
154 if (!s_grdma) return;
155 pthread_mutex_lock(&s_grdma->lock);
156 s_grdma->refcount++;
157 D("%s: call. refcount: %u\n", __FUNCTION__, s_grdma->refcount);
158 pthread_mutex_unlock(&s_grdma->lock);
159 }
160
resize_gralloc_dmaregion_locked(uint32_t new_sz)161 static void resize_gralloc_dmaregion_locked(uint32_t new_sz) {
162 if (!s_grdma) return;
163 if (s_grdma->goldfish_dma.mapped) {
164 goldfish_dma_unmap(&s_grdma->goldfish_dma);
165 }
166 close(s_grdma->goldfish_dma.fd);
167 goldfish_dma_create_region(new_sz, &s_grdma->goldfish_dma);
168 s_grdma->sz = new_sz;
169 }
170
put_gralloc_dmaregion()171 bool put_gralloc_dmaregion() {
172 if (!s_grdma) return false;
173 pthread_mutex_lock(&s_grdma->lock);
174 D("%s: call. refcount before: %u\n", __FUNCTION__, s_grdma->refcount);
175 s_grdma->refcount--;
176 bool shouldDelete = !s_grdma->refcount;
177 if (shouldDelete) {
178 D("%s: should delete!\n", __FUNCTION__);
179 resize_gralloc_dmaregion_locked(INITIAL_DMA_REGION_SIZE);
180 D("%s: done\n", __FUNCTION__);
181 }
182 pthread_mutex_unlock(&s_grdma->lock);
183 D("%s: exit\n", __FUNCTION__);
184 return shouldDelete;
185 }
186
gralloc_dmaregion_register_ashmem(uint32_t sz)187 void gralloc_dmaregion_register_ashmem(uint32_t sz) {
188 if (!s_grdma) return;
189 pthread_mutex_lock(&s_grdma->lock);
190 D("%s: for sz %u, refcount %u", __FUNCTION__, sz, s_grdma->refcount);
191 uint32_t new_sz = std::max(s_grdma->sz, sz);
192 if (new_sz != s_grdma->sz) {
193 D("%s: change sz from %u to %u", __FUNCTION__, s_grdma->sz, sz);
194 resize_gralloc_dmaregion_locked(new_sz);
195 }
196 if (!s_grdma->goldfish_dma.mapped) {
197 goldfish_dma_map(&s_grdma->goldfish_dma);
198 }
199 pthread_mutex_unlock(&s_grdma->lock);
200 }
201
get_mem_region(void * ashmemBase)202 void get_mem_region(void* ashmemBase) {
203 init_gralloc_memregions();
204 D("%s: call for %p", __FUNCTION__, ashmemBase);
205 MemRegionInfo lookup;
206 lookup.ashmemBase = ashmemBase;
207 mem_region_handle_t handle = s_grdev->ashmemRegions.find(lookup);
208 if (handle == s_grdev->ashmemRegions.end()) {
209 MemRegionInfo newRegion;
210 newRegion.ashmemBase = ashmemBase;
211 newRegion.refCount = 1;
212 s_grdev->ashmemRegions.insert(newRegion);
213 } else {
214 handle->refCount++;
215 }
216 }
217
put_mem_region(void * ashmemBase)218 bool put_mem_region(void* ashmemBase) {
219 init_gralloc_memregions();
220 D("%s: call for %p", __FUNCTION__, ashmemBase);
221 MemRegionInfo lookup;
222 lookup.ashmemBase = ashmemBase;
223 mem_region_handle_t handle = s_grdev->ashmemRegions.find(lookup);
224 if (handle == s_grdev->ashmemRegions.end()) {
225 ALOGE("%s: error: tried to put nonexistent mem region!", __FUNCTION__);
226 return true;
227 } else {
228 handle->refCount--;
229 bool shouldRemove = !handle->refCount;
230 if (shouldRemove) {
231 s_grdev->ashmemRegions.erase(lookup);
232 }
233 return shouldRemove;
234 }
235 }
236
dump_regions()237 void dump_regions() {
238 init_gralloc_memregions();
239 mem_region_handle_t curr = s_grdev->ashmemRegions.begin();
240 std::stringstream res;
241 for (; curr != s_grdev->ashmemRegions.end(); curr++) {
242 res << "\tashmem base " << curr->ashmemBase << " refcount " << curr->refCount << "\n";
243 }
244 ALOGD("ashmem region dump [\n%s]", res.str().c_str());
245 }
246
247 #if DEBUG
248
249 #define GET_ASHMEM_REGION(cb) \
250 dump_regions(); \
251 get_mem_region((void*)cb->ashmemBase); \
252 dump_regions(); \
253
254 #define PUT_ASHMEM_REGION(cb) \
255 dump_regions(); \
256 bool SHOULD_UNMAP = put_mem_region((void*)cb->ashmemBase); \
257 dump_regions(); \
258
259 #else
260
261 #define GET_ASHMEM_REGION(cb) \
262 get_mem_region((void*)cb->ashmemBase); \
263
264 #define PUT_ASHMEM_REGION(cb) \
265 bool SHOULD_UNMAP = put_mem_region((void*)cb->ashmemBase); \
266
267 #endif
268
269 //
270 // Our framebuffer device structure
271 //
272 struct fb_device_t {
273 framebuffer_device_t device;
274 };
275
map_buffer(cb_handle_t * cb,void ** vaddr)276 static int map_buffer(cb_handle_t *cb, void **vaddr)
277 {
278 if (cb->fd < 0 || cb->ashmemSize <= 0) {
279 return -EINVAL;
280 }
281
282 int map_flags = MAP_SHARED;
283 if (isHidlGralloc) map_flags |= MAP_ANONYMOUS;
284
285 void *addr = mmap(0, cb->ashmemSize, PROT_READ | PROT_WRITE,
286 MAP_SHARED, cb->fd, 0);
287 if (addr == MAP_FAILED) {
288 ALOGE("%s: failed to map ashmem region!", __FUNCTION__);
289 return -errno;
290 }
291
292 cb->ashmemBase = intptr_t(addr);
293 cb->ashmemBasePid = getpid();
294 D("%s: %p mapped ashmem base %p size %d\n", __FUNCTION__,
295 cb, cb->ashmemBase, cb->ashmemSize);
296
297 *vaddr = addr;
298 return 0;
299 }
300
301 #define DEFINE_HOST_CONNECTION \
302 HostConnection *hostCon = HostConnection::get(); \
303 ExtendedRCEncoderContext *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL)
304
305 #define DEFINE_AND_VALIDATE_HOST_CONNECTION \
306 HostConnection *hostCon = HostConnection::get(); \
307 if (!hostCon) { \
308 ALOGE("gralloc: Failed to get host connection\n"); \
309 return -EIO; \
310 } \
311 ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
312 if (!rcEnc) { \
313 ALOGE("gralloc: Failed to get renderControl encoder context\n"); \
314 return -EIO; \
315 }
316
317 #if PLATFORM_SDK_VERSION < 18
318 // On older APIs, just define it as a value no one is going to use.
319 #define HAL_PIXEL_FORMAT_YCbCr_420_888 0xFFFFFFFF
320 #endif
321
updateHostColorBuffer(cb_handle_t * cb,bool doLocked,char * pixels)322 static void updateHostColorBuffer(cb_handle_t* cb,
323 bool doLocked,
324 char* pixels) {
325 D("%s: call. doLocked=%d", __FUNCTION__, doLocked);
326 DEFINE_HOST_CONNECTION;
327 int bpp = glUtilsPixelBitSize(cb->glFormat, cb->glType) >> 3;
328 int left = doLocked ? cb->lockedLeft : 0;
329 int top = doLocked ? cb->lockedTop : 0;
330 int width = doLocked ? cb->lockedWidth : cb->width;
331 int height = doLocked ? cb->lockedHeight : cb->height;
332
333 char* to_send = pixels;
334 uint32_t rgbSz = width * height * bpp;
335 uint32_t send_buffer_size = rgbSz;
336 bool is_rgb_format =
337 cb->frameworkFormat != HAL_PIXEL_FORMAT_YV12 &&
338 cb->frameworkFormat != HAL_PIXEL_FORMAT_YCbCr_420_888;
339
340 char* convertedBuf = NULL;
341 if ((doLocked && is_rgb_format) ||
342 (!s_grdma &&
343 (doLocked || !is_rgb_format))) {
344 convertedBuf = new char[rgbSz];
345 to_send = convertedBuf;
346 send_buffer_size = rgbSz;
347 }
348
349 if (doLocked && is_rgb_format) {
350 copy_rgb_buffer_from_unlocked(
351 to_send, pixels,
352 cb->width,
353 width, height, top, left, bpp);
354 }
355
356 if (s_grdma) {
357 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
358 get_yv12_offsets(width, height, NULL, NULL,
359 &send_buffer_size);
360 }
361 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
362 get_yuv420p_offsets(width, height, NULL, NULL,
363 &send_buffer_size);
364 }
365
366 rcEnc->bindDmaContext(&s_grdma->goldfish_dma);
367 D("%s: call. dma update with sz=%u", __FUNCTION__, send_buffer_size);
368 pthread_mutex_lock(&s_grdma->lock);
369 rcEnc->rcUpdateColorBufferDMA(rcEnc, cb->hostHandle,
370 left, top, width, height,
371 cb->glFormat, cb->glType,
372 to_send, send_buffer_size);
373 pthread_mutex_unlock(&s_grdma->lock);
374 } else {
375 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
376 yv12_to_rgb888(to_send, pixels,
377 width, height, left, top,
378 left + width - 1, top + height - 1);
379 }
380 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
381 yuv420p_to_rgb888(to_send, pixels,
382 width, height, left, top,
383 left + width - 1, top + height - 1);
384 }
385 rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle,
386 left, top, width, height,
387 cb->glFormat, cb->glType, to_send);
388 }
389
390 if (convertedBuf) delete [] convertedBuf;
391 }
392
393 //
394 // gralloc device functions (alloc interface)
395 //
gralloc_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)396 static int gralloc_alloc(alloc_device_t* dev,
397 int w, int h, int format, int usage,
398 buffer_handle_t* pHandle, int* pStride)
399 {
400 D("gralloc_alloc w=%d h=%d usage=0x%x format=0x%x\n", w, h, usage, format);
401
402 gralloc_device_t *grdev = (gralloc_device_t *)dev;
403 if (!grdev || !pHandle || !pStride) {
404 ALOGE("gralloc_alloc: Bad inputs (grdev: %p, pHandle: %p, pStride: %p",
405 grdev, pHandle, pStride);
406 return -EINVAL;
407 }
408
409 //
410 // Note: in screen capture mode, both sw_write and hw_write will be on
411 // and this is a valid usage
412 //
413 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
414 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
415 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK));
416 #if PLATFORM_SDK_VERSION >= 17
417 bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE);
418 bool hw_cam_read = (usage & GRALLOC_USAGE_HW_CAMERA_READ);
419 #else // PLATFORM_SDK_VERSION
420 bool hw_cam_write = false;
421 bool hw_cam_read = false;
422 #endif // PLATFORM_SDK_VERSION
423 #if PLATFORM_SDK_VERSION >= 15
424 bool hw_vid_enc_read = usage & GRALLOC_USAGE_HW_VIDEO_ENCODER;
425 #else // PLATFORM_SDK_VERSION
426 bool hw_vid_enc_read = false;
427 #endif // PLATFORM_SDK_VERSION
428
429 // Keep around original requested format for later validation
430 int frameworkFormat = format;
431 // Pick the right concrete pixel format given the endpoints as encoded in
432 // the usage bits. Every end-point pair needs explicit listing here.
433 #if PLATFORM_SDK_VERSION >= 17
434 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
435 // Camera as producer
436 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) {
437 if (usage & GRALLOC_USAGE_HW_TEXTURE) {
438 // Camera-to-display is RGBA
439 format = HAL_PIXEL_FORMAT_RGBA_8888;
440 } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
441 // Camera-to-encoder is NV21
442 format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
443 } else if ((usage & GRALLOC_USAGE_HW_CAMERA_MASK) ==
444 GRALLOC_USAGE_HW_CAMERA_ZSL) {
445 // Camera-to-ZSL-queue is RGB_888
446 format = HAL_PIXEL_FORMAT_RGB_888;
447 }
448 }
449
450 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
451 ALOGE("gralloc_alloc: Requested auto format selection, "
452 "but no known format for this usage: %d x %d, usage %x",
453 w, h, usage);
454 return -EINVAL;
455 }
456 }
457 else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
458 ALOGW("gralloc_alloc: Requested YCbCr_420_888, taking experimental path. "
459 "usage: %d x %d, usage %x",
460 w, h, usage);
461 }
462 #endif // PLATFORM_SDK_VERSION >= 17
463 bool yuv_format = false;
464
465 int ashmem_size = 0;
466 int stride = w;
467
468 GLenum glFormat = 0;
469 GLenum glType = 0;
470 EmulatorFrameworkFormat selectedEmuFrameworkFormat = FRAMEWORK_FORMAT_GL_COMPATIBLE;
471
472 int bpp = 0;
473 int align = 1;
474 switch (format) {
475 case HAL_PIXEL_FORMAT_RGBA_8888:
476 case HAL_PIXEL_FORMAT_RGBX_8888:
477 case HAL_PIXEL_FORMAT_BGRA_8888:
478 bpp = 4;
479 glFormat = GL_RGBA;
480 glType = GL_UNSIGNED_BYTE;
481 break;
482 case HAL_PIXEL_FORMAT_RGB_888:
483 bpp = 3;
484 glFormat = GL_RGB;
485 glType = GL_UNSIGNED_BYTE;
486 break;
487 case HAL_PIXEL_FORMAT_RGB_565:
488 bpp = 2;
489 glFormat = GL_RGB;
490 glType = GL_UNSIGNED_SHORT_5_6_5;
491 break;
492 #if PLATFORM_SDK_VERSION >= 21
493 case HAL_PIXEL_FORMAT_RAW16:
494 case HAL_PIXEL_FORMAT_Y16:
495 #elif PLATFORM_SDK_VERSION >= 16
496 case HAL_PIXEL_FORMAT_RAW_SENSOR:
497 #endif
498 bpp = 2;
499 align = 16*bpp;
500 if (! ((sw_read || hw_cam_read) && (sw_write || hw_cam_write) ) ) {
501 // Raw sensor data or Y16 only goes between camera and CPU
502 return -EINVAL;
503 }
504 // Not expecting to actually create any GL surfaces for this
505 glFormat = GL_LUMINANCE;
506 glType = GL_UNSIGNED_SHORT;
507 break;
508 #if PLATFORM_SDK_VERSION >= 17
509 case HAL_PIXEL_FORMAT_BLOB:
510 bpp = 1;
511 if (! (sw_read && hw_cam_write) ) {
512 // Blob data cannot be used by HW other than camera emulator
513 return -EINVAL;
514 }
515 // Not expecting to actually create any GL surfaces for this
516 glFormat = GL_LUMINANCE;
517 glType = GL_UNSIGNED_BYTE;
518 break;
519 #endif // PLATFORM_SDK_VERSION >= 17
520 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
521 align = 1;
522 bpp = 1; // per-channel bpp
523 yuv_format = true;
524 // Not expecting to actually create any GL surfaces for this
525 break;
526 case HAL_PIXEL_FORMAT_YV12:
527 align = 16;
528 bpp = 1; // per-channel bpp
529 yuv_format = true;
530 // We are going to use RGB888 on the host
531 glFormat = GL_RGB;
532 glType = GL_UNSIGNED_BYTE;
533 selectedEmuFrameworkFormat = FRAMEWORK_FORMAT_YV12;
534 break;
535 case HAL_PIXEL_FORMAT_YCbCr_420_888:
536 align = 1;
537 bpp = 1; // per-channel bpp
538 yuv_format = true;
539 // We are going to use RGB888 on the host
540 glFormat = GL_RGB;
541 glType = GL_UNSIGNED_BYTE;
542 selectedEmuFrameworkFormat = FRAMEWORK_FORMAT_YUV_420_888;
543 break;
544 default:
545 ALOGE("gralloc_alloc: Unknown format %d", format);
546 return -EINVAL;
547 }
548
549 //
550 // Allocate ColorBuffer handle on the host (only if h/w access is allowed)
551 // Only do this for some h/w usages, not all.
552 // Also do this if we need to read from the surface, in this case the
553 // rendering will still happen on the host but we also need to be able to
554 // read back from the color buffer, which requires that there is a buffer
555 //
556 bool needHostCb = (!yuv_format ||
557 frameworkFormat == HAL_PIXEL_FORMAT_YV12 ||
558 frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) &&
559 #if PLATFORM_SDK_VERSION >= 15
560 (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
561 GRALLOC_USAGE_HW_2D | GRALLOC_USAGE_HW_COMPOSER |
562 GRALLOC_USAGE_HW_VIDEO_ENCODER |
563 GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_MASK))
564 #else // PLATFORM_SDK_VERSION
565 (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
566 GRALLOC_USAGE_HW_2D |
567 GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_MASK))
568 #endif // PLATFORM_SDK_VERSION
569 ;
570
571 if (isHidlGralloc) {
572 if (needHostCb || (usage & GRALLOC_USAGE_HW_FB)) {
573 // keep space for postCounter
574 // AND openCounter for all host cb
575 ashmem_size += sizeof(uint32_t) * 2;
576 }
577 } else {
578 if (usage & GRALLOC_USAGE_HW_FB) {
579 // keep space for postCounter
580 ashmem_size += sizeof(uint32_t) * 1;
581 }
582 }
583
584 if (sw_read || sw_write || hw_cam_write || hw_vid_enc_read) {
585 // keep space for image on guest memory if SW access is needed
586 // or if the camera is doing writing
587 if (yuv_format) {
588 size_t yStride = (w*bpp + (align - 1)) & ~(align-1);
589 size_t uvStride = (yStride / 2 + (align - 1)) & ~(align-1);
590 size_t uvHeight = h / 2;
591 ashmem_size += yStride * h + 2 * (uvHeight * uvStride);
592 stride = yStride / bpp;
593 } else {
594 size_t bpr = (w*bpp + (align-1)) & ~(align-1);
595 ashmem_size += (bpr * h);
596 stride = bpr / bpp;
597 }
598 }
599
600 D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format,
601 ashmem_size, stride, gettid());
602
603 //
604 // Allocate space in ashmem if needed
605 //
606 int fd = -1;
607 if (ashmem_size > 0) {
608 // round to page size;
609 ashmem_size = (ashmem_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
610
611 ALOGD("%s: Creating ashmem region of size %lu\n", __FUNCTION__, ashmem_size);
612 fd = ashmem_create_region("gralloc-buffer", ashmem_size);
613 if (fd < 0) {
614 ALOGE("gralloc_alloc failed to create ashmem region: %s\n",
615 strerror(errno));
616 return -errno;
617 }
618 }
619
620 cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage,
621 w, h, frameworkFormat, format,
622 glFormat, glType, selectedEmuFrameworkFormat);
623
624 DEFINE_HOST_CONNECTION;
625 if (ashmem_size > 0) {
626
627 //
628 // map ashmem region if exist
629 //
630 void *vaddr;
631 int err = map_buffer(cb, &vaddr);
632 if (err) {
633 close(fd);
634 delete cb;
635 return err;
636 }
637
638 cb->setFd(fd);
639
640 if (rcEnc->getDmaVersion() > 0) {
641 D("%s: creating goldfish dma region of size %lu (cb fd %d)\n", __FUNCTION__, ashmem_size, cb->fd);
642 init_gralloc_dmaregion();
643 get_gralloc_dmaregion();
644 } else {
645 cb->goldfish_dma.fd = -1;
646 }
647 } else {
648 cb->goldfish_dma.fd = -1;
649 }
650
651 if (needHostCb) {
652 if (hostCon && rcEnc) {
653 if (s_grdma) {
654 cb->hostHandle = rcEnc->rcCreateColorBufferDMA(rcEnc, w, h, glFormat, cb->emuFrameworkFormat);
655 } else {
656 cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, glFormat);
657 }
658 D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
659 }
660
661 if (!cb->hostHandle) {
662 // Could not create colorbuffer on host !!!
663 close(fd);
664 delete cb;
665 ALOGD("%s: failed to create host cb! -EIO", __FUNCTION__);
666 return -EIO;
667 }
668
669 if (isHidlGralloc) { *getOpenCountPtr(cb) = 0; }
670 }
671
672 //
673 // alloc succeeded - insert the allocated handle to the allocated list
674 //
675 AllocListNode *node = new AllocListNode();
676 pthread_mutex_lock(&grdev->lock);
677 node->handle = cb;
678 node->next = grdev->allocListHead;
679 node->prev = NULL;
680 if (grdev->allocListHead) {
681 grdev->allocListHead->prev = node;
682 }
683 grdev->allocListHead = node;
684 pthread_mutex_unlock(&grdev->lock);
685
686 *pHandle = cb;
687 D("%s: alloc succeded, new ashmem base and size: %p %d handle: %p",
688 __FUNCTION__, cb->ashmemBase, cb->ashmemSize, cb);
689 switch (frameworkFormat) {
690 case HAL_PIXEL_FORMAT_YCbCr_420_888:
691 *pStride = 0;
692 break;
693 default:
694 *pStride = stride;
695 break;
696 }
697 return 0;
698 }
699
gralloc_free(alloc_device_t * dev,buffer_handle_t handle)700 static int gralloc_free(alloc_device_t* dev,
701 buffer_handle_t handle)
702 {
703 cb_handle_t *cb = (cb_handle_t *)handle;
704 if (!cb_handle_t::validate((cb_handle_t*)cb)) {
705 ERR("gralloc_free: invalid handle");
706 return -EINVAL;
707 }
708
709 D("%s: for buf %p ptr %p size %d\n",
710 __FUNCTION__, handle, cb->ashmemBase, cb->ashmemSize);
711
712 if (cb->hostHandle) {
713 int32_t openCount = 1;
714 int32_t* openCountPtr = &openCount;
715
716 if (isHidlGralloc) { openCountPtr = getOpenCountPtr(cb); }
717
718 if (*openCountPtr > 0) {
719 DEFINE_AND_VALIDATE_HOST_CONNECTION;
720 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
721 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
722 } else {
723 D("A rcCloseColorBuffer is owed!!! sdk ver: %d", PLATFORM_SDK_VERSION);
724 *openCountPtr = -1;
725 }
726 }
727
728 //
729 // detach and unmap ashmem area if present
730 //
731 if (cb->fd > 0) {
732 if (cb->ashmemSize > 0 && cb->ashmemBase) {
733 D("%s: unmapped %p", __FUNCTION__, cb->ashmemBase);
734 munmap((void *)cb->ashmemBase, cb->ashmemSize);
735 put_gralloc_dmaregion();
736 }
737 close(cb->fd);
738 }
739
740 D("%s: done", __FUNCTION__);
741 // remove it from the allocated list
742 gralloc_device_t *grdev = (gralloc_device_t *)dev;
743 pthread_mutex_lock(&grdev->lock);
744 AllocListNode *n = grdev->allocListHead;
745 while( n && n->handle != cb ) {
746 n = n->next;
747 }
748 if (n) {
749 // buffer found on list - remove it from list
750 if (n->next) {
751 n->next->prev = n->prev;
752 }
753 if (n->prev) {
754 n->prev->next = n->next;
755 }
756 else {
757 grdev->allocListHead = n->next;
758 }
759
760 delete n;
761 }
762 pthread_mutex_unlock(&grdev->lock);
763
764 delete cb;
765
766 D("%s: exit", __FUNCTION__);
767 return 0;
768 }
769
gralloc_device_close(struct hw_device_t * dev)770 static int gralloc_device_close(struct hw_device_t *dev)
771 {
772 gralloc_device_t* d = reinterpret_cast<gralloc_device_t*>(dev);
773 if (d) {
774
775 // free still allocated buffers
776 while( d->allocListHead != NULL ) {
777 gralloc_free(&d->device, d->allocListHead->handle);
778 }
779
780 // free device
781 free(d);
782 }
783 return 0;
784 }
785
fb_compositionComplete(struct framebuffer_device_t * dev)786 static int fb_compositionComplete(struct framebuffer_device_t* dev)
787 {
788 (void)dev;
789
790 return 0;
791 }
792
793 //
794 // Framebuffer device functions
795 //
fb_post(struct framebuffer_device_t * dev,buffer_handle_t buffer)796 static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
797 {
798 fb_device_t *fbdev = (fb_device_t *)dev;
799 cb_handle_t *cb = (cb_handle_t *)buffer;
800
801 if (!fbdev || !cb_handle_t::validate(cb) || !cb->canBePosted()) {
802 return -EINVAL;
803 }
804
805 // Make sure we have host connection
806 DEFINE_AND_VALIDATE_HOST_CONNECTION;
807
808 // increment the post count of the buffer
809 intptr_t *postCountPtr = (intptr_t *)cb->ashmemBase;
810 if (!postCountPtr) {
811 // This should not happen
812 return -EINVAL;
813 }
814 (*postCountPtr)++;
815
816 // send post request to host
817 rcEnc->rcFBPost(rcEnc, cb->hostHandle);
818 hostCon->flush();
819
820 return 0;
821 }
822
fb_setUpdateRect(struct framebuffer_device_t * dev,int l,int t,int w,int h)823 static int fb_setUpdateRect(struct framebuffer_device_t* dev,
824 int l, int t, int w, int h)
825 {
826 fb_device_t *fbdev = (fb_device_t *)dev;
827
828 (void)l;
829 (void)t;
830 (void)w;
831 (void)h;
832
833 if (!fbdev) {
834 return -EINVAL;
835 }
836
837 // Make sure we have host connection
838 DEFINE_AND_VALIDATE_HOST_CONNECTION;
839
840 // send request to host
841 // TODO: XXX - should be implemented
842 //rcEnc->rc_XXX
843
844 return 0;
845 }
846
fb_setSwapInterval(struct framebuffer_device_t * dev,int interval)847 static int fb_setSwapInterval(struct framebuffer_device_t* dev,
848 int interval)
849 {
850 fb_device_t *fbdev = (fb_device_t *)dev;
851
852 if (!fbdev) {
853 return -EINVAL;
854 }
855
856 // Make sure we have host connection
857 DEFINE_AND_VALIDATE_HOST_CONNECTION;
858
859 // send request to host
860 rcEnc->rcFBSetSwapInterval(rcEnc, interval);
861 hostCon->flush();
862
863 return 0;
864 }
865
fb_close(struct hw_device_t * dev)866 static int fb_close(struct hw_device_t *dev)
867 {
868 fb_device_t *fbdev = (fb_device_t *)dev;
869
870 delete fbdev;
871
872 return 0;
873 }
874
875
876 //
877 // gralloc module functions - refcount + locking interface
878 //
gralloc_register_buffer(gralloc_module_t const * module,buffer_handle_t handle)879 static int gralloc_register_buffer(gralloc_module_t const* module,
880 buffer_handle_t handle)
881 {
882
883 D("%s: start", __FUNCTION__);
884 pthread_once(&sFallbackOnce, fallback_init);
885 if (sFallback != NULL) {
886 return sFallback->registerBuffer(sFallback, handle);
887 }
888
889 D("gralloc_register_buffer(%p) called", handle);
890
891 private_module_t *gr = (private_module_t *)module;
892 cb_handle_t *cb = (cb_handle_t *)handle;
893
894 if (!gr || !cb_handle_t::validate(cb)) {
895 ERR("gralloc_register_buffer(%p): invalid buffer", cb);
896 return -EINVAL;
897 }
898
899 if (cb->hostHandle != 0) {
900 DEFINE_AND_VALIDATE_HOST_CONNECTION;
901 D("Opening host ColorBuffer 0x%x\n", cb->hostHandle);
902 rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
903 }
904
905 //
906 // if the color buffer has ashmem region and it is not mapped in this
907 // process map it now.
908 //
909 if (cb->ashmemSize > 0 && cb->mappedPid != getpid()) {
910 void *vaddr;
911 int err = map_buffer(cb, &vaddr);
912 if (err) {
913 ERR("gralloc_register_buffer(%p): map failed: %s", cb, strerror(-err));
914 return -err;
915 }
916 cb->mappedPid = getpid();
917
918 if (isHidlGralloc) {
919 int32_t* openCountPtr = getOpenCountPtr(cb);
920 if (!*openCountPtr) *openCountPtr = 1;
921 }
922
923 DEFINE_AND_VALIDATE_HOST_CONNECTION;
924 if (rcEnc->getDmaVersion() > 0) {
925 init_gralloc_dmaregion();
926 gralloc_dmaregion_register_ashmem(cb->ashmemSize);
927 }
928
929 }
930
931 if (cb->ashmemSize > 0) {
932 GET_ASHMEM_REGION(cb);
933 get_gralloc_dmaregion();
934 }
935
936 return 0;
937 }
938
gralloc_unregister_buffer(gralloc_module_t const * module,buffer_handle_t handle)939 static int gralloc_unregister_buffer(gralloc_module_t const* module,
940 buffer_handle_t handle)
941 {
942 if (sFallback != NULL) {
943 return sFallback->unregisterBuffer(sFallback, handle);
944 }
945
946 private_module_t *gr = (private_module_t *)module;
947 cb_handle_t *cb = (cb_handle_t *)handle;
948
949 if (!gr || !cb_handle_t::validate(cb)) {
950 ERR("gralloc_unregister_buffer(%p): invalid buffer", cb);
951 return -EINVAL;
952 }
953
954
955 if (cb->hostHandle) {
956 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
957 DEFINE_AND_VALIDATE_HOST_CONNECTION;
958 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
959
960 if (isHidlGralloc) {
961 // Queue up another rcCloseColorBuffer if applicable.
962 // invariant: have ashmem.
963 if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) {
964 int32_t* openCountPtr = getOpenCountPtr(cb);
965 if (*openCountPtr == -1) {
966 D("%s: revenge of the rcCloseColorBuffer!", __func__);
967 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
968 *openCountPtr = -2;
969 }
970 }
971 }
972 }
973
974 //
975 // unmap ashmem region if it was previously mapped in this process
976 // (through register_buffer)
977 //
978 if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) {
979
980 PUT_ASHMEM_REGION(cb);
981 put_gralloc_dmaregion();
982
983 if (!SHOULD_UNMAP) goto done;
984
985 DEFINE_AND_VALIDATE_HOST_CONNECTION;
986
987 void *vaddr;
988 int err = munmap((void *)cb->ashmemBase, cb->ashmemSize);
989 if (err) {
990 ERR("gralloc_unregister_buffer(%p): unmap failed", cb);
991 return -EINVAL;
992 }
993 cb->ashmemBase = 0;
994 cb->mappedPid = 0;
995 D("%s: Unregister buffer previous mapped to pid %d", __FUNCTION__, getpid());
996 }
997
998 done:
999 D("gralloc_unregister_buffer(%p) done\n", cb);
1000 return 0;
1001 }
1002
1003
1004
gralloc_lock(gralloc_module_t const * module,buffer_handle_t handle,int usage,int l,int t,int w,int h,void ** vaddr)1005 static int gralloc_lock(gralloc_module_t const* module,
1006 buffer_handle_t handle, int usage,
1007 int l, int t, int w, int h,
1008 void** vaddr)
1009 {
1010 if (sFallback != NULL) {
1011 return sFallback->lock(sFallback, handle, usage, l, t, w, h, vaddr);
1012 }
1013
1014 private_module_t *gr = (private_module_t *)module;
1015 cb_handle_t *cb = (cb_handle_t *)handle;
1016
1017 if (!gr || !cb_handle_t::validate(cb)) {
1018 ALOGE("gralloc_lock bad handle\n");
1019 return -EINVAL;
1020 }
1021
1022 // Validate usage,
1023 // 1. cannot be locked for hw access
1024 // 2. lock for either sw read or write.
1025 // 3. locked sw access must match usage during alloc time.
1026 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK));
1027 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
1028 bool hw_read = (usage & GRALLOC_USAGE_HW_TEXTURE);
1029 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
1030 #if PLATFORM_SDK_VERSION >= 17
1031 bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE);
1032 bool hw_cam_read = (usage & GRALLOC_USAGE_HW_CAMERA_READ);
1033 #else // PLATFORM_SDK_VERSION
1034 bool hw_cam_write = false;
1035 bool hw_cam_read = false;
1036 #endif // PLATFORM_SDK_VERSION
1037
1038 #if PLATFORM_SDK_VERSION >= 15
1039 bool hw_vid_enc_read = (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER);
1040 #else // PLATFORM_SDK_VERSION
1041 bool hw_vid_enc_read = false;
1042 #endif // PLATFORM_SDK_VERSION
1043
1044 bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK));
1045
1046 #if PLATFORM_SDK_VERSION >= 15
1047 // bug: 30088791
1048 // a buffer was created for GRALLOC_USAGE_HW_VIDEO_ENCODER usage but
1049 // later a software encoder is reading this buffer: this is actually
1050 // legit usage.
1051 sw_read_allowed = sw_read_allowed || (cb->usage & GRALLOC_USAGE_HW_VIDEO_ENCODER);
1052 #endif // PLATFORM_SDK_VERSION >= 15
1053
1054 bool sw_write_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_WRITE_MASK));
1055
1056 if ( (hw_read || hw_write) ||
1057 (!sw_read && !sw_write &&
1058 !hw_cam_write && !hw_cam_read &&
1059 !hw_vid_enc_read) ||
1060 (sw_read && !sw_read_allowed) ||
1061 (sw_write && !sw_write_allowed) ) {
1062 ALOGE("gralloc_lock usage mismatch usage=0x%x cb->usage=0x%x\n", usage,
1063 cb->usage);
1064 //This is not exactly an error and loose it up.
1065 //bug: 30784436
1066 //return -EINVAL;
1067 }
1068
1069 intptr_t postCount = 0;
1070 void *cpu_addr = NULL;
1071
1072 //
1073 // make sure ashmem area is mapped if needed
1074 //
1075 if (cb->canBePosted() || sw_read || sw_write ||
1076 hw_cam_write || hw_cam_read ||
1077 hw_vid_enc_read) {
1078 if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) {
1079 return -EACCES;
1080 }
1081
1082 cpu_addr = (void *)(cb->ashmemBase + getAshmemColorOffset(cb));
1083 }
1084
1085 if (cb->hostHandle) {
1086 // Make sure we have host connection
1087 DEFINE_AND_VALIDATE_HOST_CONNECTION;
1088
1089 //
1090 // flush color buffer write cache on host and get its sync status.
1091 //
1092 int hostSyncStatus = rcEnc->rcColorBufferCacheFlush(rcEnc, cb->hostHandle,
1093 postCount,
1094 sw_read);
1095 if (hostSyncStatus < 0) {
1096 // host failed the color buffer sync - probably since it was already
1097 // locked for write access. fail the lock.
1098 ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n",
1099 postCount, sw_read);
1100 return -EBUSY;
1101 }
1102
1103 if (sw_read) {
1104 void* rgb_addr = cpu_addr;
1105 char* tmpBuf = 0;
1106 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12 ||
1107 cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1108 // We are using RGB888
1109 tmpBuf = new char[cb->width * cb->height * 3];
1110 rgb_addr = tmpBuf;
1111 }
1112 D("gralloc_lock read back color buffer %d %d ashmem base %p sz %d\n",
1113 cb->width, cb->height, cb->ashmemBase, cb->ashmemSize);
1114 rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle,
1115 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, rgb_addr);
1116 if (tmpBuf) {
1117 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
1118 rgb888_to_yv12((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
1119 } else if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1120 rgb888_to_yuv420p((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
1121 }
1122 delete [] tmpBuf;
1123 }
1124 }
1125 }
1126
1127 //
1128 // is virtual address required ?
1129 //
1130 if (sw_read || sw_write || hw_cam_write || hw_cam_read || hw_vid_enc_read) {
1131 *vaddr = cpu_addr;
1132 }
1133
1134 if (sw_write || hw_cam_write) {
1135 //
1136 // Keep locked region if locked for s/w write access.
1137 //
1138 cb->lockedLeft = l;
1139 cb->lockedTop = t;
1140 cb->lockedWidth = w;
1141 cb->lockedHeight = h;
1142 }
1143
1144 DD("gralloc_lock success. vaddr: %p, *vaddr: %p, usage: %x, cpu_addr: %p",
1145 vaddr, vaddr ? *vaddr : 0, usage, cpu_addr);
1146
1147 return 0;
1148 }
1149
gralloc_unlock(gralloc_module_t const * module,buffer_handle_t handle)1150 static int gralloc_unlock(gralloc_module_t const* module,
1151 buffer_handle_t handle)
1152 {
1153 if (sFallback != NULL) {
1154 return sFallback->unlock(sFallback, handle);
1155 }
1156
1157 private_module_t *gr = (private_module_t *)module;
1158 cb_handle_t *cb = (cb_handle_t *)handle;
1159
1160 if (!gr || !cb_handle_t::validate(cb)) {
1161 ALOGD("%s: invalid gr or cb handle. -EINVAL", __FUNCTION__);
1162 return -EINVAL;
1163 }
1164
1165 //
1166 // if buffer was locked for s/w write, we need to update the host with
1167 // the updated data
1168 //
1169 if (cb->hostHandle) {
1170
1171 // Make sure we have host connection
1172 DEFINE_AND_VALIDATE_HOST_CONNECTION;
1173
1174 void *cpu_addr = (void *)(cb->ashmemBase + getAshmemColorOffset(cb));
1175
1176 char* rgb_addr = (char *)cpu_addr;
1177 if (cb->lockedWidth < cb->width || cb->lockedHeight < cb->height) {
1178 updateHostColorBuffer(cb, true, rgb_addr);
1179 }
1180 else {
1181 updateHostColorBuffer(cb, false, rgb_addr);
1182 }
1183
1184 DD("gralloc_unlock success. cpu_addr: %p", cpu_addr);
1185 }
1186
1187 cb->lockedWidth = cb->lockedHeight = 0;
1188 return 0;
1189 }
1190
1191 #if PLATFORM_SDK_VERSION >= 18
gralloc_lock_ycbcr(gralloc_module_t const * module,buffer_handle_t handle,int usage,int l,int t,int w,int h,android_ycbcr * ycbcr)1192 static int gralloc_lock_ycbcr(gralloc_module_t const* module,
1193 buffer_handle_t handle, int usage,
1194 int l, int t, int w, int h,
1195 android_ycbcr *ycbcr)
1196 {
1197 // Not supporting fallback module for YCbCr
1198 if (sFallback != NULL) {
1199 ALOGD("%s: has fallback, return -EINVAL", __FUNCTION__);
1200 return -EINVAL;
1201 }
1202
1203 if (!ycbcr) {
1204 ALOGE("%s: got NULL ycbcr struct! -EINVAL", __FUNCTION__);
1205 return -EINVAL;
1206 }
1207
1208 private_module_t *gr = (private_module_t *)module;
1209 cb_handle_t *cb = (cb_handle_t *)handle;
1210 if (!gr || !cb_handle_t::validate(cb)) {
1211 ALOGE("%s: bad colorbuffer handle. -EINVAL", __FUNCTION__);
1212 return -EINVAL;
1213 }
1214
1215 if (cb->frameworkFormat != HAL_PIXEL_FORMAT_YV12 &&
1216 cb->frameworkFormat != HAL_PIXEL_FORMAT_YCbCr_420_888) {
1217 ALOGE("gralloc_lock_ycbcr can only be used with "
1218 "HAL_PIXEL_FORMAT_YCbCr_420_888 or HAL_PIXEL_FORMAT_YV12, got %x instead. "
1219 "-EINVAL",
1220 cb->frameworkFormat);
1221 return -EINVAL;
1222 }
1223
1224 // Make sure memory is mapped, get address
1225 if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) {
1226 ALOGD("%s: ashmembase not mapped. -EACCESS", __FUNCTION__);
1227 return -EACCES;
1228 }
1229
1230 uint8_t *cpu_addr = NULL;
1231 cpu_addr = (uint8_t *)(cb->ashmemBase) + getAshmemColorOffset(cb);
1232
1233 // Calculate offsets to underlying YUV data
1234 size_t yStride;
1235 size_t cStride;
1236 size_t cSize;
1237 size_t yOffset;
1238 size_t uOffset;
1239 size_t vOffset;
1240 size_t cStep;
1241 size_t align;
1242 switch (cb->format) {
1243 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1244 yStride = cb->width;
1245 cStride = cb->width;
1246 yOffset = 0;
1247 vOffset = yStride * cb->height;
1248 uOffset = vOffset + 1;
1249 cStep = 2;
1250 break;
1251 case HAL_PIXEL_FORMAT_YV12:
1252 // https://developer.android.com/reference/android/graphics/ImageFormat.html#YV12
1253 align = 16;
1254 yStride = (cb->width + (align -1)) & ~(align-1);
1255 cStride = (yStride / 2 + (align - 1)) & ~(align-1);
1256 yOffset = 0;
1257 cSize = cStride * cb->height/2;
1258 vOffset = yStride * cb->height;
1259 uOffset = vOffset + cSize;
1260 cStep = 1;
1261 break;
1262 case HAL_PIXEL_FORMAT_YCbCr_420_888:
1263 align = 1;
1264 yStride = cb->width;
1265 cStride = yStride / 2;
1266 yOffset = 0;
1267 cSize = cStride * cb->height/2;
1268 uOffset = yStride * cb->height;
1269 vOffset = uOffset + cSize;
1270 cStep = 1;
1271 break;
1272 default:
1273 ALOGE("gralloc_lock_ycbcr unexpected internal format %x",
1274 cb->format);
1275 return -EINVAL;
1276 }
1277
1278 ycbcr->y = cpu_addr + yOffset;
1279 ycbcr->cb = cpu_addr + uOffset;
1280 ycbcr->cr = cpu_addr + vOffset;
1281 ycbcr->ystride = yStride;
1282 ycbcr->cstride = cStride;
1283 ycbcr->chroma_step = cStep;
1284
1285 // Zero out reserved fields
1286 memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
1287
1288 //
1289 // Keep locked region if locked for s/w write access.
1290 //
1291 cb->lockedLeft = l;
1292 cb->lockedTop = t;
1293 cb->lockedWidth = w;
1294 cb->lockedHeight = h;
1295
1296 DD("gralloc_lock_ycbcr success. usage: %x, ycbcr.y: %p, .cb: %p, .cr: %p, "
1297 ".ystride: %d , .cstride: %d, .chroma_step: %d", usage,
1298 ycbcr->y, ycbcr->cb, ycbcr->cr, ycbcr->ystride, ycbcr->cstride,
1299 ycbcr->chroma_step);
1300
1301 return 0;
1302 }
1303 #endif // PLATFORM_SDK_VERSION >= 18
1304
gralloc_device_open(const hw_module_t * module,const char * name,hw_device_t ** device)1305 static int gralloc_device_open(const hw_module_t* module,
1306 const char* name,
1307 hw_device_t** device)
1308 {
1309 int status = -EINVAL;
1310
1311 D("gralloc_device_open %s\n", name);
1312
1313 pthread_once( &sFallbackOnce, fallback_init );
1314 if (sFallback != NULL) {
1315 return sFallback->common.methods->open(&sFallback->common, name, device);
1316 }
1317
1318 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
1319
1320 // Create host connection and keep it in the TLS.
1321 // return error if connection with host can not be established
1322 HostConnection *hostCon = HostConnection::get();
1323 if (!hostCon) {
1324 ALOGE("gralloc: failed to get host connection while opening %s\n", name);
1325 return -EIO;
1326 }
1327
1328 //
1329 // Allocate memory for the gralloc device (alloc interface)
1330 //
1331 gralloc_device_t *dev;
1332 dev = (gralloc_device_t*)malloc(sizeof(gralloc_device_t));
1333 if (NULL == dev) {
1334 return -ENOMEM;
1335 }
1336 memset(dev, 0, sizeof(gralloc_device_t));
1337
1338 // Initialize our device structure
1339 //
1340 dev->device.common.tag = HARDWARE_DEVICE_TAG;
1341 dev->device.common.version = 0;
1342 dev->device.common.module = const_cast<hw_module_t*>(module);
1343 dev->device.common.close = gralloc_device_close;
1344
1345 dev->device.alloc = gralloc_alloc;
1346 dev->device.free = gralloc_free;
1347 dev->allocListHead = NULL;
1348 pthread_mutex_init(&dev->lock, NULL);
1349
1350 *device = &dev->device.common;
1351 status = 0;
1352 }
1353 else if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
1354
1355 // return error if connection with host can not be established
1356 DEFINE_AND_VALIDATE_HOST_CONNECTION;
1357
1358 //
1359 // Query the host for Framebuffer attributes
1360 //
1361 D("gralloc: query Frabuffer attribs\n");
1362 EGLint width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH);
1363 D("gralloc: width=%d\n", width);
1364 EGLint height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT);
1365 D("gralloc: height=%d\n", height);
1366 EGLint xdpi = rcEnc->rcGetFBParam(rcEnc, FB_XDPI);
1367 D("gralloc: xdpi=%d\n", xdpi);
1368 EGLint ydpi = rcEnc->rcGetFBParam(rcEnc, FB_YDPI);
1369 D("gralloc: ydpi=%d\n", ydpi);
1370 EGLint fps = rcEnc->rcGetFBParam(rcEnc, FB_FPS);
1371 D("gralloc: fps=%d\n", fps);
1372 EGLint min_si = rcEnc->rcGetFBParam(rcEnc, FB_MIN_SWAP_INTERVAL);
1373 D("gralloc: min_swap=%d\n", min_si);
1374 EGLint max_si = rcEnc->rcGetFBParam(rcEnc, FB_MAX_SWAP_INTERVAL);
1375 D("gralloc: max_swap=%d\n", max_si);
1376
1377 //
1378 // Allocate memory for the framebuffer device
1379 //
1380 fb_device_t *dev;
1381 dev = (fb_device_t*)malloc(sizeof(fb_device_t));
1382 if (NULL == dev) {
1383 return -ENOMEM;
1384 }
1385 memset(dev, 0, sizeof(fb_device_t));
1386
1387 // Initialize our device structure
1388 //
1389 dev->device.common.tag = HARDWARE_DEVICE_TAG;
1390 dev->device.common.version = 0;
1391 dev->device.common.module = const_cast<hw_module_t*>(module);
1392 dev->device.common.close = fb_close;
1393 dev->device.setSwapInterval = fb_setSwapInterval;
1394 dev->device.post = fb_post;
1395 dev->device.setUpdateRect = 0; //fb_setUpdateRect;
1396 dev->device.compositionComplete = fb_compositionComplete; //XXX: this is a dummy
1397
1398 const_cast<uint32_t&>(dev->device.flags) = 0;
1399 const_cast<uint32_t&>(dev->device.width) = width;
1400 const_cast<uint32_t&>(dev->device.height) = height;
1401 const_cast<int&>(dev->device.stride) = width;
1402 const_cast<int&>(dev->device.format) = HAL_PIXEL_FORMAT_RGBA_8888;
1403 const_cast<float&>(dev->device.xdpi) = xdpi;
1404 const_cast<float&>(dev->device.ydpi) = ydpi;
1405 const_cast<float&>(dev->device.fps) = fps;
1406 const_cast<int&>(dev->device.minSwapInterval) = min_si;
1407 const_cast<int&>(dev->device.maxSwapInterval) = max_si;
1408 *device = &dev->device.common;
1409
1410 status = 0;
1411 }
1412
1413 return status;
1414 }
1415
1416 //
1417 // define the HMI symbol - our module interface
1418 //
1419 static struct hw_module_methods_t gralloc_module_methods = {
1420 open: gralloc_device_open
1421 };
1422
1423 struct private_module_t HAL_MODULE_INFO_SYM = {
1424 base: {
1425 common: {
1426 tag: HARDWARE_MODULE_TAG,
1427 #if PLATFORM_SDK_VERSION >= 18
1428 module_api_version: GRALLOC_MODULE_API_VERSION_0_2,
1429 hal_api_version: 0,
1430 #elif PLATFORM_SDK_VERSION >= 16
1431 module_api_version: 1,
1432 hal_api_version: 0,
1433 #else // PLATFORM_SDK_VERSION
1434 version_major: 1,
1435 version_minor: 0,
1436 #endif // PLATFORM_SDK_VERSION
1437 id: GRALLOC_HARDWARE_MODULE_ID,
1438 name: "Graphics Memory Allocator Module",
1439 author: "The Android Open Source Project",
1440 methods: &gralloc_module_methods,
1441 dso: NULL,
1442 reserved: {0, }
1443 },
1444 registerBuffer: gralloc_register_buffer,
1445 unregisterBuffer: gralloc_unregister_buffer,
1446 lock: gralloc_lock,
1447 unlock: gralloc_unlock,
1448 perform: NULL,
1449 #if PLATFORM_SDK_VERSION >= 18
1450 lock_ycbcr: gralloc_lock_ycbcr,
1451 #endif // PLATFORM_SDK_VERSION >= 18
1452 }
1453 };
1454
1455 /* This function is called once to detect whether the emulator supports
1456 * GPU emulation (this is done by looking at the qemu.gles kernel
1457 * parameter, which must be == 1 if this is the case).
1458 *
1459 * If not, then load gralloc.default instead as a fallback.
1460 */
1461 static void
fallback_init(void)1462 fallback_init(void)
1463 {
1464 char prop[PROPERTY_VALUE_MAX];
1465 void* module;
1466
1467 // qemu.gles=0 -> no GLES 2.x support (only 1.x through software).
1468 // qemu.gles=1 -> host-side GPU emulation through EmuGL
1469 // qemu.gles=2 -> guest-side GPU emulation.
1470 property_get("ro.kernel.qemu.gles", prop, "0");
1471 if (atoi(prop) == 1) {
1472 return;
1473 }
1474 ALOGD("Emulator without host-side GPU emulation detected.");
1475 #if __LP64__
1476 module = dlopen("/vendor/lib64/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL);
1477 #else
1478 module = dlopen("/vendor/lib/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL);
1479 #endif
1480 if (module != NULL) {
1481 sFallback = reinterpret_cast<gralloc_module_t*>(dlsym(module, HAL_MODULE_INFO_SYM_AS_STR));
1482 if (sFallback == NULL) {
1483 dlclose(module);
1484 }
1485 }
1486 if (sFallback == NULL) {
1487 ALOGE("Could not find software fallback module!?");
1488 }
1489 }
1490