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