Surface.cpp revision 7cdd786fa80cf03551291ae8feca7b77583be1c5
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 = true; 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, 179 int* fenceFd) { 180 ATRACE_CALL(); 181 ALOGV("Surface::dequeueBuffer"); 182 Mutex::Autolock lock(mMutex); 183 int buf = -1; 184 int reqW = mReqWidth ? mReqWidth : mUserWidth; 185 int reqH = mReqHeight ? mReqHeight : mUserHeight; 186 sp<Fence> fence; 187 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, mSwapIntervalZero, 188 reqW, reqH, mReqFormat, mReqUsage); 189 if (result < 0) { 190 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d)" 191 "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage, 192 result); 193 return result; 194 } 195 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer); 196 if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) { 197 freeAllBuffers(); 198 } 199 200 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) { 201 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf); 202 if (result != NO_ERROR) { 203 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", 204 result); 205 return result; 206 } 207 } 208 209 if (fence->isValid()) { 210 *fenceFd = fence->dup(); 211 if (*fenceFd == -1) { 212 ALOGE("dequeueBuffer: error duping fence: %d", errno); 213 // dup() should never fail; something is badly wrong. Soldier on 214 // and hope for the best; the worst that should happen is some 215 // visible corruption that lasts until the next frame. 216 } 217 } else { 218 *fenceFd = -1; 219 } 220 221 *buffer = gbuf.get(); 222 return OK; 223} 224 225int Surface::cancelBuffer(android_native_buffer_t* buffer, 226 int fenceFd) { 227 ATRACE_CALL(); 228 ALOGV("Surface::cancelBuffer"); 229 Mutex::Autolock lock(mMutex); 230 int i = getSlotFromBufferLocked(buffer); 231 if (i < 0) { 232 return i; 233 } 234 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 235 mGraphicBufferProducer->cancelBuffer(i, fence); 236 return OK; 237} 238 239int Surface::getSlotFromBufferLocked( 240 android_native_buffer_t* buffer) const { 241 bool dumpedState = false; 242 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 243 if (mSlots[i].buffer != NULL && 244 mSlots[i].buffer->handle == buffer->handle) { 245 return i; 246 } 247 } 248 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle); 249 return BAD_VALUE; 250} 251 252int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer) { 253 ALOGV("Surface::lockBuffer"); 254 Mutex::Autolock lock(mMutex); 255 return OK; 256} 257 258int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) { 259 ATRACE_CALL(); 260 ALOGV("Surface::queueBuffer"); 261 Mutex::Autolock lock(mMutex); 262 int64_t timestamp; 263 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) { 264 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 265 ALOGV("Surface::queueBuffer making up timestamp: %.2f ms", 266 timestamp / 1000000.f); 267 } else { 268 timestamp = mTimestamp; 269 } 270 int i = getSlotFromBufferLocked(buffer); 271 if (i < 0) { 272 return i; 273 } 274 275 276 // Make sure the crop rectangle is entirely inside the buffer. 277 Rect crop; 278 mCrop.intersect(Rect(buffer->width, buffer->height), &crop); 279 280 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 281 IGraphicBufferProducer::QueueBufferOutput output; 282 IGraphicBufferProducer::QueueBufferInput input(timestamp, crop, mScalingMode, 283 mTransform, mSwapIntervalZero, fence); 284 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output); 285 if (err != OK) { 286 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err); 287 } 288 uint32_t numPendingBuffers = 0; 289 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint, 290 &numPendingBuffers); 291 292 mConsumerRunningBehind = (numPendingBuffers >= 2); 293 294 return err; 295} 296 297int Surface::query(int what, int* value) const { 298 ATRACE_CALL(); 299 ALOGV("Surface::query"); 300 { // scope for the lock 301 Mutex::Autolock lock(mMutex); 302 switch (what) { 303 case NATIVE_WINDOW_FORMAT: 304 if (mReqFormat) { 305 *value = mReqFormat; 306 return NO_ERROR; 307 } 308 break; 309 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: { 310 sp<ISurfaceComposer> composer( 311 ComposerService::getComposerService()); 312 if (composer->authenticateSurfaceTexture(mGraphicBufferProducer)) { 313 *value = 1; 314 } else { 315 *value = 0; 316 } 317 return NO_ERROR; 318 } 319 case NATIVE_WINDOW_CONCRETE_TYPE: 320 *value = NATIVE_WINDOW_SURFACE; 321 return NO_ERROR; 322 case NATIVE_WINDOW_DEFAULT_WIDTH: 323 *value = mUserWidth ? mUserWidth : mDefaultWidth; 324 return NO_ERROR; 325 case NATIVE_WINDOW_DEFAULT_HEIGHT: 326 *value = mUserHeight ? mUserHeight : mDefaultHeight; 327 return NO_ERROR; 328 case NATIVE_WINDOW_TRANSFORM_HINT: 329 *value = mTransformHint; 330 return NO_ERROR; 331 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: { 332 status_t err = NO_ERROR; 333 if (!mConsumerRunningBehind) { 334 *value = 0; 335 } else { 336 err = mGraphicBufferProducer->query(what, value); 337 if (err == NO_ERROR) { 338 mConsumerRunningBehind = *value; 339 } 340 } 341 return err; 342 } 343 } 344 } 345 return mGraphicBufferProducer->query(what, value); 346} 347 348int Surface::perform(int operation, va_list args) 349{ 350 int res = NO_ERROR; 351 switch (operation) { 352 case NATIVE_WINDOW_CONNECT: 353 // deprecated. must return NO_ERROR. 354 break; 355 case NATIVE_WINDOW_DISCONNECT: 356 // deprecated. must return NO_ERROR. 357 break; 358 case NATIVE_WINDOW_SET_USAGE: 359 res = dispatchSetUsage(args); 360 break; 361 case NATIVE_WINDOW_SET_CROP: 362 res = dispatchSetCrop(args); 363 break; 364 case NATIVE_WINDOW_SET_BUFFER_COUNT: 365 res = dispatchSetBufferCount(args); 366 break; 367 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 368 res = dispatchSetBuffersGeometry(args); 369 break; 370 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 371 res = dispatchSetBuffersTransform(args); 372 break; 373 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 374 res = dispatchSetBuffersTimestamp(args); 375 break; 376 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS: 377 res = dispatchSetBuffersDimensions(args); 378 break; 379 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS: 380 res = dispatchSetBuffersUserDimensions(args); 381 break; 382 case NATIVE_WINDOW_SET_BUFFERS_FORMAT: 383 res = dispatchSetBuffersFormat(args); 384 break; 385 case NATIVE_WINDOW_LOCK: 386 res = dispatchLock(args); 387 break; 388 case NATIVE_WINDOW_UNLOCK_AND_POST: 389 res = dispatchUnlockAndPost(args); 390 break; 391 case NATIVE_WINDOW_SET_SCALING_MODE: 392 res = dispatchSetScalingMode(args); 393 break; 394 case NATIVE_WINDOW_API_CONNECT: 395 res = dispatchConnect(args); 396 break; 397 case NATIVE_WINDOW_API_DISCONNECT: 398 res = dispatchDisconnect(args); 399 break; 400 default: 401 res = NAME_NOT_FOUND; 402 break; 403 } 404 return res; 405} 406 407int Surface::dispatchConnect(va_list args) { 408 int api = va_arg(args, int); 409 return connect(api); 410} 411 412int Surface::dispatchDisconnect(va_list args) { 413 int api = va_arg(args, int); 414 return disconnect(api); 415} 416 417int Surface::dispatchSetUsage(va_list args) { 418 int usage = va_arg(args, int); 419 return setUsage(usage); 420} 421 422int Surface::dispatchSetCrop(va_list args) { 423 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*); 424 return setCrop(reinterpret_cast<Rect const*>(rect)); 425} 426 427int Surface::dispatchSetBufferCount(va_list args) { 428 size_t bufferCount = va_arg(args, size_t); 429 return setBufferCount(bufferCount); 430} 431 432int Surface::dispatchSetBuffersGeometry(va_list args) { 433 int w = va_arg(args, int); 434 int h = va_arg(args, int); 435 int f = va_arg(args, int); 436 int err = setBuffersDimensions(w, h); 437 if (err != 0) { 438 return err; 439 } 440 return setBuffersFormat(f); 441} 442 443int Surface::dispatchSetBuffersDimensions(va_list args) { 444 int w = va_arg(args, int); 445 int h = va_arg(args, int); 446 return setBuffersDimensions(w, h); 447} 448 449int Surface::dispatchSetBuffersUserDimensions(va_list args) { 450 int w = va_arg(args, int); 451 int h = va_arg(args, int); 452 return setBuffersUserDimensions(w, h); 453} 454 455int Surface::dispatchSetBuffersFormat(va_list args) { 456 int f = va_arg(args, int); 457 return setBuffersFormat(f); 458} 459 460int Surface::dispatchSetScalingMode(va_list args) { 461 int m = va_arg(args, int); 462 return setScalingMode(m); 463} 464 465int Surface::dispatchSetBuffersTransform(va_list args) { 466 int transform = va_arg(args, int); 467 return setBuffersTransform(transform); 468} 469 470int Surface::dispatchSetBuffersTimestamp(va_list args) { 471 int64_t timestamp = va_arg(args, int64_t); 472 return setBuffersTimestamp(timestamp); 473} 474 475int Surface::dispatchLock(va_list args) { 476 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*); 477 ARect* inOutDirtyBounds = va_arg(args, ARect*); 478 return lock(outBuffer, inOutDirtyBounds); 479} 480 481int Surface::dispatchUnlockAndPost(va_list args) { 482 return unlockAndPost(); 483} 484 485 486int Surface::connect(int api) { 487 ATRACE_CALL(); 488 ALOGV("Surface::connect"); 489 Mutex::Autolock lock(mMutex); 490 IGraphicBufferProducer::QueueBufferOutput output; 491 int err = mGraphicBufferProducer->connect(api, mProducerControlledByApp, &output); 492 if (err == NO_ERROR) { 493 uint32_t numPendingBuffers = 0; 494 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint, 495 &numPendingBuffers); 496 mConsumerRunningBehind = (numPendingBuffers >= 2); 497 } 498 if (!err && api == NATIVE_WINDOW_API_CPU) { 499 mConnectedToCpu = true; 500 } 501 return err; 502} 503 504int Surface::disconnect(int api) { 505 ATRACE_CALL(); 506 ALOGV("Surface::disconnect"); 507 Mutex::Autolock lock(mMutex); 508 freeAllBuffers(); 509 int err = mGraphicBufferProducer->disconnect(api); 510 if (!err) { 511 mReqFormat = 0; 512 mReqWidth = 0; 513 mReqHeight = 0; 514 mReqUsage = 0; 515 mCrop.clear(); 516 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 517 mTransform = 0; 518 if (api == NATIVE_WINDOW_API_CPU) { 519 mConnectedToCpu = false; 520 } 521 } 522 return err; 523} 524 525int Surface::setUsage(uint32_t reqUsage) 526{ 527 ALOGV("Surface::setUsage"); 528 Mutex::Autolock lock(mMutex); 529 mReqUsage = reqUsage; 530 return OK; 531} 532 533int Surface::setCrop(Rect const* rect) 534{ 535 ATRACE_CALL(); 536 537 Rect realRect; 538 if (rect == NULL || rect->isEmpty()) { 539 realRect.clear(); 540 } else { 541 realRect = *rect; 542 } 543 544 ALOGV("Surface::setCrop rect=[%d %d %d %d]", 545 realRect.left, realRect.top, realRect.right, realRect.bottom); 546 547 Mutex::Autolock lock(mMutex); 548 mCrop = realRect; 549 return NO_ERROR; 550} 551 552int Surface::setBufferCount(int bufferCount) 553{ 554 ATRACE_CALL(); 555 ALOGV("Surface::setBufferCount"); 556 Mutex::Autolock lock(mMutex); 557 558 status_t err = mGraphicBufferProducer->setBufferCount(bufferCount); 559 ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s", 560 bufferCount, strerror(-err)); 561 562 if (err == NO_ERROR) { 563 freeAllBuffers(); 564 } 565 566 return err; 567} 568 569int Surface::setBuffersDimensions(int w, int h) 570{ 571 ATRACE_CALL(); 572 ALOGV("Surface::setBuffersDimensions"); 573 574 if (w<0 || h<0) 575 return BAD_VALUE; 576 577 if ((w && !h) || (!w && h)) 578 return BAD_VALUE; 579 580 Mutex::Autolock lock(mMutex); 581 mReqWidth = w; 582 mReqHeight = h; 583 return NO_ERROR; 584} 585 586int Surface::setBuffersUserDimensions(int w, int h) 587{ 588 ATRACE_CALL(); 589 ALOGV("Surface::setBuffersUserDimensions"); 590 591 if (w<0 || h<0) 592 return BAD_VALUE; 593 594 if ((w && !h) || (!w && h)) 595 return BAD_VALUE; 596 597 Mutex::Autolock lock(mMutex); 598 mUserWidth = w; 599 mUserHeight = h; 600 return NO_ERROR; 601} 602 603int Surface::setBuffersFormat(int format) 604{ 605 ALOGV("Surface::setBuffersFormat"); 606 607 if (format<0) 608 return BAD_VALUE; 609 610 Mutex::Autolock lock(mMutex); 611 mReqFormat = format; 612 return NO_ERROR; 613} 614 615int Surface::setScalingMode(int mode) 616{ 617 ATRACE_CALL(); 618 ALOGV("Surface::setScalingMode(%d)", mode); 619 620 switch (mode) { 621 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 622 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 623 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 624 break; 625 default: 626 ALOGE("unknown scaling mode: %d", mode); 627 return BAD_VALUE; 628 } 629 630 Mutex::Autolock lock(mMutex); 631 mScalingMode = mode; 632 return NO_ERROR; 633} 634 635int Surface::setBuffersTransform(int transform) 636{ 637 ATRACE_CALL(); 638 ALOGV("Surface::setBuffersTransform"); 639 Mutex::Autolock lock(mMutex); 640 mTransform = transform; 641 return NO_ERROR; 642} 643 644int Surface::setBuffersTimestamp(int64_t timestamp) 645{ 646 ALOGV("Surface::setBuffersTimestamp"); 647 Mutex::Autolock lock(mMutex); 648 mTimestamp = timestamp; 649 return NO_ERROR; 650} 651 652void Surface::freeAllBuffers() { 653 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 654 mSlots[i].buffer = 0; 655 } 656} 657 658// ---------------------------------------------------------------------- 659// the lock/unlock APIs must be used from the same thread 660 661static status_t copyBlt( 662 const sp<GraphicBuffer>& dst, 663 const sp<GraphicBuffer>& src, 664 const Region& reg) 665{ 666 // src and dst with, height and format must be identical. no verification 667 // is done here. 668 status_t err; 669 uint8_t const * src_bits = NULL; 670 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits); 671 ALOGE_IF(err, "error locking src buffer %s", strerror(-err)); 672 673 uint8_t* dst_bits = NULL; 674 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits); 675 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err)); 676 677 Region::const_iterator head(reg.begin()); 678 Region::const_iterator tail(reg.end()); 679 if (head != tail && src_bits && dst_bits) { 680 const size_t bpp = bytesPerPixel(src->format); 681 const size_t dbpr = dst->stride * bpp; 682 const size_t sbpr = src->stride * bpp; 683 684 while (head != tail) { 685 const Rect& r(*head++); 686 ssize_t h = r.height(); 687 if (h <= 0) continue; 688 size_t size = r.width() * bpp; 689 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp; 690 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp; 691 if (dbpr==sbpr && size==sbpr) { 692 size *= h; 693 h = 1; 694 } 695 do { 696 memcpy(d, s, size); 697 d += dbpr; 698 s += sbpr; 699 } while (--h > 0); 700 } 701 } 702 703 if (src_bits) 704 src->unlock(); 705 706 if (dst_bits) 707 dst->unlock(); 708 709 return err; 710} 711 712// ---------------------------------------------------------------------------- 713 714status_t Surface::lock( 715 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds) 716{ 717 if (mLockedBuffer != 0) { 718 ALOGE("Surface::lock failed, already locked"); 719 return INVALID_OPERATION; 720 } 721 722 if (!mConnectedToCpu) { 723 int err = Surface::connect(NATIVE_WINDOW_API_CPU); 724 if (err) { 725 return err; 726 } 727 // we're intending to do software rendering from this point 728 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); 729 } 730 731 ANativeWindowBuffer* out; 732 int fenceFd = -1; 733 status_t err = dequeueBuffer(&out, &fenceFd); 734 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err)); 735 if (err == NO_ERROR) { 736 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out)); 737 sp<Fence> fence(new Fence(fenceFd)); 738 739 err = fence->waitForever("Surface::lock"); 740 if (err != OK) { 741 ALOGE("Fence::wait failed (%s)", strerror(-err)); 742 cancelBuffer(out, fenceFd); 743 return err; 744 } 745 746 const Rect bounds(backBuffer->width, backBuffer->height); 747 748 Region newDirtyRegion; 749 if (inOutDirtyBounds) { 750 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds)); 751 newDirtyRegion.andSelf(bounds); 752 } else { 753 newDirtyRegion.set(bounds); 754 } 755 756 // figure out if we can copy the frontbuffer back 757 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer); 758 const bool canCopyBack = (frontBuffer != 0 && 759 backBuffer->width == frontBuffer->width && 760 backBuffer->height == frontBuffer->height && 761 backBuffer->format == frontBuffer->format); 762 763 if (canCopyBack) { 764 // copy the area that is invalid and not repainted this round 765 const Region copyback(mDirtyRegion.subtract(newDirtyRegion)); 766 if (!copyback.isEmpty()) 767 copyBlt(backBuffer, frontBuffer, copyback); 768 } else { 769 // if we can't copy-back anything, modify the user's dirty 770 // region to make sure they redraw the whole buffer 771 newDirtyRegion.set(bounds); 772 mDirtyRegion.clear(); 773 Mutex::Autolock lock(mMutex); 774 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) { 775 mSlots[i].dirtyRegion.clear(); 776 } 777 } 778 779 780 { // scope for the lock 781 Mutex::Autolock lock(mMutex); 782 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get())); 783 if (backBufferSlot >= 0) { 784 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion); 785 mDirtyRegion.subtract(dirtyRegion); 786 dirtyRegion = newDirtyRegion; 787 } 788 } 789 790 mDirtyRegion.orSelf(newDirtyRegion); 791 if (inOutDirtyBounds) { 792 *inOutDirtyBounds = newDirtyRegion.getBounds(); 793 } 794 795 void* vaddr; 796 status_t res = backBuffer->lock( 797 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, 798 newDirtyRegion.bounds(), &vaddr); 799 800 ALOGW_IF(res, "failed locking buffer (handle = %p)", 801 backBuffer->handle); 802 803 if (res != 0) { 804 err = INVALID_OPERATION; 805 } else { 806 mLockedBuffer = backBuffer; 807 outBuffer->width = backBuffer->width; 808 outBuffer->height = backBuffer->height; 809 outBuffer->stride = backBuffer->stride; 810 outBuffer->format = backBuffer->format; 811 outBuffer->bits = vaddr; 812 } 813 } 814 return err; 815} 816 817status_t Surface::unlockAndPost() 818{ 819 if (mLockedBuffer == 0) { 820 ALOGE("Surface::unlockAndPost failed, no locked buffer"); 821 return INVALID_OPERATION; 822 } 823 824 status_t err = mLockedBuffer->unlock(); 825 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle); 826 827 err = queueBuffer(mLockedBuffer.get(), -1); 828 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)", 829 mLockedBuffer->handle, strerror(-err)); 830 831 mPostedBuffer = mLockedBuffer; 832 mLockedBuffer = 0; 833 return err; 834} 835 836}; // namespace android 837