Surface.cpp revision 7895e90e29d096be039202f2ff24fa8033b92477
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "Surface" 18#define ATRACE_TAG ATRACE_TAG_GRAPHICS 19//#define LOG_NDEBUG 0 20 21#include <android/native_window.h> 22 23#include <binder/Parcel.h> 24 25#include <utils/Log.h> 26#include <utils/Trace.h> 27 28#include <ui/Fence.h> 29 30#include <gui/ISurfaceComposer.h> 31#include <gui/SurfaceComposerClient.h> 32#include <gui/GLConsumer.h> 33#include <gui/Surface.h> 34 35#include <private/gui/ComposerService.h> 36 37namespace android { 38 39Surface::Surface( 40 const sp<IGraphicBufferProducer>& bufferProducer, 41 bool controlledByApp) 42 : mGraphicBufferProducer(bufferProducer) 43{ 44 // Initialize the ANativeWindow function pointers. 45 ANativeWindow::setSwapInterval = hook_setSwapInterval; 46 ANativeWindow::dequeueBuffer = hook_dequeueBuffer; 47 ANativeWindow::cancelBuffer = hook_cancelBuffer; 48 ANativeWindow::queueBuffer = hook_queueBuffer; 49 ANativeWindow::query = hook_query; 50 ANativeWindow::perform = hook_perform; 51 52 ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED; 53 ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED; 54 ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED; 55 ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED; 56 57 const_cast<int&>(ANativeWindow::minSwapInterval) = 0; 58 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1; 59 60 mReqWidth = 0; 61 mReqHeight = 0; 62 mReqFormat = 0; 63 mReqUsage = 0; 64 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO; 65 mCrop.clear(); 66 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 67 mTransform = 0; 68 mDefaultWidth = 0; 69 mDefaultHeight = 0; 70 mUserWidth = 0; 71 mUserHeight = 0; 72 mTransformHint = 0; 73 mConsumerRunningBehind = false; 74 mConnectedToCpu = false; 75 mProducerControlledByApp = controlledByApp; 76 mSwapIntervalZero = false; 77} 78 79Surface::~Surface() { 80 if (mConnectedToCpu) { 81 Surface::disconnect(NATIVE_WINDOW_API_CPU); 82 } 83} 84 85sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const { 86 return mGraphicBufferProducer; 87} 88 89int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) { 90 Surface* c = getSelf(window); 91 return c->setSwapInterval(interval); 92} 93 94int Surface::hook_dequeueBuffer(ANativeWindow* window, 95 ANativeWindowBuffer** buffer, int* fenceFd) { 96 Surface* c = getSelf(window); 97 return c->dequeueBuffer(buffer, fenceFd); 98} 99 100int Surface::hook_cancelBuffer(ANativeWindow* window, 101 ANativeWindowBuffer* buffer, int fenceFd) { 102 Surface* c = getSelf(window); 103 return c->cancelBuffer(buffer, fenceFd); 104} 105 106int Surface::hook_queueBuffer(ANativeWindow* window, 107 ANativeWindowBuffer* buffer, int fenceFd) { 108 Surface* c = getSelf(window); 109 return c->queueBuffer(buffer, fenceFd); 110} 111 112int Surface::hook_dequeueBuffer_DEPRECATED(ANativeWindow* window, 113 ANativeWindowBuffer** buffer) { 114 Surface* c = getSelf(window); 115 ANativeWindowBuffer* buf; 116 int fenceFd = -1; 117 int result = c->dequeueBuffer(&buf, &fenceFd); 118 sp<Fence> fence(new Fence(fenceFd)); 119 int waitResult = fence->waitForever("dequeueBuffer_DEPRECATED"); 120 if (waitResult != OK) { 121 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an error: %d", 122 waitResult); 123 c->cancelBuffer(buf, -1); 124 return waitResult; 125 } 126 *buffer = buf; 127 return result; 128} 129 130int Surface::hook_cancelBuffer_DEPRECATED(ANativeWindow* window, 131 ANativeWindowBuffer* buffer) { 132 Surface* c = getSelf(window); 133 return c->cancelBuffer(buffer, -1); 134} 135 136int Surface::hook_lockBuffer_DEPRECATED(ANativeWindow* window, 137 ANativeWindowBuffer* buffer) { 138 Surface* c = getSelf(window); 139 return c->lockBuffer_DEPRECATED(buffer); 140} 141 142int Surface::hook_queueBuffer_DEPRECATED(ANativeWindow* window, 143 ANativeWindowBuffer* buffer) { 144 Surface* c = getSelf(window); 145 return c->queueBuffer(buffer, -1); 146} 147 148int Surface::hook_query(const ANativeWindow* window, 149 int what, int* value) { 150 const Surface* c = getSelf(window); 151 return c->query(what, value); 152} 153 154int Surface::hook_perform(ANativeWindow* window, int operation, ...) { 155 va_list args; 156 va_start(args, operation); 157 Surface* c = getSelf(window); 158 return c->perform(operation, args); 159} 160 161int Surface::setSwapInterval(int interval) { 162 ATRACE_CALL(); 163 // EGL specification states: 164 // interval is silently clamped to minimum and maximum implementation 165 // dependent values before being stored. 166 167 if (interval < minSwapInterval) 168 interval = minSwapInterval; 169 170 if (interval > maxSwapInterval) 171 interval = maxSwapInterval; 172 173 mSwapIntervalZero = (interval == 0); 174 175 return NO_ERROR; 176} 177 178int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { 179 ATRACE_CALL(); 180 ALOGV("Surface::dequeueBuffer"); 181 Mutex::Autolock lock(mMutex); 182 int buf = -1; 183 int reqW = mReqWidth ? mReqWidth : mUserWidth; 184 int reqH = mReqHeight ? mReqHeight : mUserHeight; 185 sp<Fence> fence; 186 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, mSwapIntervalZero, 187 reqW, reqH, mReqFormat, mReqUsage); 188 if (result < 0) { 189 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d)" 190 "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage, 191 result); 192 return result; 193 } 194 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer); 195 196 // this should never happen 197 ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf); 198 199 if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) { 200 freeAllBuffers(); 201 } 202 203 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) { 204 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf); 205 if (result != NO_ERROR) { 206 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result); 207 return result; 208 } 209 } 210 211 if (fence->isValid()) { 212 *fenceFd = fence->dup(); 213 if (*fenceFd == -1) { 214 ALOGE("dequeueBuffer: error duping fence: %d", errno); 215 // dup() should never fail; something is badly wrong. Soldier on 216 // and hope for the best; the worst that should happen is some 217 // visible corruption that lasts until the next frame. 218 } 219 } else { 220 *fenceFd = -1; 221 } 222 223 *buffer = gbuf.get(); 224 return OK; 225} 226 227int Surface::cancelBuffer(android_native_buffer_t* buffer, 228 int fenceFd) { 229 ATRACE_CALL(); 230 ALOGV("Surface::cancelBuffer"); 231 Mutex::Autolock lock(mMutex); 232 int i = getSlotFromBufferLocked(buffer); 233 if (i < 0) { 234 return i; 235 } 236 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 237 mGraphicBufferProducer->cancelBuffer(i, fence); 238 return OK; 239} 240 241int Surface::getSlotFromBufferLocked( 242 android_native_buffer_t* buffer) const { 243 bool dumpedState = false; 244 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 245 if (mSlots[i].buffer != NULL && 246 mSlots[i].buffer->handle == buffer->handle) { 247 return i; 248 } 249 } 250 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle); 251 return BAD_VALUE; 252} 253 254int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer) { 255 ALOGV("Surface::lockBuffer"); 256 Mutex::Autolock lock(mMutex); 257 return OK; 258} 259 260int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) { 261 ATRACE_CALL(); 262 ALOGV("Surface::queueBuffer"); 263 Mutex::Autolock lock(mMutex); 264 int64_t timestamp; 265 bool isAutoTimestamp = false; 266 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) { 267 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 268 isAutoTimestamp = true; 269 ALOGV("Surface::queueBuffer making up timestamp: %.2f ms", 270 timestamp / 1000000.f); 271 } else { 272 timestamp = mTimestamp; 273 } 274 int i = getSlotFromBufferLocked(buffer); 275 if (i < 0) { 276 return i; 277 } 278 279 280 // Make sure the crop rectangle is entirely inside the buffer. 281 Rect crop; 282 mCrop.intersect(Rect(buffer->width, buffer->height), &crop); 283 284 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 285 IGraphicBufferProducer::QueueBufferOutput output; 286 IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp, 287 crop, mScalingMode, mTransform, mSwapIntervalZero, fence); 288 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output); 289 if (err != OK) { 290 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err); 291 } 292 uint32_t numPendingBuffers = 0; 293 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint, 294 &numPendingBuffers); 295 296 mConsumerRunningBehind = (numPendingBuffers >= 2); 297 298 return err; 299} 300 301int Surface::query(int what, int* value) const { 302 ATRACE_CALL(); 303 ALOGV("Surface::query"); 304 { // scope for the lock 305 Mutex::Autolock lock(mMutex); 306 switch (what) { 307 case NATIVE_WINDOW_FORMAT: 308 if (mReqFormat) { 309 *value = mReqFormat; 310 return NO_ERROR; 311 } 312 break; 313 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: { 314 sp<ISurfaceComposer> composer( 315 ComposerService::getComposerService()); 316 if (composer->authenticateSurfaceTexture(mGraphicBufferProducer)) { 317 *value = 1; 318 } else { 319 *value = 0; 320 } 321 return NO_ERROR; 322 } 323 case NATIVE_WINDOW_CONCRETE_TYPE: 324 *value = NATIVE_WINDOW_SURFACE; 325 return NO_ERROR; 326 case NATIVE_WINDOW_DEFAULT_WIDTH: 327 *value = mUserWidth ? mUserWidth : mDefaultWidth; 328 return NO_ERROR; 329 case NATIVE_WINDOW_DEFAULT_HEIGHT: 330 *value = mUserHeight ? mUserHeight : mDefaultHeight; 331 return NO_ERROR; 332 case NATIVE_WINDOW_TRANSFORM_HINT: 333 *value = mTransformHint; 334 return NO_ERROR; 335 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: { 336 status_t err = NO_ERROR; 337 if (!mConsumerRunningBehind) { 338 *value = 0; 339 } else { 340 err = mGraphicBufferProducer->query(what, value); 341 if (err == NO_ERROR) { 342 mConsumerRunningBehind = *value; 343 } 344 } 345 return err; 346 } 347 } 348 } 349 return mGraphicBufferProducer->query(what, value); 350} 351 352int Surface::perform(int operation, va_list args) 353{ 354 int res = NO_ERROR; 355 switch (operation) { 356 case NATIVE_WINDOW_CONNECT: 357 // deprecated. must return NO_ERROR. 358 break; 359 case NATIVE_WINDOW_DISCONNECT: 360 // deprecated. must return NO_ERROR. 361 break; 362 case NATIVE_WINDOW_SET_USAGE: 363 res = dispatchSetUsage(args); 364 break; 365 case NATIVE_WINDOW_SET_CROP: 366 res = dispatchSetCrop(args); 367 break; 368 case NATIVE_WINDOW_SET_BUFFER_COUNT: 369 res = dispatchSetBufferCount(args); 370 break; 371 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 372 res = dispatchSetBuffersGeometry(args); 373 break; 374 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 375 res = dispatchSetBuffersTransform(args); 376 break; 377 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 378 res = dispatchSetBuffersTimestamp(args); 379 break; 380 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS: 381 res = dispatchSetBuffersDimensions(args); 382 break; 383 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS: 384 res = dispatchSetBuffersUserDimensions(args); 385 break; 386 case NATIVE_WINDOW_SET_BUFFERS_FORMAT: 387 res = dispatchSetBuffersFormat(args); 388 break; 389 case NATIVE_WINDOW_LOCK: 390 res = dispatchLock(args); 391 break; 392 case NATIVE_WINDOW_UNLOCK_AND_POST: 393 res = dispatchUnlockAndPost(args); 394 break; 395 case NATIVE_WINDOW_SET_SCALING_MODE: 396 res = dispatchSetScalingMode(args); 397 break; 398 case NATIVE_WINDOW_API_CONNECT: 399 res = dispatchConnect(args); 400 break; 401 case NATIVE_WINDOW_API_DISCONNECT: 402 res = dispatchDisconnect(args); 403 break; 404 default: 405 res = NAME_NOT_FOUND; 406 break; 407 } 408 return res; 409} 410 411int Surface::dispatchConnect(va_list args) { 412 int api = va_arg(args, int); 413 return connect(api); 414} 415 416int Surface::dispatchDisconnect(va_list args) { 417 int api = va_arg(args, int); 418 return disconnect(api); 419} 420 421int Surface::dispatchSetUsage(va_list args) { 422 int usage = va_arg(args, int); 423 return setUsage(usage); 424} 425 426int Surface::dispatchSetCrop(va_list args) { 427 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*); 428 return setCrop(reinterpret_cast<Rect const*>(rect)); 429} 430 431int Surface::dispatchSetBufferCount(va_list args) { 432 size_t bufferCount = va_arg(args, size_t); 433 return setBufferCount(bufferCount); 434} 435 436int Surface::dispatchSetBuffersGeometry(va_list args) { 437 int w = va_arg(args, int); 438 int h = va_arg(args, int); 439 int f = va_arg(args, int); 440 int err = setBuffersDimensions(w, h); 441 if (err != 0) { 442 return err; 443 } 444 return setBuffersFormat(f); 445} 446 447int Surface::dispatchSetBuffersDimensions(va_list args) { 448 int w = va_arg(args, int); 449 int h = va_arg(args, int); 450 return setBuffersDimensions(w, h); 451} 452 453int Surface::dispatchSetBuffersUserDimensions(va_list args) { 454 int w = va_arg(args, int); 455 int h = va_arg(args, int); 456 return setBuffersUserDimensions(w, h); 457} 458 459int Surface::dispatchSetBuffersFormat(va_list args) { 460 int f = va_arg(args, int); 461 return setBuffersFormat(f); 462} 463 464int Surface::dispatchSetScalingMode(va_list args) { 465 int m = va_arg(args, int); 466 return setScalingMode(m); 467} 468 469int Surface::dispatchSetBuffersTransform(va_list args) { 470 int transform = va_arg(args, int); 471 return setBuffersTransform(transform); 472} 473 474int Surface::dispatchSetBuffersTimestamp(va_list args) { 475 int64_t timestamp = va_arg(args, int64_t); 476 return setBuffersTimestamp(timestamp); 477} 478 479int Surface::dispatchLock(va_list args) { 480 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*); 481 ARect* inOutDirtyBounds = va_arg(args, ARect*); 482 return lock(outBuffer, inOutDirtyBounds); 483} 484 485int Surface::dispatchUnlockAndPost(va_list args) { 486 return unlockAndPost(); 487} 488 489 490int Surface::connect(int api) { 491 ATRACE_CALL(); 492 ALOGV("Surface::connect"); 493 Mutex::Autolock lock(mMutex); 494 IGraphicBufferProducer::QueueBufferOutput output; 495 int err = mGraphicBufferProducer->connect(api, mProducerControlledByApp, &output); 496 if (err == NO_ERROR) { 497 uint32_t numPendingBuffers = 0; 498 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint, 499 &numPendingBuffers); 500 mConsumerRunningBehind = (numPendingBuffers >= 2); 501 } 502 if (!err && api == NATIVE_WINDOW_API_CPU) { 503 mConnectedToCpu = true; 504 } 505 return err; 506} 507 508int Surface::disconnect(int api) { 509 ATRACE_CALL(); 510 ALOGV("Surface::disconnect"); 511 Mutex::Autolock lock(mMutex); 512 freeAllBuffers(); 513 int err = mGraphicBufferProducer->disconnect(api); 514 if (!err) { 515 mReqFormat = 0; 516 mReqWidth = 0; 517 mReqHeight = 0; 518 mReqUsage = 0; 519 mCrop.clear(); 520 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 521 mTransform = 0; 522 if (api == NATIVE_WINDOW_API_CPU) { 523 mConnectedToCpu = false; 524 } 525 } 526 return err; 527} 528 529int Surface::setUsage(uint32_t reqUsage) 530{ 531 ALOGV("Surface::setUsage"); 532 Mutex::Autolock lock(mMutex); 533 mReqUsage = reqUsage; 534 return OK; 535} 536 537int Surface::setCrop(Rect const* rect) 538{ 539 ATRACE_CALL(); 540 541 Rect realRect; 542 if (rect == NULL || rect->isEmpty()) { 543 realRect.clear(); 544 } else { 545 realRect = *rect; 546 } 547 548 ALOGV("Surface::setCrop rect=[%d %d %d %d]", 549 realRect.left, realRect.top, realRect.right, realRect.bottom); 550 551 Mutex::Autolock lock(mMutex); 552 mCrop = realRect; 553 return NO_ERROR; 554} 555 556int Surface::setBufferCount(int bufferCount) 557{ 558 ATRACE_CALL(); 559 ALOGV("Surface::setBufferCount"); 560 Mutex::Autolock lock(mMutex); 561 562 status_t err = mGraphicBufferProducer->setBufferCount(bufferCount); 563 ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s", 564 bufferCount, strerror(-err)); 565 566 if (err == NO_ERROR) { 567 freeAllBuffers(); 568 } 569 570 return err; 571} 572 573int Surface::setBuffersDimensions(int w, int h) 574{ 575 ATRACE_CALL(); 576 ALOGV("Surface::setBuffersDimensions"); 577 578 if (w<0 || h<0) 579 return BAD_VALUE; 580 581 if ((w && !h) || (!w && h)) 582 return BAD_VALUE; 583 584 Mutex::Autolock lock(mMutex); 585 mReqWidth = w; 586 mReqHeight = h; 587 return NO_ERROR; 588} 589 590int Surface::setBuffersUserDimensions(int w, int h) 591{ 592 ATRACE_CALL(); 593 ALOGV("Surface::setBuffersUserDimensions"); 594 595 if (w<0 || h<0) 596 return BAD_VALUE; 597 598 if ((w && !h) || (!w && h)) 599 return BAD_VALUE; 600 601 Mutex::Autolock lock(mMutex); 602 mUserWidth = w; 603 mUserHeight = h; 604 return NO_ERROR; 605} 606 607int Surface::setBuffersFormat(int format) 608{ 609 ALOGV("Surface::setBuffersFormat"); 610 611 if (format<0) 612 return BAD_VALUE; 613 614 Mutex::Autolock lock(mMutex); 615 mReqFormat = format; 616 return NO_ERROR; 617} 618 619int Surface::setScalingMode(int mode) 620{ 621 ATRACE_CALL(); 622 ALOGV("Surface::setScalingMode(%d)", mode); 623 624 switch (mode) { 625 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 626 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 627 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 628 break; 629 default: 630 ALOGE("unknown scaling mode: %d", mode); 631 return BAD_VALUE; 632 } 633 634 Mutex::Autolock lock(mMutex); 635 mScalingMode = mode; 636 return NO_ERROR; 637} 638 639int Surface::setBuffersTransform(int transform) 640{ 641 ATRACE_CALL(); 642 ALOGV("Surface::setBuffersTransform"); 643 Mutex::Autolock lock(mMutex); 644 mTransform = transform; 645 return NO_ERROR; 646} 647 648int Surface::setBuffersTimestamp(int64_t timestamp) 649{ 650 ALOGV("Surface::setBuffersTimestamp"); 651 Mutex::Autolock lock(mMutex); 652 mTimestamp = timestamp; 653 return NO_ERROR; 654} 655 656void Surface::freeAllBuffers() { 657 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 658 mSlots[i].buffer = 0; 659 } 660} 661 662// ---------------------------------------------------------------------- 663// the lock/unlock APIs must be used from the same thread 664 665static status_t copyBlt( 666 const sp<GraphicBuffer>& dst, 667 const sp<GraphicBuffer>& src, 668 const Region& reg) 669{ 670 // src and dst with, height and format must be identical. no verification 671 // is done here. 672 status_t err; 673 uint8_t const * src_bits = NULL; 674 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits); 675 ALOGE_IF(err, "error locking src buffer %s", strerror(-err)); 676 677 uint8_t* dst_bits = NULL; 678 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits); 679 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err)); 680 681 Region::const_iterator head(reg.begin()); 682 Region::const_iterator tail(reg.end()); 683 if (head != tail && src_bits && dst_bits) { 684 const size_t bpp = bytesPerPixel(src->format); 685 const size_t dbpr = dst->stride * bpp; 686 const size_t sbpr = src->stride * bpp; 687 688 while (head != tail) { 689 const Rect& r(*head++); 690 ssize_t h = r.height(); 691 if (h <= 0) continue; 692 size_t size = r.width() * bpp; 693 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp; 694 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp; 695 if (dbpr==sbpr && size==sbpr) { 696 size *= h; 697 h = 1; 698 } 699 do { 700 memcpy(d, s, size); 701 d += dbpr; 702 s += sbpr; 703 } while (--h > 0); 704 } 705 } 706 707 if (src_bits) 708 src->unlock(); 709 710 if (dst_bits) 711 dst->unlock(); 712 713 return err; 714} 715 716// ---------------------------------------------------------------------------- 717 718status_t Surface::lock( 719 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds) 720{ 721 if (mLockedBuffer != 0) { 722 ALOGE("Surface::lock failed, already locked"); 723 return INVALID_OPERATION; 724 } 725 726 if (!mConnectedToCpu) { 727 int err = Surface::connect(NATIVE_WINDOW_API_CPU); 728 if (err) { 729 return err; 730 } 731 // we're intending to do software rendering from this point 732 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); 733 } 734 735 ANativeWindowBuffer* out; 736 int fenceFd = -1; 737 status_t err = dequeueBuffer(&out, &fenceFd); 738 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err)); 739 if (err == NO_ERROR) { 740 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out)); 741 sp<Fence> fence(new Fence(fenceFd)); 742 743 err = fence->waitForever("Surface::lock"); 744 if (err != OK) { 745 ALOGE("Fence::wait failed (%s)", strerror(-err)); 746 cancelBuffer(out, fenceFd); 747 return err; 748 } 749 750 const Rect bounds(backBuffer->width, backBuffer->height); 751 752 Region newDirtyRegion; 753 if (inOutDirtyBounds) { 754 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds)); 755 newDirtyRegion.andSelf(bounds); 756 } else { 757 newDirtyRegion.set(bounds); 758 } 759 760 // figure out if we can copy the frontbuffer back 761 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer); 762 const bool canCopyBack = (frontBuffer != 0 && 763 backBuffer->width == frontBuffer->width && 764 backBuffer->height == frontBuffer->height && 765 backBuffer->format == frontBuffer->format); 766 767 if (canCopyBack) { 768 // copy the area that is invalid and not repainted this round 769 const Region copyback(mDirtyRegion.subtract(newDirtyRegion)); 770 if (!copyback.isEmpty()) 771 copyBlt(backBuffer, frontBuffer, copyback); 772 } else { 773 // if we can't copy-back anything, modify the user's dirty 774 // region to make sure they redraw the whole buffer 775 newDirtyRegion.set(bounds); 776 mDirtyRegion.clear(); 777 Mutex::Autolock lock(mMutex); 778 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) { 779 mSlots[i].dirtyRegion.clear(); 780 } 781 } 782 783 784 { // scope for the lock 785 Mutex::Autolock lock(mMutex); 786 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get())); 787 if (backBufferSlot >= 0) { 788 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion); 789 mDirtyRegion.subtract(dirtyRegion); 790 dirtyRegion = newDirtyRegion; 791 } 792 } 793 794 mDirtyRegion.orSelf(newDirtyRegion); 795 if (inOutDirtyBounds) { 796 *inOutDirtyBounds = newDirtyRegion.getBounds(); 797 } 798 799 void* vaddr; 800 status_t res = backBuffer->lock( 801 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, 802 newDirtyRegion.bounds(), &vaddr); 803 804 ALOGW_IF(res, "failed locking buffer (handle = %p)", 805 backBuffer->handle); 806 807 if (res != 0) { 808 err = INVALID_OPERATION; 809 } else { 810 mLockedBuffer = backBuffer; 811 outBuffer->width = backBuffer->width; 812 outBuffer->height = backBuffer->height; 813 outBuffer->stride = backBuffer->stride; 814 outBuffer->format = backBuffer->format; 815 outBuffer->bits = vaddr; 816 } 817 } 818 return err; 819} 820 821status_t Surface::unlockAndPost() 822{ 823 if (mLockedBuffer == 0) { 824 ALOGE("Surface::unlockAndPost failed, no locked buffer"); 825 return INVALID_OPERATION; 826 } 827 828 status_t err = mLockedBuffer->unlock(); 829 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle); 830 831 err = queueBuffer(mLockedBuffer.get(), -1); 832 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)", 833 mLockedBuffer->handle, strerror(-err)); 834 835 mPostedBuffer = mLockedBuffer; 836 mLockedBuffer = 0; 837 return err; 838} 839 840}; // namespace android 841