SurfaceComposerClient.cpp revision 6c913be9ca95fd6b556d056e165a4ba6dc69795b
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 "SurfaceComposerClient" 18 19#include <stdint.h> 20#include <sys/types.h> 21 22#include <utils/Errors.h> 23#include <utils/Log.h> 24#include <utils/Singleton.h> 25#include <utils/SortedVector.h> 26#include <utils/String8.h> 27#include <utils/threads.h> 28 29#include <binder/IMemory.h> 30#include <binder/IServiceManager.h> 31 32#include <ui/DisplayInfo.h> 33 34#include <gui/CpuConsumer.h> 35#include <gui/IGraphicBufferProducer.h> 36#include <gui/ISurfaceComposer.h> 37#include <gui/ISurfaceComposerClient.h> 38#include <gui/SurfaceComposerClient.h> 39 40#include <private/gui/ComposerService.h> 41#include <private/gui/LayerState.h> 42 43namespace android { 44// --------------------------------------------------------------------------- 45 46ANDROID_SINGLETON_STATIC_INSTANCE(ComposerService); 47 48ComposerService::ComposerService() 49: Singleton<ComposerService>() { 50 Mutex::Autolock _l(mLock); 51 connectLocked(); 52} 53 54void ComposerService::connectLocked() { 55 const String16 name("SurfaceFlinger"); 56 while (getService(name, &mComposerService) != NO_ERROR) { 57 usleep(250000); 58 } 59 assert(mComposerService != NULL); 60 61 // Create the death listener. 62 class DeathObserver : public IBinder::DeathRecipient { 63 ComposerService& mComposerService; 64 virtual void binderDied(const wp<IBinder>& who) { 65 ALOGW("ComposerService remote (surfaceflinger) died [%p]", 66 who.unsafe_get()); 67 mComposerService.composerServiceDied(); 68 } 69 public: 70 DeathObserver(ComposerService& mgr) : mComposerService(mgr) { } 71 }; 72 73 mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this)); 74 mComposerService->asBinder()->linkToDeath(mDeathObserver); 75} 76 77/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() { 78 ComposerService& instance = ComposerService::getInstance(); 79 Mutex::Autolock _l(instance.mLock); 80 if (instance.mComposerService == NULL) { 81 ComposerService::getInstance().connectLocked(); 82 assert(instance.mComposerService != NULL); 83 ALOGD("ComposerService reconnected"); 84 } 85 return instance.mComposerService; 86} 87 88void ComposerService::composerServiceDied() 89{ 90 Mutex::Autolock _l(mLock); 91 mComposerService = NULL; 92 mDeathObserver = NULL; 93} 94 95// --------------------------------------------------------------------------- 96 97static inline 98int compare_type(const ComposerState& lhs, const ComposerState& rhs) { 99 if (lhs.client < rhs.client) return -1; 100 if (lhs.client > rhs.client) return 1; 101 if (lhs.state.surface < rhs.state.surface) return -1; 102 if (lhs.state.surface > rhs.state.surface) return 1; 103 return 0; 104} 105 106static inline 107int compare_type(const DisplayState& lhs, const DisplayState& rhs) { 108 return compare_type(lhs.token, rhs.token); 109} 110 111class Composer : public Singleton<Composer> 112{ 113 friend class Singleton<Composer>; 114 115 mutable Mutex mLock; 116 SortedVector<ComposerState> mComposerStates; 117 SortedVector<DisplayState > mDisplayStates; 118 uint32_t mForceSynchronous; 119 uint32_t mTransactionNestCount; 120 bool mAnimation; 121 122 Composer() : Singleton<Composer>(), 123 mForceSynchronous(0), mTransactionNestCount(0), 124 mAnimation(false) 125 { } 126 127 void openGlobalTransactionImpl(); 128 void closeGlobalTransactionImpl(bool synchronous); 129 void setAnimationTransactionImpl(); 130 131 layer_state_t* getLayerStateLocked( 132 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id); 133 134 DisplayState& getDisplayStateLocked(const sp<IBinder>& token); 135 136public: 137 sp<IBinder> createDisplay(const String8& displayName, bool secure); 138 void destroyDisplay(const sp<IBinder>& display); 139 sp<IBinder> getBuiltInDisplay(int32_t id); 140 141 status_t setPosition(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 142 float x, float y); 143 status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 144 uint32_t w, uint32_t h); 145 status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 146 int32_t z); 147 status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 148 uint32_t flags, uint32_t mask); 149 status_t setTransparentRegionHint( 150 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 151 const Region& transparentRegion); 152 status_t setAlpha(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 153 float alpha); 154 status_t setMatrix(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 155 float dsdx, float dtdx, float dsdy, float dtdy); 156 status_t setOrientation(int orientation); 157 status_t setCrop(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 158 const Rect& crop); 159 status_t setLayerStack(const sp<SurfaceComposerClient>& client, 160 const sp<IBinder>& id, uint32_t layerStack); 161 162 void setDisplaySurface(const sp<IBinder>& token, 163 const sp<IGraphicBufferProducer>& bufferProducer); 164 void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack); 165 void setDisplayProjection(const sp<IBinder>& token, 166 uint32_t orientation, 167 const Rect& layerStackRect, 168 const Rect& displayRect); 169 170 static void setAnimationTransaction() { 171 Composer::getInstance().setAnimationTransactionImpl(); 172 } 173 174 static void openGlobalTransaction() { 175 Composer::getInstance().openGlobalTransactionImpl(); 176 } 177 178 static void closeGlobalTransaction(bool synchronous) { 179 Composer::getInstance().closeGlobalTransactionImpl(synchronous); 180 } 181}; 182 183ANDROID_SINGLETON_STATIC_INSTANCE(Composer); 184 185// --------------------------------------------------------------------------- 186 187sp<IBinder> Composer::createDisplay(const String8& displayName, bool secure) { 188 return ComposerService::getComposerService()->createDisplay(displayName, 189 secure); 190} 191 192void Composer::destroyDisplay(const sp<IBinder>& display) { 193 return ComposerService::getComposerService()->destroyDisplay(display); 194} 195 196sp<IBinder> Composer::getBuiltInDisplay(int32_t id) { 197 return ComposerService::getComposerService()->getBuiltInDisplay(id); 198} 199 200void Composer::openGlobalTransactionImpl() { 201 { // scope for the lock 202 Mutex::Autolock _l(mLock); 203 mTransactionNestCount += 1; 204 } 205} 206 207void Composer::closeGlobalTransactionImpl(bool synchronous) { 208 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 209 210 Vector<ComposerState> transaction; 211 Vector<DisplayState> displayTransaction; 212 uint32_t flags = 0; 213 214 { // scope for the lock 215 Mutex::Autolock _l(mLock); 216 mForceSynchronous |= synchronous; 217 if (!mTransactionNestCount) { 218 ALOGW("At least one call to closeGlobalTransaction() was not matched by a prior " 219 "call to openGlobalTransaction()."); 220 } else if (--mTransactionNestCount) { 221 return; 222 } 223 224 transaction = mComposerStates; 225 mComposerStates.clear(); 226 227 displayTransaction = mDisplayStates; 228 mDisplayStates.clear(); 229 230 if (mForceSynchronous) { 231 flags |= ISurfaceComposer::eSynchronous; 232 } 233 if (mAnimation) { 234 flags |= ISurfaceComposer::eAnimation; 235 } 236 237 mForceSynchronous = false; 238 mAnimation = false; 239 } 240 241 sm->setTransactionState(transaction, displayTransaction, flags); 242} 243 244void Composer::setAnimationTransactionImpl() { 245 Mutex::Autolock _l(mLock); 246 mAnimation = true; 247} 248 249layer_state_t* Composer::getLayerStateLocked( 250 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id) { 251 252 ComposerState s; 253 s.client = client->mClient; 254 s.state.surface = id; 255 256 ssize_t index = mComposerStates.indexOf(s); 257 if (index < 0) { 258 // we don't have it, add an initialized layer_state to our list 259 index = mComposerStates.add(s); 260 } 261 262 ComposerState* const out = mComposerStates.editArray(); 263 return &(out[index].state); 264} 265 266status_t Composer::setPosition(const sp<SurfaceComposerClient>& client, 267 const sp<IBinder>& id, float x, float y) { 268 Mutex::Autolock _l(mLock); 269 layer_state_t* s = getLayerStateLocked(client, id); 270 if (!s) 271 return BAD_INDEX; 272 s->what |= layer_state_t::ePositionChanged; 273 s->x = x; 274 s->y = y; 275 return NO_ERROR; 276} 277 278status_t Composer::setSize(const sp<SurfaceComposerClient>& client, 279 const sp<IBinder>& id, uint32_t w, uint32_t h) { 280 Mutex::Autolock _l(mLock); 281 layer_state_t* s = getLayerStateLocked(client, id); 282 if (!s) 283 return BAD_INDEX; 284 s->what |= layer_state_t::eSizeChanged; 285 s->w = w; 286 s->h = h; 287 288 // Resizing a surface makes the transaction synchronous. 289 mForceSynchronous = true; 290 291 return NO_ERROR; 292} 293 294status_t Composer::setLayer(const sp<SurfaceComposerClient>& client, 295 const sp<IBinder>& id, int32_t z) { 296 Mutex::Autolock _l(mLock); 297 layer_state_t* s = getLayerStateLocked(client, id); 298 if (!s) 299 return BAD_INDEX; 300 s->what |= layer_state_t::eLayerChanged; 301 s->z = z; 302 return NO_ERROR; 303} 304 305status_t Composer::setFlags(const sp<SurfaceComposerClient>& client, 306 const sp<IBinder>& id, uint32_t flags, 307 uint32_t mask) { 308 Mutex::Autolock _l(mLock); 309 layer_state_t* s = getLayerStateLocked(client, id); 310 if (!s) 311 return BAD_INDEX; 312 s->what |= layer_state_t::eVisibilityChanged; 313 s->flags &= ~mask; 314 s->flags |= (flags & mask); 315 s->mask |= mask; 316 return NO_ERROR; 317} 318 319status_t Composer::setTransparentRegionHint( 320 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 321 const Region& transparentRegion) { 322 Mutex::Autolock _l(mLock); 323 layer_state_t* s = getLayerStateLocked(client, id); 324 if (!s) 325 return BAD_INDEX; 326 s->what |= layer_state_t::eTransparentRegionChanged; 327 s->transparentRegion = transparentRegion; 328 return NO_ERROR; 329} 330 331status_t Composer::setAlpha(const sp<SurfaceComposerClient>& client, 332 const sp<IBinder>& id, float alpha) { 333 Mutex::Autolock _l(mLock); 334 layer_state_t* s = getLayerStateLocked(client, id); 335 if (!s) 336 return BAD_INDEX; 337 s->what |= layer_state_t::eAlphaChanged; 338 s->alpha = alpha; 339 return NO_ERROR; 340} 341 342status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client, 343 const sp<IBinder>& id, uint32_t layerStack) { 344 Mutex::Autolock _l(mLock); 345 layer_state_t* s = getLayerStateLocked(client, id); 346 if (!s) 347 return BAD_INDEX; 348 s->what |= layer_state_t::eLayerStackChanged; 349 s->layerStack = layerStack; 350 return NO_ERROR; 351} 352 353status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client, 354 const sp<IBinder>& id, float dsdx, float dtdx, 355 float dsdy, float dtdy) { 356 Mutex::Autolock _l(mLock); 357 layer_state_t* s = getLayerStateLocked(client, id); 358 if (!s) 359 return BAD_INDEX; 360 s->what |= layer_state_t::eMatrixChanged; 361 layer_state_t::matrix22_t matrix; 362 matrix.dsdx = dsdx; 363 matrix.dtdx = dtdx; 364 matrix.dsdy = dsdy; 365 matrix.dtdy = dtdy; 366 s->matrix = matrix; 367 return NO_ERROR; 368} 369 370status_t Composer::setCrop(const sp<SurfaceComposerClient>& client, 371 const sp<IBinder>& id, const Rect& crop) { 372 Mutex::Autolock _l(mLock); 373 layer_state_t* s = getLayerStateLocked(client, id); 374 if (!s) 375 return BAD_INDEX; 376 s->what |= layer_state_t::eCropChanged; 377 s->crop = crop; 378 return NO_ERROR; 379} 380 381// --------------------------------------------------------------------------- 382 383DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) { 384 DisplayState s; 385 s.token = token; 386 ssize_t index = mDisplayStates.indexOf(s); 387 if (index < 0) { 388 // we don't have it, add an initialized layer_state to our list 389 s.what = 0; 390 index = mDisplayStates.add(s); 391 } 392 return mDisplayStates.editItemAt(index); 393} 394 395void Composer::setDisplaySurface(const sp<IBinder>& token, 396 const sp<IGraphicBufferProducer>& bufferProducer) { 397 Mutex::Autolock _l(mLock); 398 DisplayState& s(getDisplayStateLocked(token)); 399 s.surface = bufferProducer; 400 s.what |= DisplayState::eSurfaceChanged; 401} 402 403void Composer::setDisplayLayerStack(const sp<IBinder>& token, 404 uint32_t layerStack) { 405 Mutex::Autolock _l(mLock); 406 DisplayState& s(getDisplayStateLocked(token)); 407 s.layerStack = layerStack; 408 s.what |= DisplayState::eLayerStackChanged; 409} 410 411void Composer::setDisplayProjection(const sp<IBinder>& token, 412 uint32_t orientation, 413 const Rect& layerStackRect, 414 const Rect& displayRect) { 415 Mutex::Autolock _l(mLock); 416 DisplayState& s(getDisplayStateLocked(token)); 417 s.orientation = orientation; 418 s.viewport = layerStackRect; 419 s.frame = displayRect; 420 s.what |= DisplayState::eDisplayProjectionChanged; 421 mForceSynchronous = true; // TODO: do we actually still need this? 422} 423 424// --------------------------------------------------------------------------- 425 426SurfaceComposerClient::SurfaceComposerClient() 427 : mStatus(NO_INIT), mComposer(Composer::getInstance()) 428{ 429} 430 431void SurfaceComposerClient::onFirstRef() { 432 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 433 if (sm != 0) { 434 sp<ISurfaceComposerClient> conn = sm->createConnection(); 435 if (conn != 0) { 436 mClient = conn; 437 mStatus = NO_ERROR; 438 } 439 } 440} 441 442SurfaceComposerClient::~SurfaceComposerClient() { 443 dispose(); 444} 445 446status_t SurfaceComposerClient::initCheck() const { 447 return mStatus; 448} 449 450sp<IBinder> SurfaceComposerClient::connection() const { 451 return (mClient != 0) ? mClient->asBinder() : 0; 452} 453 454status_t SurfaceComposerClient::linkToComposerDeath( 455 const sp<IBinder::DeathRecipient>& recipient, 456 void* cookie, uint32_t flags) { 457 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 458 return sm->asBinder()->linkToDeath(recipient, cookie, flags); 459} 460 461void SurfaceComposerClient::dispose() { 462 // this can be called more than once. 463 sp<ISurfaceComposerClient> client; 464 Mutex::Autolock _lm(mLock); 465 if (mClient != 0) { 466 client = mClient; // hold ref while lock is held 467 mClient.clear(); 468 } 469 mStatus = NO_INIT; 470} 471 472sp<SurfaceControl> SurfaceComposerClient::createSurface( 473 const String8& name, 474 uint32_t w, 475 uint32_t h, 476 PixelFormat format, 477 uint32_t flags) 478{ 479 sp<SurfaceControl> sur; 480 if (mStatus == NO_ERROR) { 481 sp<IBinder> handle; 482 sp<IGraphicBufferProducer> gbp; 483 status_t err = mClient->createSurface(name, w, h, format, flags, 484 &handle, &gbp); 485 ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err)); 486 if (err == NO_ERROR) { 487 sur = new SurfaceControl(this, handle, gbp); 488 } 489 } 490 return sur; 491} 492 493sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName, 494 bool secure) { 495 return Composer::getInstance().createDisplay(displayName, secure); 496} 497 498void SurfaceComposerClient::destroyDisplay(const sp<IBinder>& display) { 499 Composer::getInstance().destroyDisplay(display); 500} 501 502sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) { 503 return Composer::getInstance().getBuiltInDisplay(id); 504} 505 506status_t SurfaceComposerClient::destroySurface(const sp<IBinder>& sid) { 507 if (mStatus != NO_ERROR) 508 return mStatus; 509 status_t err = mClient->destroySurface(sid); 510 return err; 511} 512 513inline Composer& SurfaceComposerClient::getComposer() { 514 return mComposer; 515} 516 517// ---------------------------------------------------------------------------- 518 519void SurfaceComposerClient::openGlobalTransaction() { 520 Composer::openGlobalTransaction(); 521} 522 523void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) { 524 Composer::closeGlobalTransaction(synchronous); 525} 526 527void SurfaceComposerClient::setAnimationTransaction() { 528 Composer::setAnimationTransaction(); 529} 530 531// ---------------------------------------------------------------------------- 532 533status_t SurfaceComposerClient::setCrop(const sp<IBinder>& id, const Rect& crop) { 534 return getComposer().setCrop(this, id, crop); 535} 536 537status_t SurfaceComposerClient::setPosition(const sp<IBinder>& id, float x, float y) { 538 return getComposer().setPosition(this, id, x, y); 539} 540 541status_t SurfaceComposerClient::setSize(const sp<IBinder>& id, uint32_t w, uint32_t h) { 542 return getComposer().setSize(this, id, w, h); 543} 544 545status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) { 546 return getComposer().setLayer(this, id, z); 547} 548 549status_t SurfaceComposerClient::hide(const sp<IBinder>& id) { 550 return getComposer().setFlags(this, id, 551 layer_state_t::eLayerHidden, 552 layer_state_t::eLayerHidden); 553} 554 555status_t SurfaceComposerClient::show(const sp<IBinder>& id) { 556 return getComposer().setFlags(this, id, 557 0, 558 layer_state_t::eLayerHidden); 559} 560 561status_t SurfaceComposerClient::setFlags(const sp<IBinder>& id, uint32_t flags, 562 uint32_t mask) { 563 return getComposer().setFlags(this, id, flags, mask); 564} 565 566status_t SurfaceComposerClient::setTransparentRegionHint(const sp<IBinder>& id, 567 const Region& transparentRegion) { 568 return getComposer().setTransparentRegionHint(this, id, transparentRegion); 569} 570 571status_t SurfaceComposerClient::setAlpha(const sp<IBinder>& id, float alpha) { 572 return getComposer().setAlpha(this, id, alpha); 573} 574 575status_t SurfaceComposerClient::setLayerStack(const sp<IBinder>& id, uint32_t layerStack) { 576 return getComposer().setLayerStack(this, id, layerStack); 577} 578 579status_t SurfaceComposerClient::setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, 580 float dsdy, float dtdy) { 581 return getComposer().setMatrix(this, id, dsdx, dtdx, dsdy, dtdy); 582} 583 584// ---------------------------------------------------------------------------- 585 586void SurfaceComposerClient::setDisplaySurface(const sp<IBinder>& token, 587 const sp<IGraphicBufferProducer>& bufferProducer) { 588 Composer::getInstance().setDisplaySurface(token, bufferProducer); 589} 590 591void SurfaceComposerClient::setDisplayLayerStack(const sp<IBinder>& token, 592 uint32_t layerStack) { 593 Composer::getInstance().setDisplayLayerStack(token, layerStack); 594} 595 596void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token, 597 uint32_t orientation, 598 const Rect& layerStackRect, 599 const Rect& displayRect) { 600 Composer::getInstance().setDisplayProjection(token, orientation, 601 layerStackRect, displayRect); 602} 603 604// ---------------------------------------------------------------------------- 605 606status_t SurfaceComposerClient::getDisplayInfo( 607 const sp<IBinder>& display, DisplayInfo* info) 608{ 609 return ComposerService::getComposerService()->getDisplayInfo(display, info); 610} 611 612void SurfaceComposerClient::blankDisplay(const sp<IBinder>& token) { 613 ComposerService::getComposerService()->blank(token); 614} 615 616void SurfaceComposerClient::unblankDisplay(const sp<IBinder>& token) { 617 ComposerService::getComposerService()->unblank(token); 618} 619 620// ---------------------------------------------------------------------------- 621 622status_t ScreenshotClient::capture( 623 const sp<IBinder>& display, 624 const sp<IGraphicBufferProducer>& producer, 625 uint32_t reqWidth, uint32_t reqHeight, 626 uint32_t minLayerZ, uint32_t maxLayerZ) { 627 sp<ISurfaceComposer> s(ComposerService::getComposerService()); 628 if (s == NULL) return NO_INIT; 629 return s->captureScreen(display, producer, 630 reqWidth, reqHeight, minLayerZ, maxLayerZ); 631} 632 633ScreenshotClient::ScreenshotClient() 634 : mHaveBuffer(false) { 635 memset(&mBuffer, 0, sizeof(mBuffer)); 636} 637 638ScreenshotClient::~ScreenshotClient() { 639 ScreenshotClient::release(); 640} 641 642sp<CpuConsumer> ScreenshotClient::getCpuConsumer() const { 643 if (mCpuConsumer == NULL) { 644 mBufferQueue = new BufferQueue(); 645 mCpuConsumer = new CpuConsumer(mBufferQueue, 1); 646 mCpuConsumer->setName(String8("ScreenshotClient")); 647 } 648 return mCpuConsumer; 649} 650 651status_t ScreenshotClient::update(const sp<IBinder>& display, 652 uint32_t reqWidth, uint32_t reqHeight, 653 uint32_t minLayerZ, uint32_t maxLayerZ) { 654 sp<ISurfaceComposer> s(ComposerService::getComposerService()); 655 if (s == NULL) return NO_INIT; 656 sp<CpuConsumer> cpuConsumer = getCpuConsumer(); 657 658 if (mHaveBuffer) { 659 mCpuConsumer->unlockBuffer(mBuffer); 660 memset(&mBuffer, 0, sizeof(mBuffer)); 661 mHaveBuffer = false; 662 } 663 664 status_t err = s->captureScreen(display, mBufferQueue, 665 reqWidth, reqHeight, minLayerZ, maxLayerZ); 666 667 if (err == NO_ERROR) { 668 err = mCpuConsumer->lockNextBuffer(&mBuffer); 669 if (err == NO_ERROR) { 670 mHaveBuffer = true; 671 } 672 } 673 return err; 674} 675 676status_t ScreenshotClient::update(const sp<IBinder>& display) { 677 return ScreenshotClient::update(display, 0, 0, 0, -1UL); 678} 679 680status_t ScreenshotClient::update(const sp<IBinder>& display, 681 uint32_t reqWidth, uint32_t reqHeight) { 682 return ScreenshotClient::update(display, reqWidth, reqHeight, 0, -1UL); 683} 684 685void ScreenshotClient::release() { 686 if (mHaveBuffer) { 687 mCpuConsumer->unlockBuffer(mBuffer); 688 memset(&mBuffer, 0, sizeof(mBuffer)); 689 mHaveBuffer = false; 690 } 691 mCpuConsumer.clear(); 692} 693 694void const* ScreenshotClient::getPixels() const { 695 return mBuffer.data; 696} 697 698uint32_t ScreenshotClient::getWidth() const { 699 return mBuffer.width; 700} 701 702uint32_t ScreenshotClient::getHeight() const { 703 return mBuffer.height; 704} 705 706PixelFormat ScreenshotClient::getFormat() const { 707 return mBuffer.format; 708} 709 710uint32_t ScreenshotClient::getStride() const { 711 return mBuffer.stride; 712} 713 714size_t ScreenshotClient::getSize() const { 715 return mBuffer.stride * mBuffer.height * bytesPerPixel(mBuffer.format); 716} 717 718// ---------------------------------------------------------------------------- 719}; // namespace android 720