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 32namespace android { 33 34CpuConsumer::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 47CpuConsumer::~CpuConsumer() { 48 // ConsumerBase destructor does all the work. 49} 50 51 52 53void 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 63static 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 91status_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 209status_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 225status_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 263void CpuConsumer::freeBufferLocked(int slotIndex) { 264 ConsumerBase::freeBufferLocked(slotIndex); 265} 266 267} // namespace android 268