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