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