libs/gui/CpuConsumer.cpp

   1 /*
   2  * Copyright (C) 2012 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_NDEBUG 0
  18 #define LOG_TAG "CpuConsumer"
  19 //#define ATRACE_TAG ATRACE_TAG_GRAPHICS
  20
  21 #include <cutils/compiler.h>
  22 #include <utils/Log.h>
  23 #include <gui/BufferItem.h>
  24 #include <gui/CpuConsumer.h>
  25
  26 #define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
  27 //#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
  28 //#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
  29 #define CC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
  30 #define CC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
  31
  32 namespace android {
  33
  34 CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq,
  35         size_t maxLockedBuffers, bool controlledByApp) :
  36     ConsumerBase(bq, controlledByApp),
  37     mMaxLockedBuffers(maxLockedBuffers),
  38     mCurrentLockedBuffers(0)
  39 {
  40     // Create tracking entries for locked buffers
  41     mAcquiredBuffers.insertAt(0, maxLockedBuffers);
  42
  43     mConsumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
  44     mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));
  45 }
  46
  47 CpuConsumer::~CpuConsumer() {
  48     // ConsumerBase destructor does all the work.
  49 }
  50
  51
  52
  53 void CpuConsumer::setName(const String8& name) {
  54     Mutex::Autolock _l(mMutex);
  55     if (mAbandoned) {
  56         CC_LOGE("setName: CpuConsumer is abandoned!");
  57         return;
  58     }
  59     mName = name;
  60     mConsumer->setConsumerName(name);
  61 }
  62
  63 static bool isPossiblyYUV(PixelFormat format) {
  64     switch (static_cast<int>(format)) {
  65         case HAL_PIXEL_FORMAT_RGBA_8888:
  66         case HAL_PIXEL_FORMAT_RGBX_8888:
  67         case HAL_PIXEL_FORMAT_RGBA_FP16:
  68         case HAL_PIXEL_FORMAT_RGBA_1010102:
  69         case HAL_PIXEL_FORMAT_RGB_888:
  70         case HAL_PIXEL_FORMAT_RGB_565:
  71         case HAL_PIXEL_FORMAT_BGRA_8888:
  72         case HAL_PIXEL_FORMAT_Y8:
  73         case HAL_PIXEL_FORMAT_Y16:
  74         case HAL_PIXEL_FORMAT_RAW16:
  75         case HAL_PIXEL_FORMAT_RAW10:
  76         case HAL_PIXEL_FORMAT_RAW_OPAQUE:
  77         case HAL_PIXEL_FORMAT_BLOB:
  78         case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
  79             return false;
  80
  81         case HAL_PIXEL_FORMAT_YV12:
  82         case HAL_PIXEL_FORMAT_YCbCr_420_888:
  83         case HAL_PIXEL_FORMAT_YCbCr_422_SP:
  84         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
  85         case HAL_PIXEL_FORMAT_YCbCr_422_I:
  86         default:
  87             return true;
  88     }
  89 }
  90
  91 status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
  92     status_t err;
  93
  94     if (!nativeBuffer) return BAD_VALUE;
  95     if (mCurrentLockedBuffers == mMaxLockedBuffers) {
  96         CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.",
  97                 mMaxLockedBuffers);
  98         return NOT_ENOUGH_DATA;
  99     }
 100
 101     BufferItem b;
 102
 103     Mutex::Autolock _l(mMutex);
 104
 105     err = acquireBufferLocked(&b, 0);
 106     if (err != OK) {
 107         if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
 108             return BAD_VALUE;
 109         } else {
 110             CC_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
 111             return err;
 112         }
 113     }
 114
 115     int slot = b.mSlot;
 116
 117     void *bufferPointer = NULL;
 118     android_ycbcr ycbcr = android_ycbcr();
 119
 120     PixelFormat format = mSlots[slot].mGraphicBuffer->getPixelFormat();
 121     PixelFormat flexFormat = format;
 122     if (isPossiblyYUV(format)) {
 123         if (b.mFence.get()) {
 124             err = mSlots[slot].mGraphicBuffer->lockAsyncYCbCr(
 125                 GraphicBuffer::USAGE_SW_READ_OFTEN,
 126                 b.mCrop,
 127                 &ycbcr,
 128                 b.mFence->dup());
 129         } else {
 130             err = mSlots[slot].mGraphicBuffer->lockYCbCr(
 131                 GraphicBuffer::USAGE_SW_READ_OFTEN,
 132                 b.mCrop,
 133                 &ycbcr);
 134         }
 135         if (err == OK) {
 136             bufferPointer = ycbcr.y;
 137             flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
 138             if (format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
 139                 CC_LOGV("locking buffer of format %#x as flex YUV", format);
 140             }
 141         } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
 142             CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)",
 143                     strerror(-err), err);
 144             return err;
 145         }
 146     }
 147
 148     if (bufferPointer == NULL) { // not flexible YUV
 149         if (b.mFence.get()) {
 150             err = mSlots[slot].mGraphicBuffer->lockAsync(
 151                 GraphicBuffer::USAGE_SW_READ_OFTEN,
 152                 b.mCrop,
 153                 &bufferPointer,
 154                 b.mFence->dup());
 155         } else {
 156             err = mSlots[slot].mGraphicBuffer->lock(
 157                 GraphicBuffer::USAGE_SW_READ_OFTEN,
 158                 b.mCrop,
 159                 &bufferPointer);
 160         }
 161         if (err != OK) {
 162             CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)",
 163                     strerror(-err), err);
 164             return err;
 165         }
 166     }
 167
 168     size_t lockedIdx = 0;
 169     for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
 170         if (mAcquiredBuffers[lockedIdx].mSlot ==
 171                 BufferQueue::INVALID_BUFFER_SLOT) {
 172             break;
 173         }
 174     }
 175     assert(lockedIdx < mMaxLockedBuffers);
 176
 177     AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
 178     ab.mSlot = slot;
 179     ab.mBufferPointer = bufferPointer;
 180     ab.mGraphicBuffer = mSlots[slot].mGraphicBuffer;
 181
 182     nativeBuffer->data   =
 183             reinterpret_cast<uint8_t*>(bufferPointer);
 184     nativeBuffer->width  = mSlots[slot].mGraphicBuffer->getWidth();
 185     nativeBuffer->height = mSlots[slot].mGraphicBuffer->getHeight();
 186     nativeBuffer->format = format;
 187     nativeBuffer->flexFormat = flexFormat;
 188     nativeBuffer->stride = (ycbcr.y != NULL) ?
 189             static_cast<uint32_t>(ycbcr.ystride) :
 190             mSlots[slot].mGraphicBuffer->getStride();
 191
 192     nativeBuffer->crop        = b.mCrop;
 193     nativeBuffer->transform   = b.mTransform;
 194     nativeBuffer->scalingMode = b.mScalingMode;
 195     nativeBuffer->timestamp   = b.mTimestamp;
 196     nativeBuffer->dataSpace   = b.mDataSpace;
 197     nativeBuffer->frameNumber = b.mFrameNumber;
 198
 199     nativeBuffer->dataCb       = reinterpret_cast<uint8_t*>(ycbcr.cb);
 200     nativeBuffer->dataCr       = reinterpret_cast<uint8_t*>(ycbcr.cr);
 201     nativeBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
 202     nativeBuffer->chromaStep   = static_cast<uint32_t>(ycbcr.chroma_step);
 203
 204     mCurrentLockedBuffers++;
 205
 206     return OK;
 207 }
 208
 209 status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {
 210     Mutex::Autolock _l(mMutex);
 211     size_t lockedIdx = 0;
 212
 213     void *bufPtr = reinterpret_cast<void *>(nativeBuffer.data);
 214     for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
 215         if (bufPtr == mAcquiredBuffers[lockedIdx].mBufferPointer) break;
 216     }
 217     if (lockedIdx == mMaxLockedBuffers) {
 218         CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);
 219         return BAD_VALUE;
 220     }
 221
 222     return releaseAcquiredBufferLocked(lockedIdx);
 223 }
 224
 225 status_t CpuConsumer::releaseAcquiredBufferLocked(size_t lockedIdx) {
 226     status_t err;
 227     int fd = -1;
 228
 229     err = mAcquiredBuffers[lockedIdx].mGraphicBuffer->unlockAsync(&fd);
 230     if (err != OK) {
 231         CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__,
 232                 lockedIdx);
 233         return err;
 234     }
 235     int buf = mAcquiredBuffers[lockedIdx].mSlot;
 236     if (CC_LIKELY(fd != -1)) {
 237         sp<Fence> fence(new Fence(fd));
 238         addReleaseFenceLocked(
 239             mAcquiredBuffers[lockedIdx].mSlot,
 240             mSlots[buf].mGraphicBuffer,
 241             fence);
 242     }
 243
 244     // release the buffer if it hasn't already been freed by the BufferQueue.
 245     // This can happen, for example, when the producer of this buffer
 246     // disconnected after this buffer was acquired.
 247     if (CC_LIKELY(mAcquiredBuffers[lockedIdx].mGraphicBuffer ==
 248             mSlots[buf].mGraphicBuffer)) {
 249         releaseBufferLocked(
 250                 buf, mAcquiredBuffers[lockedIdx].mGraphicBuffer,
 251                 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
 252     }
 253
 254     AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
 255     ab.mSlot = BufferQueue::INVALID_BUFFER_SLOT;
 256     ab.mBufferPointer = NULL;
 257     ab.mGraphicBuffer.clear();
 258
 259     mCurrentLockedBuffers--;
 260     return OK;
 261 }
 262
 263 void CpuConsumer::freeBufferLocked(int slotIndex) {
 264     ConsumerBase::freeBufferLocked(slotIndex);
 265 }
 266
 267 } // namespace android