Surface.cpp revision 812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2
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#include <utils/NativeHandle.h> 28 29#include <ui/Fence.h> 30#include <ui/Region.h> 31 32#include <gui/IProducerListener.h> 33#include <gui/ISurfaceComposer.h> 34#include <gui/SurfaceComposerClient.h> 35#include <gui/GLConsumer.h> 36#include <gui/Surface.h> 37 38#include <private/gui/ComposerService.h> 39 40namespace android { 41 42Surface::Surface( 43 const sp<IGraphicBufferProducer>& bufferProducer, 44 bool controlledByApp) 45 : mGraphicBufferProducer(bufferProducer), 46 mGenerationNumber(0) 47{ 48 // Initialize the ANativeWindow function pointers. 49 ANativeWindow::setSwapInterval = hook_setSwapInterval; 50 ANativeWindow::dequeueBuffer = hook_dequeueBuffer; 51 ANativeWindow::cancelBuffer = hook_cancelBuffer; 52 ANativeWindow::queueBuffer = hook_queueBuffer; 53 ANativeWindow::query = hook_query; 54 ANativeWindow::perform = hook_perform; 55 56 ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED; 57 ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED; 58 ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED; 59 ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED; 60 61 const_cast<int&>(ANativeWindow::minSwapInterval) = 0; 62 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1; 63 64 mReqWidth = 0; 65 mReqHeight = 0; 66 mReqFormat = 0; 67 mReqUsage = 0; 68 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO; 69 mDataSpace = HAL_DATASPACE_UNKNOWN; 70 mCrop.clear(); 71 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 72 mTransform = 0; 73 mStickyTransform = 0; 74 mDefaultWidth = 0; 75 mDefaultHeight = 0; 76 mUserWidth = 0; 77 mUserHeight = 0; 78 mTransformHint = 0; 79 mConsumerRunningBehind = false; 80 mConnectedToCpu = false; 81 mProducerControlledByApp = controlledByApp; 82 mSwapIntervalZero = false; 83} 84 85Surface::~Surface() { 86 if (mConnectedToCpu) { 87 Surface::disconnect(NATIVE_WINDOW_API_CPU); 88 } 89} 90 91sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const { 92 return mGraphicBufferProducer; 93} 94 95void Surface::setSidebandStream(const sp<NativeHandle>& stream) { 96 mGraphicBufferProducer->setSidebandStream(stream); 97} 98 99void Surface::allocateBuffers() { 100 uint32_t reqWidth = mReqWidth ? mReqWidth : mUserWidth; 101 uint32_t reqHeight = mReqHeight ? mReqHeight : mUserHeight; 102 mGraphicBufferProducer->allocateBuffers(mSwapIntervalZero, reqWidth, 103 reqHeight, mReqFormat, mReqUsage); 104} 105 106status_t Surface::setGenerationNumber(uint32_t generation) { 107 status_t result = mGraphicBufferProducer->setGenerationNumber(generation); 108 if (result == NO_ERROR) { 109 mGenerationNumber = generation; 110 } 111 return result; 112} 113 114int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) { 115 Surface* c = getSelf(window); 116 return c->setSwapInterval(interval); 117} 118 119int Surface::hook_dequeueBuffer(ANativeWindow* window, 120 ANativeWindowBuffer** buffer, int* fenceFd) { 121 Surface* c = getSelf(window); 122 return c->dequeueBuffer(buffer, fenceFd); 123} 124 125int Surface::hook_cancelBuffer(ANativeWindow* window, 126 ANativeWindowBuffer* buffer, int fenceFd) { 127 Surface* c = getSelf(window); 128 return c->cancelBuffer(buffer, fenceFd); 129} 130 131int Surface::hook_queueBuffer(ANativeWindow* window, 132 ANativeWindowBuffer* buffer, int fenceFd) { 133 Surface* c = getSelf(window); 134 return c->queueBuffer(buffer, fenceFd); 135} 136 137int Surface::hook_dequeueBuffer_DEPRECATED(ANativeWindow* window, 138 ANativeWindowBuffer** buffer) { 139 Surface* c = getSelf(window); 140 ANativeWindowBuffer* buf; 141 int fenceFd = -1; 142 int result = c->dequeueBuffer(&buf, &fenceFd); 143 sp<Fence> fence(new Fence(fenceFd)); 144 int waitResult = fence->waitForever("dequeueBuffer_DEPRECATED"); 145 if (waitResult != OK) { 146 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an error: %d", 147 waitResult); 148 c->cancelBuffer(buf, -1); 149 return waitResult; 150 } 151 *buffer = buf; 152 return result; 153} 154 155int Surface::hook_cancelBuffer_DEPRECATED(ANativeWindow* window, 156 ANativeWindowBuffer* buffer) { 157 Surface* c = getSelf(window); 158 return c->cancelBuffer(buffer, -1); 159} 160 161int Surface::hook_lockBuffer_DEPRECATED(ANativeWindow* window, 162 ANativeWindowBuffer* buffer) { 163 Surface* c = getSelf(window); 164 return c->lockBuffer_DEPRECATED(buffer); 165} 166 167int Surface::hook_queueBuffer_DEPRECATED(ANativeWindow* window, 168 ANativeWindowBuffer* buffer) { 169 Surface* c = getSelf(window); 170 return c->queueBuffer(buffer, -1); 171} 172 173int Surface::hook_query(const ANativeWindow* window, 174 int what, int* value) { 175 const Surface* c = getSelf(window); 176 return c->query(what, value); 177} 178 179int Surface::hook_perform(ANativeWindow* window, int operation, ...) { 180 va_list args; 181 va_start(args, operation); 182 Surface* c = getSelf(window); 183 return c->perform(operation, args); 184} 185 186int Surface::setSwapInterval(int interval) { 187 ATRACE_CALL(); 188 // EGL specification states: 189 // interval is silently clamped to minimum and maximum implementation 190 // dependent values before being stored. 191 192 if (interval < minSwapInterval) 193 interval = minSwapInterval; 194 195 if (interval > maxSwapInterval) 196 interval = maxSwapInterval; 197 198 mSwapIntervalZero = (interval == 0); 199 200 return NO_ERROR; 201} 202 203int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { 204 ATRACE_CALL(); 205 ALOGV("Surface::dequeueBuffer"); 206 207 uint32_t reqWidth; 208 uint32_t reqHeight; 209 bool swapIntervalZero; 210 PixelFormat reqFormat; 211 uint32_t reqUsage; 212 213 { 214 Mutex::Autolock lock(mMutex); 215 216 reqWidth = mReqWidth ? mReqWidth : mUserWidth; 217 reqHeight = mReqHeight ? mReqHeight : mUserHeight; 218 219 swapIntervalZero = mSwapIntervalZero; 220 reqFormat = mReqFormat; 221 reqUsage = mReqUsage; 222 } // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffer 223 224 int buf = -1; 225 sp<Fence> fence; 226 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, swapIntervalZero, 227 reqWidth, reqHeight, reqFormat, reqUsage); 228 229 if (result < 0) { 230 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)" 231 "failed: %d", swapIntervalZero, reqWidth, reqHeight, reqFormat, 232 reqUsage, result); 233 return result; 234 } 235 236 Mutex::Autolock lock(mMutex); 237 238 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer); 239 240 // this should never happen 241 ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf); 242 243 if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) { 244 freeAllBuffers(); 245 } 246 247 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) { 248 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf); 249 if (result != NO_ERROR) { 250 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result); 251 mGraphicBufferProducer->cancelBuffer(buf, fence); 252 return result; 253 } 254 } 255 256 if (fence->isValid()) { 257 *fenceFd = fence->dup(); 258 if (*fenceFd == -1) { 259 ALOGE("dequeueBuffer: error duping fence: %d", errno); 260 // dup() should never fail; something is badly wrong. Soldier on 261 // and hope for the best; the worst that should happen is some 262 // visible corruption that lasts until the next frame. 263 } 264 } else { 265 *fenceFd = -1; 266 } 267 268 *buffer = gbuf.get(); 269 return OK; 270} 271 272int Surface::cancelBuffer(android_native_buffer_t* buffer, 273 int fenceFd) { 274 ATRACE_CALL(); 275 ALOGV("Surface::cancelBuffer"); 276 Mutex::Autolock lock(mMutex); 277 int i = getSlotFromBufferLocked(buffer); 278 if (i < 0) { 279 if (fenceFd >= 0) { 280 close(fenceFd); 281 } 282 return i; 283 } 284 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 285 mGraphicBufferProducer->cancelBuffer(i, fence); 286 return OK; 287} 288 289int Surface::getSlotFromBufferLocked( 290 android_native_buffer_t* buffer) const { 291 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 292 if (mSlots[i].buffer != NULL && 293 mSlots[i].buffer->handle == buffer->handle) { 294 return i; 295 } 296 } 297 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle); 298 return BAD_VALUE; 299} 300 301int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer __attribute__((unused))) { 302 ALOGV("Surface::lockBuffer"); 303 Mutex::Autolock lock(mMutex); 304 return OK; 305} 306 307int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) { 308 ATRACE_CALL(); 309 ALOGV("Surface::queueBuffer"); 310 Mutex::Autolock lock(mMutex); 311 int64_t timestamp; 312 bool isAutoTimestamp = false; 313 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) { 314 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 315 isAutoTimestamp = true; 316 ALOGV("Surface::queueBuffer making up timestamp: %.2f ms", 317 timestamp / 1000000.f); 318 } else { 319 timestamp = mTimestamp; 320 } 321 int i = getSlotFromBufferLocked(buffer); 322 if (i < 0) { 323 if (fenceFd >= 0) { 324 close(fenceFd); 325 } 326 return i; 327 } 328 329 330 // Make sure the crop rectangle is entirely inside the buffer. 331 Rect crop; 332 mCrop.intersect(Rect(buffer->width, buffer->height), &crop); 333 334 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 335 IGraphicBufferProducer::QueueBufferOutput output; 336 IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp, 337 mDataSpace, crop, mScalingMode, mTransform ^ mStickyTransform, 338 mSwapIntervalZero, fence, mStickyTransform); 339 340 if (mConnectedToCpu || mDirtyRegion.bounds() == Rect::INVALID_RECT) { 341 input.setSurfaceDamage(Region::INVALID_REGION); 342 } else { 343 // The surface damage was specified using the OpenGL ES convention of 344 // the origin being in the bottom-left corner. Here we flip to the 345 // convention that the rest of the system uses (top-left corner) by 346 // subtracting all top/bottom coordinates from the buffer height. 347 int height = buffer->height; 348 if ((mTransform ^ mStickyTransform) & NATIVE_WINDOW_TRANSFORM_ROT_90) { 349 height = buffer->width; 350 } 351 Region flippedRegion; 352 for (auto rect : mDirtyRegion) { 353 auto top = height - rect.bottom; 354 auto bottom = height - rect.top; 355 Rect flippedRect{rect.left, top, rect.right, bottom}; 356 flippedRegion.orSelf(flippedRect); 357 } 358 359 input.setSurfaceDamage(flippedRegion); 360 } 361 362 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output); 363 if (err != OK) { 364 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err); 365 } 366 uint32_t numPendingBuffers = 0; 367 uint32_t hint = 0; 368 output.deflate(&mDefaultWidth, &mDefaultHeight, &hint, 369 &numPendingBuffers); 370 371 // Disable transform hint if sticky transform is set. 372 if (mStickyTransform == 0) { 373 mTransformHint = hint; 374 } 375 376 mConsumerRunningBehind = (numPendingBuffers >= 2); 377 378 if (!mConnectedToCpu) { 379 // Clear surface damage back to full-buffer 380 mDirtyRegion = Region::INVALID_REGION; 381 } 382 383 return err; 384} 385 386int Surface::query(int what, int* value) const { 387 ATRACE_CALL(); 388 ALOGV("Surface::query"); 389 { // scope for the lock 390 Mutex::Autolock lock(mMutex); 391 switch (what) { 392 case NATIVE_WINDOW_FORMAT: 393 if (mReqFormat) { 394 *value = static_cast<int>(mReqFormat); 395 return NO_ERROR; 396 } 397 break; 398 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: { 399 sp<ISurfaceComposer> composer( 400 ComposerService::getComposerService()); 401 if (composer->authenticateSurfaceTexture(mGraphicBufferProducer)) { 402 *value = 1; 403 } else { 404 *value = 0; 405 } 406 return NO_ERROR; 407 } 408 case NATIVE_WINDOW_CONCRETE_TYPE: 409 *value = NATIVE_WINDOW_SURFACE; 410 return NO_ERROR; 411 case NATIVE_WINDOW_DEFAULT_WIDTH: 412 *value = static_cast<int>( 413 mUserWidth ? mUserWidth : mDefaultWidth); 414 return NO_ERROR; 415 case NATIVE_WINDOW_DEFAULT_HEIGHT: 416 *value = static_cast<int>( 417 mUserHeight ? mUserHeight : mDefaultHeight); 418 return NO_ERROR; 419 case NATIVE_WINDOW_TRANSFORM_HINT: 420 *value = static_cast<int>(mTransformHint); 421 return NO_ERROR; 422 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: { 423 status_t err = NO_ERROR; 424 if (!mConsumerRunningBehind) { 425 *value = 0; 426 } else { 427 err = mGraphicBufferProducer->query(what, value); 428 if (err == NO_ERROR) { 429 mConsumerRunningBehind = *value; 430 } 431 } 432 return err; 433 } 434 } 435 } 436 return mGraphicBufferProducer->query(what, value); 437} 438 439int Surface::perform(int operation, va_list args) 440{ 441 int res = NO_ERROR; 442 switch (operation) { 443 case NATIVE_WINDOW_CONNECT: 444 // deprecated. must return NO_ERROR. 445 break; 446 case NATIVE_WINDOW_DISCONNECT: 447 // deprecated. must return NO_ERROR. 448 break; 449 case NATIVE_WINDOW_SET_USAGE: 450 res = dispatchSetUsage(args); 451 break; 452 case NATIVE_WINDOW_SET_CROP: 453 res = dispatchSetCrop(args); 454 break; 455 case NATIVE_WINDOW_SET_BUFFER_COUNT: 456 res = dispatchSetBufferCount(args); 457 break; 458 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 459 res = dispatchSetBuffersGeometry(args); 460 break; 461 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 462 res = dispatchSetBuffersTransform(args); 463 break; 464 case NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM: 465 res = dispatchSetBuffersStickyTransform(args); 466 break; 467 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 468 res = dispatchSetBuffersTimestamp(args); 469 break; 470 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS: 471 res = dispatchSetBuffersDimensions(args); 472 break; 473 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS: 474 res = dispatchSetBuffersUserDimensions(args); 475 break; 476 case NATIVE_WINDOW_SET_BUFFERS_FORMAT: 477 res = dispatchSetBuffersFormat(args); 478 break; 479 case NATIVE_WINDOW_LOCK: 480 res = dispatchLock(args); 481 break; 482 case NATIVE_WINDOW_UNLOCK_AND_POST: 483 res = dispatchUnlockAndPost(args); 484 break; 485 case NATIVE_WINDOW_SET_SCALING_MODE: 486 res = dispatchSetScalingMode(args); 487 break; 488 case NATIVE_WINDOW_API_CONNECT: 489 res = dispatchConnect(args); 490 break; 491 case NATIVE_WINDOW_API_DISCONNECT: 492 res = dispatchDisconnect(args); 493 break; 494 case NATIVE_WINDOW_SET_SIDEBAND_STREAM: 495 res = dispatchSetSidebandStream(args); 496 break; 497 case NATIVE_WINDOW_SET_BUFFERS_DATASPACE: 498 res = dispatchSetBuffersDataSpace(args); 499 break; 500 case NATIVE_WINDOW_SET_SURFACE_DAMAGE: 501 res = dispatchSetSurfaceDamage(args); 502 break; 503 default: 504 res = NAME_NOT_FOUND; 505 break; 506 } 507 return res; 508} 509 510int Surface::dispatchConnect(va_list args) { 511 int api = va_arg(args, int); 512 return connect(api); 513} 514 515int Surface::dispatchDisconnect(va_list args) { 516 int api = va_arg(args, int); 517 return disconnect(api); 518} 519 520int Surface::dispatchSetUsage(va_list args) { 521 int usage = va_arg(args, int); 522 return setUsage(static_cast<uint32_t>(usage)); 523} 524 525int Surface::dispatchSetCrop(va_list args) { 526 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*); 527 return setCrop(reinterpret_cast<Rect const*>(rect)); 528} 529 530int Surface::dispatchSetBufferCount(va_list args) { 531 size_t bufferCount = va_arg(args, size_t); 532 return setBufferCount(static_cast<int32_t>(bufferCount)); 533} 534 535int Surface::dispatchSetBuffersGeometry(va_list args) { 536 uint32_t width = va_arg(args, uint32_t); 537 uint32_t height = va_arg(args, uint32_t); 538 PixelFormat format = va_arg(args, PixelFormat); 539 int err = setBuffersDimensions(width, height); 540 if (err != 0) { 541 return err; 542 } 543 return setBuffersFormat(format); 544} 545 546int Surface::dispatchSetBuffersDimensions(va_list args) { 547 uint32_t width = va_arg(args, uint32_t); 548 uint32_t height = va_arg(args, uint32_t); 549 return setBuffersDimensions(width, height); 550} 551 552int Surface::dispatchSetBuffersUserDimensions(va_list args) { 553 uint32_t width = va_arg(args, uint32_t); 554 uint32_t height = va_arg(args, uint32_t); 555 return setBuffersUserDimensions(width, height); 556} 557 558int Surface::dispatchSetBuffersFormat(va_list args) { 559 PixelFormat format = va_arg(args, PixelFormat); 560 return setBuffersFormat(format); 561} 562 563int Surface::dispatchSetScalingMode(va_list args) { 564 int mode = va_arg(args, int); 565 return setScalingMode(mode); 566} 567 568int Surface::dispatchSetBuffersTransform(va_list args) { 569 uint32_t transform = va_arg(args, uint32_t); 570 return setBuffersTransform(transform); 571} 572 573int Surface::dispatchSetBuffersStickyTransform(va_list args) { 574 uint32_t transform = va_arg(args, uint32_t); 575 return setBuffersStickyTransform(transform); 576} 577 578int Surface::dispatchSetBuffersTimestamp(va_list args) { 579 int64_t timestamp = va_arg(args, int64_t); 580 return setBuffersTimestamp(timestamp); 581} 582 583int Surface::dispatchLock(va_list args) { 584 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*); 585 ARect* inOutDirtyBounds = va_arg(args, ARect*); 586 return lock(outBuffer, inOutDirtyBounds); 587} 588 589int Surface::dispatchUnlockAndPost(va_list args __attribute__((unused))) { 590 return unlockAndPost(); 591} 592 593int Surface::dispatchSetSidebandStream(va_list args) { 594 native_handle_t* sH = va_arg(args, native_handle_t*); 595 sp<NativeHandle> sidebandHandle = NativeHandle::create(sH, false); 596 setSidebandStream(sidebandHandle); 597 return OK; 598} 599 600int Surface::dispatchSetBuffersDataSpace(va_list args) { 601 android_dataspace dataspace = 602 static_cast<android_dataspace>(va_arg(args, int)); 603 return setBuffersDataSpace(dataspace); 604} 605 606int Surface::dispatchSetSurfaceDamage(va_list args) { 607 android_native_rect_t* rects = va_arg(args, android_native_rect_t*); 608 size_t numRects = va_arg(args, size_t); 609 setSurfaceDamage(rects, numRects); 610 return NO_ERROR; 611} 612 613int Surface::connect(int api) { 614 static sp<IProducerListener> listener = new DummyProducerListener(); 615 return connect(api, listener); 616} 617 618int Surface::connect(int api, const sp<IProducerListener>& listener) { 619 ATRACE_CALL(); 620 ALOGV("Surface::connect"); 621 Mutex::Autolock lock(mMutex); 622 IGraphicBufferProducer::QueueBufferOutput output; 623 int err = mGraphicBufferProducer->connect(listener, api, mProducerControlledByApp, &output); 624 if (err == NO_ERROR) { 625 uint32_t numPendingBuffers = 0; 626 uint32_t hint = 0; 627 output.deflate(&mDefaultWidth, &mDefaultHeight, &hint, 628 &numPendingBuffers); 629 630 // Disable transform hint if sticky transform is set. 631 if (mStickyTransform == 0) { 632 mTransformHint = hint; 633 } 634 635 mConsumerRunningBehind = (numPendingBuffers >= 2); 636 } 637 if (!err && api == NATIVE_WINDOW_API_CPU) { 638 mConnectedToCpu = true; 639 // Clear the dirty region in case we're switching from a non-CPU API 640 mDirtyRegion.clear(); 641 } else if (!err) { 642 // Initialize the dirty region for tracking surface damage 643 mDirtyRegion = Region::INVALID_REGION; 644 } 645 646 return err; 647} 648 649 650int Surface::disconnect(int api) { 651 ATRACE_CALL(); 652 ALOGV("Surface::disconnect"); 653 Mutex::Autolock lock(mMutex); 654 freeAllBuffers(); 655 int err = mGraphicBufferProducer->disconnect(api); 656 if (!err) { 657 mReqFormat = 0; 658 mReqWidth = 0; 659 mReqHeight = 0; 660 mReqUsage = 0; 661 mCrop.clear(); 662 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 663 mTransform = 0; 664 mStickyTransform = 0; 665 666 if (api == NATIVE_WINDOW_API_CPU) { 667 mConnectedToCpu = false; 668 } 669 } 670 return err; 671} 672 673int Surface::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 674 sp<Fence>* outFence) { 675 ATRACE_CALL(); 676 ALOGV("Surface::detachNextBuffer"); 677 678 if (outBuffer == NULL || outFence == NULL) { 679 return BAD_VALUE; 680 } 681 682 Mutex::Autolock lock(mMutex); 683 684 sp<GraphicBuffer> buffer(NULL); 685 sp<Fence> fence(NULL); 686 status_t result = mGraphicBufferProducer->detachNextBuffer( 687 &buffer, &fence); 688 if (result != NO_ERROR) { 689 return result; 690 } 691 692 *outBuffer = buffer; 693 if (fence != NULL && fence->isValid()) { 694 *outFence = fence; 695 } else { 696 *outFence = Fence::NO_FENCE; 697 } 698 699 return NO_ERROR; 700} 701 702int Surface::attachBuffer(ANativeWindowBuffer* buffer) 703{ 704 ATRACE_CALL(); 705 ALOGV("Surface::attachBuffer"); 706 707 Mutex::Autolock lock(mMutex); 708 709 sp<GraphicBuffer> graphicBuffer(static_cast<GraphicBuffer*>(buffer)); 710 uint32_t priorGeneration = graphicBuffer->mGenerationNumber; 711 graphicBuffer->mGenerationNumber = mGenerationNumber; 712 int32_t attachedSlot = -1; 713 status_t result = mGraphicBufferProducer->attachBuffer( 714 &attachedSlot, graphicBuffer); 715 if (result != NO_ERROR) { 716 ALOGE("attachBuffer: IGraphicBufferProducer call failed (%d)", result); 717 graphicBuffer->mGenerationNumber = priorGeneration; 718 return result; 719 } 720 mSlots[attachedSlot].buffer = graphicBuffer; 721 722 return NO_ERROR; 723} 724 725int Surface::setUsage(uint32_t reqUsage) 726{ 727 ALOGV("Surface::setUsage"); 728 Mutex::Autolock lock(mMutex); 729 mReqUsage = reqUsage; 730 return OK; 731} 732 733int Surface::setCrop(Rect const* rect) 734{ 735 ATRACE_CALL(); 736 737 Rect realRect; 738 if (rect == NULL || rect->isEmpty()) { 739 realRect.clear(); 740 } else { 741 realRect = *rect; 742 } 743 744 ALOGV("Surface::setCrop rect=[%d %d %d %d]", 745 realRect.left, realRect.top, realRect.right, realRect.bottom); 746 747 Mutex::Autolock lock(mMutex); 748 mCrop = realRect; 749 return NO_ERROR; 750} 751 752int Surface::setBufferCount(int bufferCount) 753{ 754 ATRACE_CALL(); 755 ALOGV("Surface::setBufferCount"); 756 Mutex::Autolock lock(mMutex); 757 758 status_t err = mGraphicBufferProducer->setBufferCount(bufferCount); 759 ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s", 760 bufferCount, strerror(-err)); 761 762 if (err == NO_ERROR) { 763 freeAllBuffers(); 764 } 765 766 return err; 767} 768 769int Surface::setBuffersDimensions(uint32_t width, uint32_t height) 770{ 771 ATRACE_CALL(); 772 ALOGV("Surface::setBuffersDimensions"); 773 774 if ((width && !height) || (!width && height)) 775 return BAD_VALUE; 776 777 Mutex::Autolock lock(mMutex); 778 mReqWidth = width; 779 mReqHeight = height; 780 return NO_ERROR; 781} 782 783int Surface::setBuffersUserDimensions(uint32_t width, uint32_t height) 784{ 785 ATRACE_CALL(); 786 ALOGV("Surface::setBuffersUserDimensions"); 787 788 if ((width && !height) || (!width && height)) 789 return BAD_VALUE; 790 791 Mutex::Autolock lock(mMutex); 792 mUserWidth = width; 793 mUserHeight = height; 794 return NO_ERROR; 795} 796 797int Surface::setBuffersFormat(PixelFormat format) 798{ 799 ALOGV("Surface::setBuffersFormat"); 800 801 Mutex::Autolock lock(mMutex); 802 mReqFormat = format; 803 return NO_ERROR; 804} 805 806int Surface::setScalingMode(int mode) 807{ 808 ATRACE_CALL(); 809 ALOGV("Surface::setScalingMode(%d)", mode); 810 811 switch (mode) { 812 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 813 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 814 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 815 break; 816 default: 817 ALOGE("unknown scaling mode: %d", mode); 818 return BAD_VALUE; 819 } 820 821 Mutex::Autolock lock(mMutex); 822 mScalingMode = mode; 823 return NO_ERROR; 824} 825 826int Surface::setBuffersTransform(uint32_t transform) 827{ 828 ATRACE_CALL(); 829 ALOGV("Surface::setBuffersTransform"); 830 Mutex::Autolock lock(mMutex); 831 mTransform = transform; 832 return NO_ERROR; 833} 834 835int Surface::setBuffersStickyTransform(uint32_t transform) 836{ 837 ATRACE_CALL(); 838 ALOGV("Surface::setBuffersStickyTransform"); 839 Mutex::Autolock lock(mMutex); 840 mStickyTransform = transform; 841 return NO_ERROR; 842} 843 844int Surface::setBuffersTimestamp(int64_t timestamp) 845{ 846 ALOGV("Surface::setBuffersTimestamp"); 847 Mutex::Autolock lock(mMutex); 848 mTimestamp = timestamp; 849 return NO_ERROR; 850} 851 852int Surface::setBuffersDataSpace(android_dataspace dataSpace) 853{ 854 ALOGV("Surface::setBuffersDataSpace"); 855 Mutex::Autolock lock(mMutex); 856 mDataSpace = dataSpace; 857 return NO_ERROR; 858} 859 860void Surface::freeAllBuffers() { 861 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 862 mSlots[i].buffer = 0; 863 } 864} 865 866void Surface::setSurfaceDamage(android_native_rect_t* rects, size_t numRects) { 867 ATRACE_CALL(); 868 ALOGV("Surface::setSurfaceDamage"); 869 Mutex::Autolock lock(mMutex); 870 871 if (mConnectedToCpu || numRects == 0) { 872 mDirtyRegion = Region::INVALID_REGION; 873 return; 874 } 875 876 mDirtyRegion.clear(); 877 for (size_t r = 0; r < numRects; ++r) { 878 // We intentionally flip top and bottom here, since because they're 879 // specified with a bottom-left origin, top > bottom, which fails 880 // validation in the Region class. We will fix this up when we flip to a 881 // top-left origin in queueBuffer. 882 Rect rect(rects[r].left, rects[r].bottom, rects[r].right, rects[r].top); 883 mDirtyRegion.orSelf(rect); 884 } 885} 886 887// ---------------------------------------------------------------------- 888// the lock/unlock APIs must be used from the same thread 889 890static status_t copyBlt( 891 const sp<GraphicBuffer>& dst, 892 const sp<GraphicBuffer>& src, 893 const Region& reg) 894{ 895 // src and dst with, height and format must be identical. no verification 896 // is done here. 897 status_t err; 898 uint8_t* src_bits = NULL; 899 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), 900 reinterpret_cast<void**>(&src_bits)); 901 ALOGE_IF(err, "error locking src buffer %s", strerror(-err)); 902 903 uint8_t* dst_bits = NULL; 904 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), 905 reinterpret_cast<void**>(&dst_bits)); 906 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err)); 907 908 Region::const_iterator head(reg.begin()); 909 Region::const_iterator tail(reg.end()); 910 if (head != tail && src_bits && dst_bits) { 911 const size_t bpp = bytesPerPixel(src->format); 912 const size_t dbpr = static_cast<uint32_t>(dst->stride) * bpp; 913 const size_t sbpr = static_cast<uint32_t>(src->stride) * bpp; 914 915 while (head != tail) { 916 const Rect& r(*head++); 917 int32_t h = r.height(); 918 if (h <= 0) continue; 919 size_t size = static_cast<uint32_t>(r.width()) * bpp; 920 uint8_t const * s = src_bits + 921 static_cast<uint32_t>(r.left + src->stride * r.top) * bpp; 922 uint8_t * d = dst_bits + 923 static_cast<uint32_t>(r.left + dst->stride * r.top) * bpp; 924 if (dbpr==sbpr && size==sbpr) { 925 size *= static_cast<size_t>(h); 926 h = 1; 927 } 928 do { 929 memcpy(d, s, size); 930 d += dbpr; 931 s += sbpr; 932 } while (--h > 0); 933 } 934 } 935 936 if (src_bits) 937 src->unlock(); 938 939 if (dst_bits) 940 dst->unlock(); 941 942 return err; 943} 944 945// ---------------------------------------------------------------------------- 946 947status_t Surface::lock( 948 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds) 949{ 950 if (mLockedBuffer != 0) { 951 ALOGE("Surface::lock failed, already locked"); 952 return INVALID_OPERATION; 953 } 954 955 if (!mConnectedToCpu) { 956 int err = Surface::connect(NATIVE_WINDOW_API_CPU); 957 if (err) { 958 return err; 959 } 960 // we're intending to do software rendering from this point 961 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); 962 } 963 964 ANativeWindowBuffer* out; 965 int fenceFd = -1; 966 status_t err = dequeueBuffer(&out, &fenceFd); 967 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err)); 968 if (err == NO_ERROR) { 969 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out)); 970 const Rect bounds(backBuffer->width, backBuffer->height); 971 972 Region newDirtyRegion; 973 if (inOutDirtyBounds) { 974 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds)); 975 newDirtyRegion.andSelf(bounds); 976 } else { 977 newDirtyRegion.set(bounds); 978 } 979 980 // figure out if we can copy the frontbuffer back 981 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer); 982 const bool canCopyBack = (frontBuffer != 0 && 983 backBuffer->width == frontBuffer->width && 984 backBuffer->height == frontBuffer->height && 985 backBuffer->format == frontBuffer->format); 986 987 if (canCopyBack) { 988 // copy the area that is invalid and not repainted this round 989 const Region copyback(mDirtyRegion.subtract(newDirtyRegion)); 990 if (!copyback.isEmpty()) 991 copyBlt(backBuffer, frontBuffer, copyback); 992 } else { 993 // if we can't copy-back anything, modify the user's dirty 994 // region to make sure they redraw the whole buffer 995 newDirtyRegion.set(bounds); 996 mDirtyRegion.clear(); 997 Mutex::Autolock lock(mMutex); 998 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) { 999 mSlots[i].dirtyRegion.clear(); 1000 } 1001 } 1002 1003 1004 { // scope for the lock 1005 Mutex::Autolock lock(mMutex); 1006 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get())); 1007 if (backBufferSlot >= 0) { 1008 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion); 1009 mDirtyRegion.subtract(dirtyRegion); 1010 dirtyRegion = newDirtyRegion; 1011 } 1012 } 1013 1014 mDirtyRegion.orSelf(newDirtyRegion); 1015 if (inOutDirtyBounds) { 1016 *inOutDirtyBounds = newDirtyRegion.getBounds(); 1017 } 1018 1019 void* vaddr; 1020 status_t res = backBuffer->lockAsync( 1021 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, 1022 newDirtyRegion.bounds(), &vaddr, fenceFd); 1023 1024 ALOGW_IF(res, "failed locking buffer (handle = %p)", 1025 backBuffer->handle); 1026 1027 if (res != 0) { 1028 err = INVALID_OPERATION; 1029 } else { 1030 mLockedBuffer = backBuffer; 1031 outBuffer->width = backBuffer->width; 1032 outBuffer->height = backBuffer->height; 1033 outBuffer->stride = backBuffer->stride; 1034 outBuffer->format = backBuffer->format; 1035 outBuffer->bits = vaddr; 1036 } 1037 } 1038 return err; 1039} 1040 1041status_t Surface::unlockAndPost() 1042{ 1043 if (mLockedBuffer == 0) { 1044 ALOGE("Surface::unlockAndPost failed, no locked buffer"); 1045 return INVALID_OPERATION; 1046 } 1047 1048 int fd = -1; 1049 status_t err = mLockedBuffer->unlockAsync(&fd); 1050 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle); 1051 1052 err = queueBuffer(mLockedBuffer.get(), fd); 1053 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)", 1054 mLockedBuffer->handle, strerror(-err)); 1055 1056 mPostedBuffer = mLockedBuffer; 1057 mLockedBuffer = 0; 1058 return err; 1059} 1060 1061}; // namespace android 1062