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