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