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