libs/gui/SurfaceTextureClient.cpp

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