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 "HostConnection.h" 26 #include "glUtils.h" 27 #include <cutils/log.h> 28 #include <cutils/properties.h> 29 30 /* Set to 1 or 2 to enable debug traces */ 31 #define DEBUG 0 32 33 #if DEBUG >= 1 34 # define D(...) ALOGD(__VA_ARGS__) 35 #else 36 # define D(...) ((void)0) 37 #endif 38 39 #if DEBUG >= 2 40 # define DD(...) ALOGD(__VA_ARGS__) 41 #else 42 # define DD(...) ((void)0) 43 #endif 44 45 #define DBG_FUNC DBG("%s\n", __FUNCTION__) 46 // 47 // our private gralloc module structure 48 // 49 struct private_module_t { 50 gralloc_module_t base; 51 }; 52 53 /* If not NULL, this is a pointer to the fallback module. 54 * This really is gralloc.default, which we'll use if we detect 55 * that the emulator we're running in does not support GPU emulation. 56 */ 57 static gralloc_module_t* sFallback; 58 static pthread_once_t sFallbackOnce = PTHREAD_ONCE_INIT; 59 60 static void fallback_init(void); // forward 61 62 63 typedef struct _alloc_list_node { 64 buffer_handle_t handle; 65 _alloc_list_node *next; 66 _alloc_list_node *prev; 67 } AllocListNode; 68 69 // 70 // Our gralloc device structure (alloc interface) 71 // 72 struct gralloc_device_t { 73 alloc_device_t device; 74 75 AllocListNode *allocListHead; // double linked list of allocated buffers 76 pthread_mutex_t lock; 77 }; 78 79 // 80 // Our framebuffer device structure 81 // 82 struct fb_device_t { 83 framebuffer_device_t device; 84 }; 85 86 static int map_buffer(cb_handle_t *cb, void **vaddr) 87 { 88 if (cb->fd < 0 || cb->ashmemSize <= 0) { 89 return -EINVAL; 90 } 91 92 void *addr = mmap(0, cb->ashmemSize, PROT_READ | PROT_WRITE, 93 MAP_SHARED, cb->fd, 0); 94 if (addr == MAP_FAILED) { 95 return -errno; 96 } 97 98 cb->ashmemBase = intptr_t(addr); 99 cb->ashmemBasePid = getpid(); 100 101 *vaddr = addr; 102 return 0; 103 } 104 105 #define DEFINE_HOST_CONNECTION \ 106 HostConnection *hostCon = HostConnection::get(); \ 107 renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL) 108 109 #define DEFINE_AND_VALIDATE_HOST_CONNECTION \ 110 HostConnection *hostCon = HostConnection::get(); \ 111 if (!hostCon) { \ 112 ALOGE("gralloc: Failed to get host connection\n"); \ 113 return -EIO; \ 114 } \ 115 renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ 116 if (!rcEnc) { \ 117 ALOGE("gralloc: Failed to get renderControl encoder context\n"); \ 118 return -EIO; \ 119 } 120 121 122 // 123 // gralloc device functions (alloc interface) 124 // 125 static int gralloc_alloc(alloc_device_t* dev, 126 int w, int h, int format, int usage, 127 buffer_handle_t* pHandle, int* pStride) 128 { 129 D("gralloc_alloc w=%d h=%d usage=0x%x\n", w, h, usage); 130 131 gralloc_device_t *grdev = (gralloc_device_t *)dev; 132 if (!grdev || !pHandle || !pStride) { 133 ALOGE("gralloc_alloc: Bad inputs (grdev: %p, pHandle: %p, pStride: %p", 134 grdev, pHandle, pStride); 135 return -EINVAL; 136 } 137 138 // 139 // Note: in screen capture mode, both sw_write and hw_write will be on 140 // and this is a valid usage 141 // 142 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK)); 143 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER); 144 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); 145 bool hw_cam_write = usage & GRALLOC_USAGE_HW_CAMERA_WRITE; 146 bool hw_cam_read = usage & GRALLOC_USAGE_HW_CAMERA_READ; 147 bool hw_vid_enc_read = usage & GRALLOC_USAGE_HW_VIDEO_ENCODER; 148 149 // Keep around original requested format for later validation 150 int frameworkFormat = format; 151 // Pick the right concrete pixel format given the endpoints as encoded in 152 // the usage bits. Every end-point pair needs explicit listing here. 153 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 154 // Camera as producer 155 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { 156 if (usage & GRALLOC_USAGE_HW_TEXTURE) { 157 // Camera-to-display is RGBA 158 format = HAL_PIXEL_FORMAT_RGBA_8888; 159 } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { 160 // Camera-to-encoder is NV21 161 format = HAL_PIXEL_FORMAT_YCrCb_420_SP; 162 } else if ((usage & GRALLOC_USAGE_HW_CAMERA_MASK) == 163 GRALLOC_USAGE_HW_CAMERA_ZSL) { 164 // Camera-to-ZSL-queue is RGB_888 165 format = HAL_PIXEL_FORMAT_RGB_888; 166 } 167 } 168 169 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 170 ALOGE("gralloc_alloc: Requested auto format selection, " 171 "but no known format for this usage: %d x %d, usage %x", 172 w, h, usage); 173 return -EINVAL; 174 } 175 } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 176 // Flexible framework-accessible YUV format; map to NV21 for now 177 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { 178 format = HAL_PIXEL_FORMAT_YCrCb_420_SP; 179 } 180 if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 181 ALOGE("gralloc_alloc: Requested YCbCr_420_888, but no known " 182 "specific format for this usage: %d x %d, usage %x", 183 w, h, usage); 184 } 185 } 186 bool yuv_format = false; 187 188 int ashmem_size = 0; 189 int stride = w; 190 191 GLenum glFormat = 0; 192 GLenum glType = 0; 193 194 int bpp = 0; 195 int align = 1; 196 switch (format) { 197 case HAL_PIXEL_FORMAT_RGBA_8888: 198 case HAL_PIXEL_FORMAT_RGBX_8888: 199 case HAL_PIXEL_FORMAT_BGRA_8888: 200 bpp = 4; 201 glFormat = GL_RGBA; 202 glType = GL_UNSIGNED_BYTE; 203 break; 204 case HAL_PIXEL_FORMAT_RGB_888: 205 bpp = 3; 206 glFormat = GL_RGB; 207 glType = GL_UNSIGNED_BYTE; 208 break; 209 case HAL_PIXEL_FORMAT_RGB_565: 210 bpp = 2; 211 glFormat = GL_RGB; 212 glType = GL_UNSIGNED_SHORT_5_6_5; 213 break; 214 case HAL_PIXEL_FORMAT_RAW16: 215 case HAL_PIXEL_FORMAT_Y16: 216 bpp = 2; 217 align = 16*bpp; 218 if (! ((sw_read || hw_cam_read) && (sw_write || hw_cam_write) ) ) { 219 // Raw sensor data or Y16 only goes between camera and CPU 220 return -EINVAL; 221 } 222 // Not expecting to actually create any GL surfaces for this 223 glFormat = GL_LUMINANCE; 224 glType = GL_UNSIGNED_SHORT; 225 break; 226 case HAL_PIXEL_FORMAT_BLOB: 227 bpp = 1; 228 if (! (sw_read && hw_cam_write) ) { 229 // Blob data cannot be used by HW other than camera emulator 230 return -EINVAL; 231 } 232 // Not expecting to actually create any GL surfaces for this 233 glFormat = GL_LUMINANCE; 234 glType = GL_UNSIGNED_BYTE; 235 break; 236 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 237 align = 1; 238 bpp = 1; // per-channel bpp 239 yuv_format = true; 240 // Not expecting to actually create any GL surfaces for this 241 break; 242 case HAL_PIXEL_FORMAT_YV12: 243 align = 16; 244 bpp = 1; // per-channel bpp 245 yuv_format = true; 246 // Not expecting to actually create any GL surfaces for this 247 break; 248 default: 249 ALOGE("gralloc_alloc: Unknown format %d", format); 250 return -EINVAL; 251 } 252 253 if (usage & GRALLOC_USAGE_HW_FB) { 254 // keep space for postCounter 255 ashmem_size += sizeof(uint32_t); 256 } 257 258 if (sw_read || sw_write || hw_cam_write || hw_vid_enc_read) { 259 // keep space for image on guest memory if SW access is needed 260 // or if the camera is doing writing 261 if (yuv_format) { 262 size_t yStride = (w*bpp + (align - 1)) & ~(align-1); 263 size_t uvStride = (yStride / 2 + (align - 1)) & ~(align-1); 264 size_t uvHeight = h / 2; 265 ashmem_size += yStride * h + 2 * (uvHeight * uvStride); 266 stride = yStride / bpp; 267 } else { 268 size_t bpr = (w*bpp + (align-1)) & ~(align-1); 269 ashmem_size += (bpr * h); 270 stride = bpr / bpp; 271 } 272 } 273 274 D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format, 275 ashmem_size, stride, gettid()); 276 277 // 278 // Allocate space in ashmem if needed 279 // 280 int fd = -1; 281 if (ashmem_size > 0) { 282 // round to page size; 283 ashmem_size = (ashmem_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1); 284 285 fd = ashmem_create_region("gralloc-buffer", ashmem_size); 286 if (fd < 0) { 287 ALOGE("gralloc_alloc failed to create ashmem region: %s\n", 288 strerror(errno)); 289 return -errno; 290 } 291 } 292 293 cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage, 294 w, h, frameworkFormat, format, 295 glFormat, glType); 296 297 if (ashmem_size > 0) { 298 // 299 // map ashmem region if exist 300 // 301 void *vaddr; 302 int err = map_buffer(cb, &vaddr); 303 if (err) { 304 close(fd); 305 delete cb; 306 return err; 307 } 308 309 cb->setFd(fd); 310 } 311 312 // 313 // Allocate ColorBuffer handle on the host (only if h/w access is allowed) 314 // Only do this for some h/w usages, not all. 315 // Also do this if we need to read from the surface, in this case the 316 // rendering will still happen on the host but we also need to be able to 317 // read back from the color buffer, which requires that there is a buffer 318 // 319 if (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER | 320 GRALLOC_USAGE_HW_2D | GRALLOC_USAGE_HW_COMPOSER | 321 GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_MASK) ) { 322 DEFINE_HOST_CONNECTION; 323 if (hostCon && rcEnc) { 324 cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, glFormat); 325 D("Created host ColorBuffer 0x%x\n", cb->hostHandle); 326 } 327 328 if (!cb->hostHandle) { 329 // Could not create colorbuffer on host !!! 330 close(fd); 331 delete cb; 332 return -EIO; 333 } 334 } 335 336 // 337 // alloc succeeded - insert the allocated handle to the allocated list 338 // 339 AllocListNode *node = new AllocListNode(); 340 pthread_mutex_lock(&grdev->lock); 341 node->handle = cb; 342 node->next = grdev->allocListHead; 343 node->prev = NULL; 344 if (grdev->allocListHead) { 345 grdev->allocListHead->prev = node; 346 } 347 grdev->allocListHead = node; 348 pthread_mutex_unlock(&grdev->lock); 349 350 *pHandle = cb; 351 if (frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) { 352 *pStride = 0; 353 } else { 354 *pStride = stride; 355 } 356 return 0; 357 } 358 359 static int gralloc_free(alloc_device_t* dev, 360 buffer_handle_t handle) 361 { 362 const cb_handle_t *cb = (const cb_handle_t *)handle; 363 if (!cb_handle_t::validate((cb_handle_t*)cb)) { 364 ERR("gralloc_free: invalid handle"); 365 return -EINVAL; 366 } 367 368 if (cb->hostHandle != 0) { 369 DEFINE_AND_VALIDATE_HOST_CONNECTION; 370 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle); 371 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle); 372 } 373 374 // 375 // detach and unmap ashmem area if present 376 // 377 if (cb->fd > 0) { 378 if (cb->ashmemSize > 0 && cb->ashmemBase) { 379 munmap((void *)cb->ashmemBase, cb->ashmemSize); 380 } 381 close(cb->fd); 382 } 383 384 // remove it from the allocated list 385 gralloc_device_t *grdev = (gralloc_device_t *)dev; 386 pthread_mutex_lock(&grdev->lock); 387 AllocListNode *n = grdev->allocListHead; 388 while( n && n->handle != cb ) { 389 n = n->next; 390 } 391 if (n) { 392 // buffer found on list - remove it from list 393 if (n->next) { 394 n->next->prev = n->prev; 395 } 396 if (n->prev) { 397 n->prev->next = n->next; 398 } 399 else { 400 grdev->allocListHead = n->next; 401 } 402 403 delete n; 404 } 405 pthread_mutex_unlock(&grdev->lock); 406 407 delete cb; 408 409 return 0; 410 } 411 412 static int gralloc_device_close(struct hw_device_t *dev) 413 { 414 gralloc_device_t* d = reinterpret_cast<gralloc_device_t*>(dev); 415 if (d) { 416 417 // free still allocated buffers 418 while( d->allocListHead != NULL ) { 419 gralloc_free(&d->device, d->allocListHead->handle); 420 } 421 422 // free device 423 free(d); 424 } 425 return 0; 426 } 427 428 static int fb_compositionComplete(struct framebuffer_device_t* dev) 429 { 430 (void)dev; 431 432 return 0; 433 } 434 435 // 436 // Framebuffer device functions 437 // 438 static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer) 439 { 440 fb_device_t *fbdev = (fb_device_t *)dev; 441 cb_handle_t *cb = (cb_handle_t *)buffer; 442 443 if (!fbdev || !cb_handle_t::validate(cb) || !cb->canBePosted()) { 444 return -EINVAL; 445 } 446 447 // Make sure we have host connection 448 DEFINE_AND_VALIDATE_HOST_CONNECTION; 449 450 // increment the post count of the buffer 451 intptr_t *postCountPtr = (intptr_t *)cb->ashmemBase; 452 if (!postCountPtr) { 453 // This should not happen 454 return -EINVAL; 455 } 456 (*postCountPtr)++; 457 458 // send post request to host 459 rcEnc->rcFBPost(rcEnc, cb->hostHandle); 460 hostCon->flush(); 461 462 return 0; 463 } 464 465 static int fb_setUpdateRect(struct framebuffer_device_t* dev, 466 int l, int t, int w, int h) 467 { 468 fb_device_t *fbdev = (fb_device_t *)dev; 469 470 (void)l; 471 (void)t; 472 (void)w; 473 (void)h; 474 475 if (!fbdev) { 476 return -EINVAL; 477 } 478 479 // Make sure we have host connection 480 DEFINE_AND_VALIDATE_HOST_CONNECTION; 481 482 // send request to host 483 // TODO: XXX - should be implemented 484 //rcEnc->rc_XXX 485 486 return 0; 487 } 488 489 static int fb_setSwapInterval(struct framebuffer_device_t* dev, 490 int interval) 491 { 492 fb_device_t *fbdev = (fb_device_t *)dev; 493 494 if (!fbdev) { 495 return -EINVAL; 496 } 497 498 // Make sure we have host connection 499 DEFINE_AND_VALIDATE_HOST_CONNECTION; 500 501 // send request to host 502 rcEnc->rcFBSetSwapInterval(rcEnc, interval); 503 hostCon->flush(); 504 505 return 0; 506 } 507 508 static int fb_close(struct hw_device_t *dev) 509 { 510 fb_device_t *fbdev = (fb_device_t *)dev; 511 512 delete fbdev; 513 514 return 0; 515 } 516 517 518 // 519 // gralloc module functions - refcount + locking interface 520 // 521 static int gralloc_register_buffer(gralloc_module_t const* module, 522 buffer_handle_t handle) 523 { 524 pthread_once(&sFallbackOnce, fallback_init); 525 if (sFallback != NULL) { 526 return sFallback->registerBuffer(sFallback, handle); 527 } 528 529 D("gralloc_register_buffer(%p) called", handle); 530 531 private_module_t *gr = (private_module_t *)module; 532 cb_handle_t *cb = (cb_handle_t *)handle; 533 if (!gr || !cb_handle_t::validate(cb)) { 534 ERR("gralloc_register_buffer(%p): invalid buffer", cb); 535 return -EINVAL; 536 } 537 538 if (cb->hostHandle != 0) { 539 DEFINE_AND_VALIDATE_HOST_CONNECTION; 540 D("Opening host ColorBuffer 0x%x\n", cb->hostHandle); 541 rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle); 542 } 543 544 // 545 // if the color buffer has ashmem region and it is not mapped in this 546 // process map it now. 547 // 548 if (cb->ashmemSize > 0 && cb->mappedPid != getpid()) { 549 void *vaddr; 550 int err = map_buffer(cb, &vaddr); 551 if (err) { 552 ERR("gralloc_register_buffer(%p): map failed: %s", cb, strerror(-err)); 553 return -err; 554 } 555 cb->mappedPid = getpid(); 556 } 557 558 return 0; 559 } 560 561 static int gralloc_unregister_buffer(gralloc_module_t const* module, 562 buffer_handle_t handle) 563 { 564 if (sFallback != NULL) { 565 return sFallback->unregisterBuffer(sFallback, handle); 566 } 567 568 private_module_t *gr = (private_module_t *)module; 569 cb_handle_t *cb = (cb_handle_t *)handle; 570 if (!gr || !cb_handle_t::validate(cb)) { 571 ERR("gralloc_unregister_buffer(%p): invalid buffer", cb); 572 return -EINVAL; 573 } 574 575 if (cb->hostHandle != 0) { 576 DEFINE_AND_VALIDATE_HOST_CONNECTION; 577 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle); 578 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle); 579 } 580 581 // 582 // unmap ashmem region if it was previously mapped in this process 583 // (through register_buffer) 584 // 585 if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) { 586 void *vaddr; 587 int err = munmap((void *)cb->ashmemBase, cb->ashmemSize); 588 if (err) { 589 ERR("gralloc_unregister_buffer(%p): unmap failed", cb); 590 return -EINVAL; 591 } 592 cb->ashmemBase = 0; 593 cb->mappedPid = 0; 594 } 595 596 D("gralloc_unregister_buffer(%p) done\n", cb); 597 598 return 0; 599 } 600 601 static int gralloc_lock(gralloc_module_t const* module, 602 buffer_handle_t handle, int usage, 603 int l, int t, int w, int h, 604 void** vaddr) 605 { 606 if (sFallback != NULL) { 607 return sFallback->lock(sFallback, handle, usage, l, t, w, h, vaddr); 608 } 609 610 private_module_t *gr = (private_module_t *)module; 611 cb_handle_t *cb = (cb_handle_t *)handle; 612 if (!gr || !cb_handle_t::validate(cb)) { 613 ALOGE("gralloc_lock bad handle\n"); 614 return -EINVAL; 615 } 616 617 // validate format 618 if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) { 619 ALOGE("gralloc_lock can't be used with YCbCr_420_888 format"); 620 return -EINVAL; 621 } 622 623 // Validate usage, 624 // 1. cannot be locked for hw access 625 // 2. lock for either sw read or write. 626 // 3. locked sw access must match usage during alloc time. 627 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); 628 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK)); 629 bool hw_read = (usage & GRALLOC_USAGE_HW_TEXTURE); 630 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER); 631 bool hw_vid_enc_read = (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER); 632 bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE); 633 bool hw_cam_read = (usage & GRALLOC_USAGE_HW_CAMERA_READ); 634 bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK)); 635 bool sw_write_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_WRITE_MASK)); 636 637 if ( (hw_read || hw_write) || 638 (!sw_read && !sw_write && 639 !hw_cam_write && !hw_cam_read && 640 !hw_vid_enc_read) || 641 (sw_read && !sw_read_allowed) || 642 (sw_write && !sw_write_allowed) ) { 643 ALOGE("gralloc_lock usage mismatch usage=0x%x cb->usage=0x%x\n", usage, 644 cb->usage); 645 return -EINVAL; 646 } 647 648 intptr_t postCount = 0; 649 void *cpu_addr = NULL; 650 651 // 652 // make sure ashmem area is mapped if needed 653 // 654 if (cb->canBePosted() || sw_read || sw_write || 655 hw_cam_write || hw_cam_read || 656 hw_vid_enc_read) { 657 if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) { 658 return -EACCES; 659 } 660 661 if (cb->canBePosted()) { 662 postCount = *((intptr_t *)cb->ashmemBase); 663 cpu_addr = (void *)(cb->ashmemBase + sizeof(intptr_t)); 664 } 665 else { 666 cpu_addr = (void *)(cb->ashmemBase); 667 } 668 } 669 670 if (cb->hostHandle) { 671 // Make sure we have host connection 672 DEFINE_AND_VALIDATE_HOST_CONNECTION; 673 674 // 675 // flush color buffer write cache on host and get its sync status. 676 // 677 int hostSyncStatus = rcEnc->rcColorBufferCacheFlush(rcEnc, cb->hostHandle, 678 postCount, 679 sw_read); 680 if (hostSyncStatus < 0) { 681 // host failed the color buffer sync - probably since it was already 682 // locked for write access. fail the lock. 683 ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n", 684 postCount, sw_read); 685 return -EBUSY; 686 } 687 688 if (sw_read) { 689 D("gralloc_lock read back color buffer %d %d\n", cb->width, cb->height); 690 rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle, 691 0, 0, cb->width, cb->height, GL_RGBA, GL_UNSIGNED_BYTE, cpu_addr); 692 } 693 } 694 695 // 696 // is virtual address required ? 697 // 698 if (sw_read || sw_write || hw_cam_write || hw_cam_read || hw_vid_enc_read) { 699 *vaddr = cpu_addr; 700 } 701 702 if (sw_write || hw_cam_write) { 703 // 704 // Keep locked region if locked for s/w write access. 705 // 706 cb->lockedLeft = l; 707 cb->lockedTop = t; 708 cb->lockedWidth = w; 709 cb->lockedHeight = h; 710 } 711 712 DD("gralloc_lock success. vaddr: %p, *vaddr: %p, usage: %x, cpu_addr: %p", 713 vaddr, vaddr ? *vaddr : 0, usage, cpu_addr); 714 715 return 0; 716 } 717 718 static int gralloc_unlock(gralloc_module_t const* module, 719 buffer_handle_t handle) 720 { 721 if (sFallback != NULL) { 722 return sFallback->unlock(sFallback, handle); 723 } 724 725 private_module_t *gr = (private_module_t *)module; 726 cb_handle_t *cb = (cb_handle_t *)handle; 727 if (!gr || !cb_handle_t::validate(cb)) { 728 return -EINVAL; 729 } 730 731 // 732 // if buffer was locked for s/w write, we need to update the host with 733 // the updated data 734 // 735 if (cb->hostHandle) { 736 737 // Make sure we have host connection 738 DEFINE_AND_VALIDATE_HOST_CONNECTION; 739 740 void *cpu_addr; 741 if (cb->canBePosted()) { 742 cpu_addr = (void *)(cb->ashmemBase + sizeof(int)); 743 } 744 else { 745 cpu_addr = (void *)(cb->ashmemBase); 746 } 747 748 if (cb->lockedWidth < cb->width || cb->lockedHeight < cb->height) { 749 int bpp = glUtilsPixelBitSize(cb->glFormat, cb->glType) >> 3; 750 char *tmpBuf = new char[cb->lockedWidth * cb->lockedHeight * bpp]; 751 752 int dst_line_len = cb->lockedWidth * bpp; 753 int src_line_len = cb->width * bpp; 754 char *src = (char *)cpu_addr + cb->lockedTop*src_line_len + cb->lockedLeft*bpp; 755 char *dst = tmpBuf; 756 for (int y=0; y<cb->lockedHeight; y++) { 757 memcpy(dst, src, dst_line_len); 758 src += src_line_len; 759 dst += dst_line_len; 760 } 761 762 rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, 763 cb->lockedLeft, cb->lockedTop, 764 cb->lockedWidth, cb->lockedHeight, 765 cb->glFormat, cb->glType, 766 tmpBuf); 767 768 delete [] tmpBuf; 769 } 770 else { 771 rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, 0, 0, 772 cb->width, cb->height, 773 cb->glFormat, cb->glType, 774 cpu_addr); 775 } 776 } 777 778 cb->lockedWidth = cb->lockedHeight = 0; 779 return 0; 780 } 781 782 static int gralloc_lock_ycbcr(gralloc_module_t const* module, 783 buffer_handle_t handle, int usage, 784 int l, int t, int w, int h, 785 android_ycbcr *ycbcr) 786 { 787 // Not supporting fallback module for YCbCr 788 if (sFallback != NULL) { 789 return -EINVAL; 790 } 791 792 if (!ycbcr) { 793 ALOGE("gralloc_lock_ycbcr got NULL ycbcr struct"); 794 return -EINVAL; 795 } 796 797 private_module_t *gr = (private_module_t *)module; 798 cb_handle_t *cb = (cb_handle_t *)handle; 799 if (!gr || !cb_handle_t::validate(cb)) { 800 ALOGE("gralloc_lock_ycbcr bad handle\n"); 801 return -EINVAL; 802 } 803 804 if (cb->frameworkFormat != HAL_PIXEL_FORMAT_YCbCr_420_888) { 805 ALOGE("gralloc_lock_ycbcr can only be used with " 806 "HAL_PIXEL_FORMAT_YCbCr_420_888, got %x instead", 807 cb->frameworkFormat); 808 return -EINVAL; 809 } 810 811 // Validate usage 812 // For now, only allow camera write, software read. 813 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); 814 bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE); 815 bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK)); 816 817 if ( (!hw_cam_write && !sw_read) || 818 (sw_read && !sw_read_allowed) ) { 819 ALOGE("gralloc_lock_ycbcr usage mismatch usage:0x%x cb->usage:0x%x\n", 820 usage, cb->usage); 821 return -EINVAL; 822 } 823 824 // Make sure memory is mapped, get address 825 if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) { 826 return -EACCES; 827 } 828 829 uint8_t *cpu_addr = NULL; 830 831 if (cb->canBePosted()) { 832 cpu_addr = (uint8_t *)(cb->ashmemBase + sizeof(int)); 833 } 834 else { 835 cpu_addr = (uint8_t *)(cb->ashmemBase); 836 } 837 838 // Calculate offsets to underlying YUV data 839 size_t yStride; 840 size_t cStride; 841 size_t yOffset; 842 size_t uOffset; 843 size_t vOffset; 844 size_t cStep; 845 switch (cb->format) { 846 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 847 yStride = cb->width; 848 cStride = cb->width; 849 yOffset = 0; 850 vOffset = yStride * cb->height; 851 uOffset = vOffset + 1; 852 cStep = 2; 853 break; 854 default: 855 ALOGE("gralloc_lock_ycbcr unexpected internal format %x", 856 cb->format); 857 return -EINVAL; 858 } 859 860 ycbcr->y = cpu_addr + yOffset; 861 ycbcr->cb = cpu_addr + uOffset; 862 ycbcr->cr = cpu_addr + vOffset; 863 ycbcr->ystride = yStride; 864 ycbcr->cstride = cStride; 865 ycbcr->chroma_step = cStep; 866 867 // Zero out reserved fields 868 memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved)); 869 870 // 871 // Keep locked region if locked for s/w write access. 872 // 873 cb->lockedLeft = l; 874 cb->lockedTop = t; 875 cb->lockedWidth = w; 876 cb->lockedHeight = h; 877 878 DD("gralloc_lock_ycbcr success. usage: %x, ycbcr.y: %p, .cb: %p, .cr: %p, " 879 ".ystride: %d , .cstride: %d, .chroma_step: %d", usage, 880 ycbcr->y, ycbcr->cb, ycbcr->cr, ycbcr->ystride, ycbcr->cstride, 881 ycbcr->chroma_step); 882 883 return 0; 884 } 885 886 static int gralloc_device_open(const hw_module_t* module, 887 const char* name, 888 hw_device_t** device) 889 { 890 int status = -EINVAL; 891 892 D("gralloc_device_open %s\n", name); 893 894 pthread_once( &sFallbackOnce, fallback_init ); 895 if (sFallback != NULL) { 896 return sFallback->common.methods->open(&sFallback->common, name, device); 897 } 898 899 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) { 900 901 // Create host connection and keep it in the TLS. 902 // return error if connection with host can not be established 903 HostConnection *hostCon = HostConnection::get(); 904 if (!hostCon) { 905 ALOGE("gralloc: failed to get host connection while opening %s\n", name); 906 return -EIO; 907 } 908 909 // 910 // Allocate memory for the gralloc device (alloc interface) 911 // 912 gralloc_device_t *dev; 913 dev = (gralloc_device_t*)malloc(sizeof(gralloc_device_t)); 914 if (NULL == dev) { 915 return -ENOMEM; 916 } 917 918 // Initialize our device structure 919 // 920 dev->device.common.tag = HARDWARE_DEVICE_TAG; 921 dev->device.common.version = 0; 922 dev->device.common.module = const_cast<hw_module_t*>(module); 923 dev->device.common.close = gralloc_device_close; 924 925 dev->device.alloc = gralloc_alloc; 926 dev->device.free = gralloc_free; 927 dev->allocListHead = NULL; 928 pthread_mutex_init(&dev->lock, NULL); 929 930 *device = &dev->device.common; 931 status = 0; 932 } 933 else if (!strcmp(name, GRALLOC_HARDWARE_FB0)) { 934 935 // return error if connection with host can not be established 936 DEFINE_AND_VALIDATE_HOST_CONNECTION; 937 938 // 939 // Query the host for Framebuffer attributes 940 // 941 D("gralloc: query Frabuffer attribs\n"); 942 EGLint width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH); 943 D("gralloc: width=%d\n", width); 944 EGLint height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT); 945 D("gralloc: height=%d\n", height); 946 EGLint xdpi = rcEnc->rcGetFBParam(rcEnc, FB_XDPI); 947 D("gralloc: xdpi=%d\n", xdpi); 948 EGLint ydpi = rcEnc->rcGetFBParam(rcEnc, FB_YDPI); 949 D("gralloc: ydpi=%d\n", ydpi); 950 EGLint fps = rcEnc->rcGetFBParam(rcEnc, FB_FPS); 951 D("gralloc: fps=%d\n", fps); 952 EGLint min_si = rcEnc->rcGetFBParam(rcEnc, FB_MIN_SWAP_INTERVAL); 953 D("gralloc: min_swap=%d\n", min_si); 954 EGLint max_si = rcEnc->rcGetFBParam(rcEnc, FB_MAX_SWAP_INTERVAL); 955 D("gralloc: max_swap=%d\n", max_si); 956 957 // 958 // Allocate memory for the framebuffer device 959 // 960 fb_device_t *dev; 961 dev = (fb_device_t*)malloc(sizeof(fb_device_t)); 962 if (NULL == dev) { 963 return -ENOMEM; 964 } 965 memset(dev, 0, sizeof(fb_device_t)); 966 967 // Initialize our device structure 968 // 969 dev->device.common.tag = HARDWARE_DEVICE_TAG; 970 dev->device.common.version = 0; 971 dev->device.common.module = const_cast<hw_module_t*>(module); 972 dev->device.common.close = fb_close; 973 dev->device.setSwapInterval = fb_setSwapInterval; 974 dev->device.post = fb_post; 975 dev->device.setUpdateRect = 0; //fb_setUpdateRect; 976 dev->device.compositionComplete = fb_compositionComplete; //XXX: this is a dummy 977 978 const_cast<uint32_t&>(dev->device.flags) = 0; 979 const_cast<uint32_t&>(dev->device.width) = width; 980 const_cast<uint32_t&>(dev->device.height) = height; 981 const_cast<int&>(dev->device.stride) = width; 982 const_cast<int&>(dev->device.format) = HAL_PIXEL_FORMAT_RGBA_8888; 983 const_cast<float&>(dev->device.xdpi) = xdpi; 984 const_cast<float&>(dev->device.ydpi) = ydpi; 985 const_cast<float&>(dev->device.fps) = fps; 986 const_cast<int&>(dev->device.minSwapInterval) = min_si; 987 const_cast<int&>(dev->device.maxSwapInterval) = max_si; 988 *device = &dev->device.common; 989 990 status = 0; 991 } 992 993 return status; 994 } 995 996 // 997 // define the HMI symbol - our module interface 998 // 999 static struct hw_module_methods_t gralloc_module_methods = { 1000 open: gralloc_device_open 1001 }; 1002 1003 struct private_module_t HAL_MODULE_INFO_SYM = { 1004 base: { 1005 common: { 1006 tag: HARDWARE_MODULE_TAG, 1007 module_api_version: GRALLOC_MODULE_API_VERSION_0_2, 1008 hal_api_version: 0, 1009 id: GRALLOC_HARDWARE_MODULE_ID, 1010 name: "Graphics Memory Allocator Module", 1011 author: "The Android Open Source Project", 1012 methods: &gralloc_module_methods, 1013 dso: NULL, 1014 reserved: {0, } 1015 }, 1016 registerBuffer: gralloc_register_buffer, 1017 unregisterBuffer: gralloc_unregister_buffer, 1018 lock: gralloc_lock, 1019 unlock: gralloc_unlock, 1020 perform: NULL, 1021 lock_ycbcr: gralloc_lock_ycbcr, 1022 } 1023 }; 1024 1025 /* This function is called once to detect whether the emulator supports 1026 * GPU emulation (this is done by looking at the qemu.gles kernel 1027 * parameter, which must be == 1 if this is the case). 1028 * 1029 * If not, then load gralloc.default instead as a fallback. 1030 */ 1031 static void 1032 fallback_init(void) 1033 { 1034 char prop[PROPERTY_VALUE_MAX]; 1035 void* module; 1036 1037 // qemu.gles=0 -> no GLES 2.x support (only 1.x through software). 1038 // qemu.gles=1 -> host-side GPU emulation through EmuGL 1039 // qemu.gles=2 -> guest-side GPU emulation. 1040 property_get("ro.kernel.qemu.gles", prop, "0"); 1041 if (atoi(prop) == 1) { 1042 return; 1043 } 1044 ALOGD("Emulator without host-side GPU emulation detected."); 1045 #if __LP64__ 1046 module = dlopen("/system/lib64/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL); 1047 #else 1048 module = dlopen("/system/lib/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL); 1049 #endif 1050 if (module != NULL) { 1051 sFallback = reinterpret_cast<gralloc_module_t*>(dlsym(module, HAL_MODULE_INFO_SYM_AS_STR)); 1052 if (sFallback == NULL) { 1053 dlclose(module); 1054 } 1055 } 1056 if (sFallback == NULL) { 1057 ALOGE("Could not find software fallback module!?"); 1058 } 1059 } 1060
