Surface.cpp revision d87f162026454f5a3e6437ed0c9ef51651a6b939
1/* 2 * Copyright (C) 2007 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 19#include <stdint.h> 20#include <errno.h> 21#include <sys/types.h> 22#include <sys/stat.h> 23 24#include <utils/Errors.h> 25#include <utils/threads.h> 26#include <utils/CallStack.h> 27#include <utils/Log.h> 28 29#include <binder/IPCThreadState.h> 30#include <binder/IMemory.h> 31 32#include <ui/DisplayInfo.h> 33#include <ui/GraphicBuffer.h> 34#include <ui/GraphicBufferMapper.h> 35#include <ui/GraphicLog.h> 36#include <ui/Rect.h> 37 38#include <surfaceflinger/Surface.h> 39#include <surfaceflinger/ISurface.h> 40#include <surfaceflinger/ISurfaceComposer.h> 41#include <surfaceflinger/SurfaceComposerClient.h> 42 43#include <private/surfaceflinger/SharedBufferStack.h> 44#include <private/surfaceflinger/LayerState.h> 45 46namespace android { 47 48// ---------------------------------------------------------------------- 49 50static status_t copyBlt( 51 const sp<GraphicBuffer>& dst, 52 const sp<GraphicBuffer>& src, 53 const Region& reg) 54{ 55 // src and dst with, height and format must be identical. no verification 56 // is done here. 57 status_t err; 58 uint8_t const * src_bits = NULL; 59 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits); 60 LOGE_IF(err, "error locking src buffer %s", strerror(-err)); 61 62 uint8_t* dst_bits = NULL; 63 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits); 64 LOGE_IF(err, "error locking dst buffer %s", strerror(-err)); 65 66 Region::const_iterator head(reg.begin()); 67 Region::const_iterator tail(reg.end()); 68 if (head != tail && src_bits && dst_bits) { 69 const size_t bpp = bytesPerPixel(src->format); 70 const size_t dbpr = dst->stride * bpp; 71 const size_t sbpr = src->stride * bpp; 72 73 while (head != tail) { 74 const Rect& r(*head++); 75 ssize_t h = r.height(); 76 if (h <= 0) continue; 77 size_t size = r.width() * bpp; 78 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp; 79 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp; 80 if (dbpr==sbpr && size==sbpr) { 81 size *= h; 82 h = 1; 83 } 84 do { 85 memcpy(d, s, size); 86 d += dbpr; 87 s += sbpr; 88 } while (--h > 0); 89 } 90 } 91 92 if (src_bits) 93 src->unlock(); 94 95 if (dst_bits) 96 dst->unlock(); 97 98 return err; 99} 100 101// ============================================================================ 102// SurfaceControl 103// ============================================================================ 104 105SurfaceControl::SurfaceControl( 106 const sp<SurfaceComposerClient>& client, 107 const sp<ISurface>& surface, 108 const ISurfaceComposerClient::surface_data_t& data, 109 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags) 110 : mClient(client), mSurface(surface), 111 mToken(data.token), mIdentity(data.identity), 112 mWidth(data.width), mHeight(data.height), mFormat(data.format), 113 mFlags(flags) 114{ 115} 116 117SurfaceControl::~SurfaceControl() 118{ 119 destroy(); 120} 121 122void SurfaceControl::destroy() 123{ 124 if (isValid()) { 125 mClient->destroySurface(mToken); 126 } 127 128 // clear all references and trigger an IPC now, to make sure things 129 // happen without delay, since these resources are quite heavy. 130 mClient.clear(); 131 mSurface.clear(); 132 IPCThreadState::self()->flushCommands(); 133} 134 135void SurfaceControl::clear() 136{ 137 // here, the window manager tells us explicitly that we should destroy 138 // the surface's resource. Soon after this call, it will also release 139 // its last reference (which will call the dtor); however, it is possible 140 // that a client living in the same process still holds references which 141 // would delay the call to the dtor -- that is why we need this explicit 142 // "clear()" call. 143 destroy(); 144} 145 146bool SurfaceControl::isSameSurface( 147 const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs) 148{ 149 if (lhs == 0 || rhs == 0) 150 return false; 151 return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); 152} 153 154status_t SurfaceControl::setLayer(int32_t layer) { 155 status_t err = validate(); 156 if (err < 0) return err; 157 const sp<SurfaceComposerClient>& client(mClient); 158 return client->setLayer(mToken, layer); 159} 160status_t SurfaceControl::setPosition(int32_t x, int32_t y) { 161 status_t err = validate(); 162 if (err < 0) return err; 163 const sp<SurfaceComposerClient>& client(mClient); 164 return client->setPosition(mToken, x, y); 165} 166status_t SurfaceControl::setSize(uint32_t w, uint32_t h) { 167 status_t err = validate(); 168 if (err < 0) return err; 169 const sp<SurfaceComposerClient>& client(mClient); 170 return client->setSize(mToken, w, h); 171} 172status_t SurfaceControl::hide() { 173 status_t err = validate(); 174 if (err < 0) return err; 175 const sp<SurfaceComposerClient>& client(mClient); 176 return client->hide(mToken); 177} 178status_t SurfaceControl::show(int32_t layer) { 179 status_t err = validate(); 180 if (err < 0) return err; 181 const sp<SurfaceComposerClient>& client(mClient); 182 return client->show(mToken, layer); 183} 184status_t SurfaceControl::freeze() { 185 status_t err = validate(); 186 if (err < 0) return err; 187 const sp<SurfaceComposerClient>& client(mClient); 188 return client->freeze(mToken); 189} 190status_t SurfaceControl::unfreeze() { 191 status_t err = validate(); 192 if (err < 0) return err; 193 const sp<SurfaceComposerClient>& client(mClient); 194 return client->unfreeze(mToken); 195} 196status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) { 197 status_t err = validate(); 198 if (err < 0) return err; 199 const sp<SurfaceComposerClient>& client(mClient); 200 return client->setFlags(mToken, flags, mask); 201} 202status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) { 203 status_t err = validate(); 204 if (err < 0) return err; 205 const sp<SurfaceComposerClient>& client(mClient); 206 return client->setTransparentRegionHint(mToken, transparent); 207} 208status_t SurfaceControl::setAlpha(float alpha) { 209 status_t err = validate(); 210 if (err < 0) return err; 211 const sp<SurfaceComposerClient>& client(mClient); 212 return client->setAlpha(mToken, alpha); 213} 214status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { 215 status_t err = validate(); 216 if (err < 0) return err; 217 const sp<SurfaceComposerClient>& client(mClient); 218 return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy); 219} 220status_t SurfaceControl::setFreezeTint(uint32_t tint) { 221 status_t err = validate(); 222 if (err < 0) return err; 223 const sp<SurfaceComposerClient>& client(mClient); 224 return client->setFreezeTint(mToken, tint); 225} 226 227status_t SurfaceControl::validate() const 228{ 229 if (mToken<0 || mClient==0) { 230 LOGE("invalid token (%d, identity=%u) or client (%p)", 231 mToken, mIdentity, mClient.get()); 232 return NO_INIT; 233 } 234 return NO_ERROR; 235} 236 237status_t SurfaceControl::writeSurfaceToParcel( 238 const sp<SurfaceControl>& control, Parcel* parcel) 239{ 240 sp<ISurface> sur; 241 uint32_t identity = 0; 242 uint32_t width = 0; 243 uint32_t height = 0; 244 uint32_t format = 0; 245 uint32_t flags = 0; 246 if (SurfaceControl::isValid(control)) { 247 sur = control->mSurface; 248 identity = control->mIdentity; 249 width = control->mWidth; 250 height = control->mHeight; 251 format = control->mFormat; 252 flags = control->mFlags; 253 } 254 parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); 255 parcel->writeInt32(identity); 256 parcel->writeInt32(width); 257 parcel->writeInt32(height); 258 parcel->writeInt32(format); 259 parcel->writeInt32(flags); 260 return NO_ERROR; 261} 262 263sp<Surface> SurfaceControl::getSurface() const 264{ 265 Mutex::Autolock _l(mLock); 266 if (mSurfaceData == 0) { 267 mSurfaceData = new Surface(const_cast<SurfaceControl*>(this)); 268 } 269 return mSurfaceData; 270} 271 272// ============================================================================ 273// Surface 274// ============================================================================ 275 276class SurfaceClient : public Singleton<SurfaceClient> 277{ 278 // all these attributes are constants 279 sp<ISurfaceComposer> mComposerService; 280 sp<ISurfaceComposerClient> mClient; 281 status_t mStatus; 282 SharedClient* mControl; 283 sp<IMemoryHeap> mControlMemory; 284 285 SurfaceClient() 286 : Singleton<SurfaceClient>(), mStatus(NO_INIT) 287 { 288 sp<ISurfaceComposer> sf(ComposerService::getComposerService()); 289 mComposerService = sf; 290 mClient = sf->createClientConnection(); 291 if (mClient != NULL) { 292 mControlMemory = mClient->getControlBlock(); 293 if (mControlMemory != NULL) { 294 mControl = static_cast<SharedClient *>( 295 mControlMemory->getBase()); 296 if (mControl) { 297 mStatus = NO_ERROR; 298 } 299 } 300 } 301 } 302 friend class Singleton<SurfaceClient>; 303public: 304 status_t initCheck() const { 305 return mStatus; 306 } 307 SharedClient* getSharedClient() const { 308 return mControl; 309 } 310 ssize_t getTokenForSurface(const sp<ISurface>& sur) const { 311 // TODO: we could cache a few tokens here to avoid an IPC 312 return mClient->getTokenForSurface(sur); 313 } 314 void signalServer() const { 315 mComposerService->signal(); 316 } 317}; 318 319ANDROID_SINGLETON_STATIC_INSTANCE(SurfaceClient); 320 321// --------------------------------------------------------------------------- 322 323Surface::Surface(const sp<SurfaceControl>& surface) 324 : mBufferMapper(GraphicBufferMapper::get()), 325 mClient(SurfaceClient::getInstance()), 326 mSharedBufferClient(NULL), 327 mInitCheck(NO_INIT), 328 mSurface(surface->mSurface), 329 mIdentity(surface->mIdentity), 330 mFormat(surface->mFormat), mFlags(surface->mFlags), 331 mWidth(surface->mWidth), mHeight(surface->mHeight) 332{ 333 init(); 334} 335 336Surface::Surface(const Parcel& parcel, const sp<IBinder>& ref) 337 : mBufferMapper(GraphicBufferMapper::get()), 338 mClient(SurfaceClient::getInstance()), 339 mSharedBufferClient(NULL), 340 mInitCheck(NO_INIT) 341{ 342 mSurface = interface_cast<ISurface>(ref); 343 mIdentity = parcel.readInt32(); 344 mWidth = parcel.readInt32(); 345 mHeight = parcel.readInt32(); 346 mFormat = parcel.readInt32(); 347 mFlags = parcel.readInt32(); 348 init(); 349} 350 351status_t Surface::writeToParcel( 352 const sp<Surface>& surface, Parcel* parcel) 353{ 354 sp<ISurface> sur; 355 uint32_t identity = 0; 356 uint32_t width = 0; 357 uint32_t height = 0; 358 uint32_t format = 0; 359 uint32_t flags = 0; 360 if (Surface::isValid(surface)) { 361 sur = surface->mSurface; 362 identity = surface->mIdentity; 363 width = surface->mWidth; 364 height = surface->mHeight; 365 format = surface->mFormat; 366 flags = surface->mFlags; 367 } else if (surface != 0 && surface->mSurface != 0) { 368 LOGW("Parceling invalid surface with non-NULL ISurface as NULL: " 369 "mSurface = %p, mIdentity = %d, mWidth = %d, mHeight = %d, " 370 "mFormat = %d, mFlags = 0x%08x, mInitCheck = %d", 371 surface->mSurface.get(), surface->mIdentity, surface->mWidth, 372 surface->mHeight, surface->mFormat, surface->mFlags, 373 surface->mInitCheck); 374 } 375 parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); 376 parcel->writeInt32(identity); 377 parcel->writeInt32(width); 378 parcel->writeInt32(height); 379 parcel->writeInt32(format); 380 parcel->writeInt32(flags); 381 return NO_ERROR; 382 383} 384 385 386Mutex Surface::sCachedSurfacesLock; 387DefaultKeyedVector<wp<IBinder>, wp<Surface> > Surface::sCachedSurfaces; 388 389sp<Surface> Surface::readFromParcel(const Parcel& data) { 390 Mutex::Autolock _l(sCachedSurfacesLock); 391 sp<IBinder> binder(data.readStrongBinder()); 392 sp<Surface> surface = sCachedSurfaces.valueFor(binder).promote(); 393 if (surface == 0) { 394 surface = new Surface(data, binder); 395 sCachedSurfaces.add(binder, surface); 396 } 397 if (surface->mSurface == 0) { 398 surface = 0; 399 } 400 cleanCachedSurfacesLocked(); 401 return surface; 402} 403 404// Remove the stale entries from the surface cache. This should only be called 405// with sCachedSurfacesLock held. 406void Surface::cleanCachedSurfacesLocked() { 407 for (int i = sCachedSurfaces.size()-1; i >= 0; --i) { 408 wp<Surface> s(sCachedSurfaces.valueAt(i)); 409 if (s == 0 || s.promote() == 0) { 410 sCachedSurfaces.removeItemsAt(i); 411 } 412 } 413} 414 415void Surface::init() 416{ 417 ANativeWindow::setSwapInterval = setSwapInterval; 418 ANativeWindow::dequeueBuffer = dequeueBuffer; 419 ANativeWindow::cancelBuffer = cancelBuffer; 420 ANativeWindow::lockBuffer = lockBuffer; 421 ANativeWindow::queueBuffer = queueBuffer; 422 ANativeWindow::query = query; 423 ANativeWindow::perform = perform; 424 425 DisplayInfo dinfo; 426 SurfaceComposerClient::getDisplayInfo(0, &dinfo); 427 const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi; 428 const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi; 429 // FIXME: set real values here 430 const_cast<int&>(ANativeWindow::minSwapInterval) = 1; 431 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1; 432 const_cast<uint32_t&>(ANativeWindow::flags) = 0; 433 434 mNextBufferTransform = 0; 435 mConnected = 0; 436 mSwapRectangle.makeInvalid(); 437 mNextBufferCrop = Rect(0,0); 438 // two buffers by default 439 mBuffers.setCapacity(2); 440 mBuffers.insertAt(0, 2); 441 442 if (mSurface != 0 && mClient.initCheck() == NO_ERROR) { 443 int32_t token = mClient.getTokenForSurface(mSurface); 444 if (token >= 0) { 445 mSharedBufferClient = new SharedBufferClient( 446 mClient.getSharedClient(), token, 2, mIdentity); 447 mInitCheck = mClient.getSharedClient()->validate(token); 448 } else { 449 LOGW("Not initializing the shared buffer client because token = %d", 450 token); 451 } 452 } 453} 454 455Surface::~Surface() 456{ 457 // clear all references and trigger an IPC now, to make sure things 458 // happen without delay, since these resources are quite heavy. 459 mBuffers.clear(); 460 mSurface.clear(); 461 delete mSharedBufferClient; 462 IPCThreadState::self()->flushCommands(); 463} 464 465bool Surface::isValid() { 466 return mInitCheck == NO_ERROR; 467} 468 469status_t Surface::validate(bool inCancelBuffer) const 470{ 471 // check that we initialized ourself properly 472 if (mInitCheck != NO_ERROR) { 473 LOGE("invalid token (identity=%u)", mIdentity); 474 return mInitCheck; 475 } 476 477 // verify the identity of this surface 478 uint32_t identity = mSharedBufferClient->getIdentity(); 479 if (mIdentity != identity) { 480 LOGE("[Surface] using an invalid surface, " 481 "identity=%u should be %d", 482 mIdentity, identity); 483 CallStack stack; 484 stack.update(); 485 stack.dump("Surface"); 486 return BAD_INDEX; 487 } 488 489 // check the surface didn't become invalid 490 status_t err = mSharedBufferClient->getStatus(); 491 if (err != NO_ERROR) { 492 if (!inCancelBuffer) { 493 LOGE("surface (identity=%u) is invalid, err=%d (%s)", 494 mIdentity, err, strerror(-err)); 495 CallStack stack; 496 stack.update(); 497 stack.dump("Surface"); 498 } 499 return err; 500 } 501 502 return NO_ERROR; 503} 504 505sp<ISurface> Surface::getISurface() const { 506 return mSurface; 507} 508 509// ---------------------------------------------------------------------------- 510 511int Surface::setSwapInterval(ANativeWindow* window, int interval) { 512 return 0; 513} 514 515int Surface::dequeueBuffer(ANativeWindow* window, 516 android_native_buffer_t** buffer) { 517 Surface* self = getSelf(window); 518 return self->dequeueBuffer(buffer); 519} 520 521int Surface::cancelBuffer(ANativeWindow* window, 522 android_native_buffer_t* buffer) { 523 Surface* self = getSelf(window); 524 return self->cancelBuffer(buffer); 525} 526 527int Surface::lockBuffer(ANativeWindow* window, 528 android_native_buffer_t* buffer) { 529 Surface* self = getSelf(window); 530 return self->lockBuffer(buffer); 531} 532 533int Surface::queueBuffer(ANativeWindow* window, 534 android_native_buffer_t* buffer) { 535 Surface* self = getSelf(window); 536 return self->queueBuffer(buffer); 537} 538 539int Surface::query(ANativeWindow* window, 540 int what, int* value) { 541 Surface* self = getSelf(window); 542 return self->query(what, value); 543} 544 545int Surface::perform(ANativeWindow* window, 546 int operation, ...) { 547 va_list args; 548 va_start(args, operation); 549 Surface* self = getSelf(window); 550 int res = self->perform(operation, args); 551 va_end(args); 552 return res; 553} 554 555// ---------------------------------------------------------------------------- 556 557bool Surface::needNewBuffer(int bufIdx, 558 uint32_t *pWidth, uint32_t *pHeight, 559 uint32_t *pFormat, uint32_t *pUsage) const 560{ 561 Mutex::Autolock _l(mSurfaceLock); 562 563 // Always call needNewBuffer(), since it clears the needed buffers flags 564 bool needNewBuffer = mSharedBufferClient->needNewBuffer(bufIdx); 565 bool validBuffer = mBufferInfo.validateBuffer(mBuffers[bufIdx]); 566 bool newNeewBuffer = needNewBuffer || !validBuffer; 567 if (newNeewBuffer) { 568 mBufferInfo.get(pWidth, pHeight, pFormat, pUsage); 569 } 570 return newNeewBuffer; 571} 572 573int Surface::dequeueBuffer(android_native_buffer_t** buffer) 574{ 575 status_t err = validate(); 576 if (err != NO_ERROR) 577 return err; 578 579 GraphicLog& logger(GraphicLog::getInstance()); 580 logger.log(GraphicLog::SF_APP_DEQUEUE_BEFORE, mIdentity, -1); 581 582 ssize_t bufIdx = mSharedBufferClient->dequeue(); 583 584 logger.log(GraphicLog::SF_APP_DEQUEUE_AFTER, mIdentity, bufIdx); 585 586 if (bufIdx < 0) { 587 LOGE("error dequeuing a buffer (%s)", strerror(bufIdx)); 588 return bufIdx; 589 } 590 591 // grow the buffer array if needed 592 const size_t size = mBuffers.size(); 593 const size_t needed = bufIdx+1; 594 if (size < needed) { 595 mBuffers.insertAt(size, needed-size); 596 } 597 598 uint32_t w, h, format, usage; 599 if (needNewBuffer(bufIdx, &w, &h, &format, &usage)) { 600 err = getBufferLocked(bufIdx, w, h, format, usage); 601 LOGE_IF(err, "getBufferLocked(%ld, %u, %u, %u, %08x) failed (%s)", 602 bufIdx, w, h, format, usage, strerror(-err)); 603 if (err == NO_ERROR) { 604 // reset the width/height with the what we get from the buffer 605 const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]); 606 mWidth = uint32_t(backBuffer->width); 607 mHeight = uint32_t(backBuffer->height); 608 } 609 } 610 611 // if we still don't have a buffer here, we probably ran out of memory 612 const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]); 613 if (!err && backBuffer==0) { 614 err = NO_MEMORY; 615 } 616 617 if (err == NO_ERROR) { 618 mDirtyRegion.set(backBuffer->width, backBuffer->height); 619 *buffer = backBuffer.get(); 620 } else { 621 mSharedBufferClient->undoDequeue(bufIdx); 622 } 623 624 return err; 625} 626 627int Surface::cancelBuffer(android_native_buffer_t* buffer) 628{ 629 status_t err = validate(true); 630 switch (err) { 631 case NO_ERROR: 632 // no error, common case 633 break; 634 case BAD_INDEX: 635 // legitimate errors here 636 return err; 637 default: 638 // other errors happen because the surface is now invalid, 639 // for instance because it has been destroyed. In this case, 640 // we just fail silently (canceling a buffer is not technically 641 // an error at this point) 642 return NO_ERROR; 643 } 644 645 int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer)); 646 647 err = mSharedBufferClient->cancel(bufIdx); 648 649 LOGE_IF(err, "error canceling buffer %d (%s)", bufIdx, strerror(-err)); 650 return err; 651} 652 653 654int Surface::lockBuffer(android_native_buffer_t* buffer) 655{ 656 status_t err = validate(); 657 if (err != NO_ERROR) 658 return err; 659 660 int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer)); 661 662 GraphicLog& logger(GraphicLog::getInstance()); 663 logger.log(GraphicLog::SF_APP_LOCK_BEFORE, mIdentity, bufIdx); 664 665 err = mSharedBufferClient->lock(bufIdx); 666 667 logger.log(GraphicLog::SF_APP_LOCK_AFTER, mIdentity, bufIdx); 668 669 LOGE_IF(err, "error locking buffer %d (%s)", bufIdx, strerror(-err)); 670 return err; 671} 672 673int Surface::queueBuffer(android_native_buffer_t* buffer) 674{ 675 status_t err = validate(); 676 if (err != NO_ERROR) 677 return err; 678 679 if (mSwapRectangle.isValid()) { 680 mDirtyRegion.set(mSwapRectangle); 681 } 682 683 int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer)); 684 685 GraphicLog::getInstance().log(GraphicLog::SF_APP_QUEUE, mIdentity, bufIdx); 686 687 mSharedBufferClient->setTransform(bufIdx, mNextBufferTransform); 688 mSharedBufferClient->setCrop(bufIdx, mNextBufferCrop); 689 mSharedBufferClient->setDirtyRegion(bufIdx, mDirtyRegion); 690 err = mSharedBufferClient->queue(bufIdx); 691 LOGE_IF(err, "error queuing buffer %d (%s)", bufIdx, strerror(-err)); 692 693 if (err == NO_ERROR) { 694 // TODO: can we avoid this IPC if we know there is one pending? 695 mClient.signalServer(); 696 } 697 return err; 698} 699 700int Surface::query(int what, int* value) 701{ 702 switch (what) { 703 case NATIVE_WINDOW_WIDTH: 704 *value = int(mWidth); 705 return NO_ERROR; 706 case NATIVE_WINDOW_HEIGHT: 707 *value = int(mHeight); 708 return NO_ERROR; 709 case NATIVE_WINDOW_FORMAT: 710 *value = int(mFormat); 711 return NO_ERROR; 712 case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS: 713 *value = MIN_UNDEQUEUED_BUFFERS; 714 return NO_ERROR; 715 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: { 716 sp<ISurfaceComposer> sf(ComposerService::getComposerService()); 717 *value = sf->authenticateSurface(mSurface) ? 1 : 0; 718 return NO_ERROR; 719 } 720 case NATIVE_WINDOW_CONCRETE_TYPE: 721 *value = NATIVE_WINDOW_SURFACE; 722 return NO_ERROR; 723 } 724 return BAD_VALUE; 725} 726 727int Surface::perform(int operation, va_list args) 728{ 729 status_t err = validate(); 730 if (err != NO_ERROR) 731 return err; 732 733 int res = NO_ERROR; 734 switch (operation) { 735 case NATIVE_WINDOW_SET_USAGE: 736 dispatch_setUsage( args ); 737 break; 738 case NATIVE_WINDOW_CONNECT: 739 res = dispatch_connect( args ); 740 break; 741 case NATIVE_WINDOW_DISCONNECT: 742 res = dispatch_disconnect( args ); 743 break; 744 case NATIVE_WINDOW_SET_CROP: 745 res = dispatch_crop( args ); 746 break; 747 case NATIVE_WINDOW_SET_BUFFER_COUNT: 748 res = dispatch_set_buffer_count( args ); 749 break; 750 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 751 res = dispatch_set_buffers_geometry( args ); 752 break; 753 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 754 res = dispatch_set_buffers_transform( args ); 755 break; 756 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 757 res = dispatch_set_buffers_timestamp( args ); 758 break; 759 default: 760 res = NAME_NOT_FOUND; 761 break; 762 } 763 return res; 764} 765 766void Surface::dispatch_setUsage(va_list args) { 767 int usage = va_arg(args, int); 768 setUsage( usage ); 769} 770int Surface::dispatch_connect(va_list args) { 771 int api = va_arg(args, int); 772 return connect( api ); 773} 774int Surface::dispatch_disconnect(va_list args) { 775 int api = va_arg(args, int); 776 return disconnect( api ); 777} 778int Surface::dispatch_crop(va_list args) { 779 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*); 780 return crop( reinterpret_cast<Rect const*>(rect) ); 781} 782int Surface::dispatch_set_buffer_count(va_list args) { 783 size_t bufferCount = va_arg(args, size_t); 784 return setBufferCount(bufferCount); 785} 786int Surface::dispatch_set_buffers_geometry(va_list args) { 787 int w = va_arg(args, int); 788 int h = va_arg(args, int); 789 int f = va_arg(args, int); 790 return setBuffersGeometry(w, h, f); 791} 792 793int Surface::dispatch_set_buffers_transform(va_list args) { 794 int transform = va_arg(args, int); 795 return setBuffersTransform(transform); 796} 797 798int Surface::dispatch_set_buffers_timestamp(va_list args) { 799 int64_t timestamp = va_arg(args, int64_t); 800 return setBuffersTimestamp(timestamp); 801} 802 803void Surface::setUsage(uint32_t reqUsage) 804{ 805 Mutex::Autolock _l(mSurfaceLock); 806 mBufferInfo.set(reqUsage); 807} 808 809int Surface::connect(int api) 810{ 811 Mutex::Autolock _l(mSurfaceLock); 812 int err = NO_ERROR; 813 switch (api) { 814 case NATIVE_WINDOW_API_EGL: 815 if (mConnected) { 816 err = -EINVAL; 817 } else { 818 mConnected = api; 819 } 820 break; 821 default: 822 err = -EINVAL; 823 break; 824 } 825 return err; 826} 827 828int Surface::disconnect(int api) 829{ 830 Mutex::Autolock _l(mSurfaceLock); 831 int err = NO_ERROR; 832 switch (api) { 833 case NATIVE_WINDOW_API_EGL: 834 if (mConnected == api) { 835 mConnected = 0; 836 } else { 837 err = -EINVAL; 838 } 839 break; 840 default: 841 err = -EINVAL; 842 break; 843 } 844 return err; 845} 846 847int Surface::crop(Rect const* rect) 848{ 849 Mutex::Autolock _l(mSurfaceLock); 850 // TODO: validate rect size 851 852 if (rect == NULL || rect->isEmpty()) { 853 mNextBufferCrop = Rect(0,0); 854 } else { 855 mNextBufferCrop = *rect; 856 } 857 858 return NO_ERROR; 859} 860 861int Surface::setBufferCount(int bufferCount) 862{ 863 sp<ISurface> s(mSurface); 864 if (s == 0) return NO_INIT; 865 866 class SetBufferCountIPC : public SharedBufferClient::SetBufferCountCallback { 867 sp<ISurface> surface; 868 virtual status_t operator()(int bufferCount) const { 869 return surface->setBufferCount(bufferCount); 870 } 871 public: 872 SetBufferCountIPC(const sp<ISurface>& surface) : surface(surface) { } 873 } ipc(s); 874 875 status_t err = mSharedBufferClient->setBufferCount(bufferCount, ipc); 876 LOGE_IF(err, "ISurface::setBufferCount(%d) returned %s", 877 bufferCount, strerror(-err)); 878 879 if (err == NO_ERROR) { 880 // Clear out any references to the old buffers. 881 mBuffers.clear(); 882 } 883 884 return err; 885} 886 887int Surface::setBuffersGeometry(int w, int h, int format) 888{ 889 if (w<0 || h<0 || format<0) 890 return BAD_VALUE; 891 892 if ((w && !h) || (!w && h)) 893 return BAD_VALUE; 894 895 Mutex::Autolock _l(mSurfaceLock); 896 if (mConnected == NATIVE_WINDOW_API_EGL) { 897 return INVALID_OPERATION; 898 } 899 900 mBufferInfo.set(w, h, format); 901 if (format != 0) { 902 // we update the format of the surface as reported by query(). 903 // this is to allow applications to change the format of a surface's 904 // buffer, and have it reflected in EGL; which is needed for 905 // EGLConfig validation. 906 mFormat = format; 907 } 908 909 mNextBufferCrop = Rect(0,0); 910 911 return NO_ERROR; 912} 913 914int Surface::setBuffersTransform(int transform) 915{ 916 Mutex::Autolock _l(mSurfaceLock); 917 mNextBufferTransform = transform; 918 return NO_ERROR; 919} 920 921int Surface::setBuffersTimestamp(int64_t timestamp) 922{ 923 // Surface doesn't really have anything meaningful to do with timestamps 924 // so they'll just be dropped here. 925 return NO_ERROR; 926} 927 928// ---------------------------------------------------------------------------- 929 930int Surface::getConnectedApi() const 931{ 932 Mutex::Autolock _l(mSurfaceLock); 933 return mConnected; 934} 935 936// ---------------------------------------------------------------------------- 937 938status_t Surface::lock(SurfaceInfo* info, bool blocking) { 939 return Surface::lock(info, NULL, blocking); 940} 941 942status_t Surface::lock(SurfaceInfo* other, Region* dirtyIn, bool blocking) 943{ 944 if (getConnectedApi()) { 945 LOGE("Surface::lock(%p) failed. Already connected to another API", 946 (ANativeWindow*)this); 947 CallStack stack; 948 stack.update(); 949 stack.dump(""); 950 return INVALID_OPERATION; 951 } 952 953 if (mApiLock.tryLock() != NO_ERROR) { 954 LOGE("calling Surface::lock from different threads!"); 955 CallStack stack; 956 stack.update(); 957 stack.dump(""); 958 return WOULD_BLOCK; 959 } 960 961 /* Here we're holding mApiLock */ 962 963 if (mLockedBuffer != 0) { 964 LOGE("Surface::lock failed, already locked"); 965 mApiLock.unlock(); 966 return INVALID_OPERATION; 967 } 968 969 // we're intending to do software rendering from this point 970 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); 971 972 android_native_buffer_t* out; 973 status_t err = dequeueBuffer(&out); 974 LOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err)); 975 if (err == NO_ERROR) { 976 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out)); 977 err = lockBuffer(backBuffer.get()); 978 LOGE_IF(err, "lockBuffer (idx=%d) failed (%s)", 979 getBufferIndex(backBuffer), strerror(-err)); 980 if (err == NO_ERROR) { 981 const Rect bounds(backBuffer->width, backBuffer->height); 982 const Region boundsRegion(bounds); 983 Region scratch(boundsRegion); 984 Region& newDirtyRegion(dirtyIn ? *dirtyIn : scratch); 985 newDirtyRegion &= boundsRegion; 986 987 // figure out if we can copy the frontbuffer back 988 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer); 989 const bool canCopyBack = (frontBuffer != 0 && 990 backBuffer->width == frontBuffer->width && 991 backBuffer->height == frontBuffer->height && 992 backBuffer->format == frontBuffer->format && 993 !(mFlags & ISurfaceComposer::eDestroyBackbuffer)); 994 995 // the dirty region we report to surfaceflinger is the one 996 // given by the user (as opposed to the one *we* return to the 997 // user). 998 mDirtyRegion = newDirtyRegion; 999 1000 if (canCopyBack) { 1001 // copy the area that is invalid and not repainted this round 1002 const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion)); 1003 if (!copyback.isEmpty()) 1004 copyBlt(backBuffer, frontBuffer, copyback); 1005 } else { 1006 // if we can't copy-back anything, modify the user's dirty 1007 // region to make sure they redraw the whole buffer 1008 newDirtyRegion = boundsRegion; 1009 } 1010 1011 // keep track of the are of the buffer that is "clean" 1012 // (ie: that will be redrawn) 1013 mOldDirtyRegion = newDirtyRegion; 1014 1015 void* vaddr; 1016 status_t res = backBuffer->lock( 1017 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, 1018 newDirtyRegion.bounds(), &vaddr); 1019 1020 LOGW_IF(res, "failed locking buffer (handle = %p)", 1021 backBuffer->handle); 1022 1023 mLockedBuffer = backBuffer; 1024 other->w = backBuffer->width; 1025 other->h = backBuffer->height; 1026 other->s = backBuffer->stride; 1027 other->usage = backBuffer->usage; 1028 other->format = backBuffer->format; 1029 other->bits = vaddr; 1030 } 1031 } 1032 mApiLock.unlock(); 1033 return err; 1034} 1035 1036status_t Surface::unlockAndPost() 1037{ 1038 if (mLockedBuffer == 0) { 1039 LOGE("Surface::unlockAndPost failed, no locked buffer"); 1040 return INVALID_OPERATION; 1041 } 1042 1043 status_t err = mLockedBuffer->unlock(); 1044 LOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle); 1045 1046 err = queueBuffer(mLockedBuffer.get()); 1047 LOGE_IF(err, "queueBuffer (idx=%d) failed (%s)", 1048 getBufferIndex(mLockedBuffer), strerror(-err)); 1049 1050 mPostedBuffer = mLockedBuffer; 1051 mLockedBuffer = 0; 1052 return err; 1053} 1054 1055void Surface::setSwapRectangle(const Rect& r) { 1056 Mutex::Autolock _l(mSurfaceLock); 1057 mSwapRectangle = r; 1058} 1059 1060int Surface::getBufferIndex(const sp<GraphicBuffer>& buffer) const 1061{ 1062 int idx = buffer->getIndex(); 1063 if (idx < 0) { 1064 // The buffer doesn't have an index set. See if the handle the same as 1065 // one of the buffers for which we do know the index. This can happen 1066 // e.g. if GraphicBuffer is used to wrap an android_native_buffer_t that 1067 // was dequeued from an ANativeWindow. 1068 for (size_t i = 0; i < mBuffers.size(); i++) { 1069 if (mBuffers[i] != 0 && buffer->handle == mBuffers[i]->handle) { 1070 idx = mBuffers[i]->getIndex(); 1071 break; 1072 } 1073 } 1074 } 1075 return idx; 1076} 1077 1078status_t Surface::getBufferLocked(int index, 1079 uint32_t w, uint32_t h, uint32_t format, uint32_t usage) 1080{ 1081 sp<ISurface> s(mSurface); 1082 if (s == 0) return NO_INIT; 1083 1084 status_t err = NO_MEMORY; 1085 1086 // free the current buffer 1087 sp<GraphicBuffer>& currentBuffer(mBuffers.editItemAt(index)); 1088 if (currentBuffer != 0) { 1089 currentBuffer.clear(); 1090 } 1091 1092 sp<GraphicBuffer> buffer = s->requestBuffer(index, w, h, format, usage); 1093 LOGE_IF(buffer==0, 1094 "ISurface::getBuffer(%d, %08x) returned NULL", 1095 index, usage); 1096 if (buffer != 0) { // this should always happen by construction 1097 LOGE_IF(buffer->handle == NULL, 1098 "Surface (identity=%d) requestBuffer(%d, %u, %u, %u, %08x) " 1099 "returned a buffer with a null handle", 1100 mIdentity, index, w, h, format, usage); 1101 err = mSharedBufferClient->getStatus(); 1102 LOGE_IF(err, "Surface (identity=%d) state = %d", mIdentity, err); 1103 if (!err && buffer->handle != NULL) { 1104 currentBuffer = buffer; 1105 currentBuffer->setIndex(index); 1106 } else { 1107 err = err<0 ? err : status_t(NO_MEMORY); 1108 } 1109 } 1110 return err; 1111} 1112 1113// ---------------------------------------------------------------------------- 1114Surface::BufferInfo::BufferInfo() 1115 : mWidth(0), mHeight(0), mFormat(0), 1116 mUsage(GRALLOC_USAGE_HW_RENDER), mDirty(0) 1117{ 1118} 1119 1120void Surface::BufferInfo::set(uint32_t w, uint32_t h, uint32_t format) { 1121 if ((mWidth != w) || (mHeight != h) || (mFormat != format)) { 1122 mWidth = w; 1123 mHeight = h; 1124 mFormat = format; 1125 mDirty |= GEOMETRY; 1126 } 1127} 1128 1129void Surface::BufferInfo::set(uint32_t usage) { 1130 mUsage = usage; 1131} 1132 1133void Surface::BufferInfo::get(uint32_t *pWidth, uint32_t *pHeight, 1134 uint32_t *pFormat, uint32_t *pUsage) const { 1135 *pWidth = mWidth; 1136 *pHeight = mHeight; 1137 *pFormat = mFormat; 1138 *pUsage = mUsage; 1139} 1140 1141bool Surface::BufferInfo::validateBuffer(const sp<GraphicBuffer>& buffer) const { 1142 // make sure we AT LEAST have the usage flags we want 1143 if (mDirty || buffer==0 || 1144 ((buffer->usage & mUsage) != mUsage)) { 1145 mDirty = 0; 1146 return false; 1147 } 1148 return true; 1149} 1150 1151// ---------------------------------------------------------------------------- 1152}; // namespace android 1153