1/*
2 * Copyright (C) 2013 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 "Camera3-ZslStream"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <inttypes.h>
22
23#include <utils/Log.h>
24#include <utils/Trace.h>
25#include "Camera3ZslStream.h"
26
27typedef android::RingBufferConsumer::PinnedBufferItem PinnedBufferItem;
28
29namespace android {
30
31namespace camera3 {
32
33namespace {
34struct TimestampFinder : public RingBufferConsumer::RingBufferComparator {
35    typedef RingBufferConsumer::BufferInfo BufferInfo;
36
37    enum {
38        SELECT_I1 = -1,
39        SELECT_I2 = 1,
40        SELECT_NEITHER = 0,
41    };
42
43    TimestampFinder(nsecs_t timestamp) : mTimestamp(timestamp) {}
44    ~TimestampFinder() {}
45
46    template <typename T>
47    static void swap(T& a, T& b) {
48        T tmp = a;
49        a = b;
50        b = tmp;
51    }
52
53    /**
54     * Try to find the best candidate for a ZSL buffer.
55     * Match priority from best to worst:
56     *  1) Timestamps match.
57     *  2) Timestamp is closest to the needle (and lower).
58     *  3) Timestamp is closest to the needle (and higher).
59     *
60     */
61    virtual int compare(const BufferInfo *i1,
62                        const BufferInfo *i2) const {
63        // Try to select non-null object first.
64        if (i1 == NULL) {
65            return SELECT_I2;
66        } else if (i2 == NULL) {
67            return SELECT_I1;
68        }
69
70        // Best result: timestamp is identical
71        if (i1->mTimestamp == mTimestamp) {
72            return SELECT_I1;
73        } else if (i2->mTimestamp == mTimestamp) {
74            return SELECT_I2;
75        }
76
77        const BufferInfo* infoPtrs[2] = {
78            i1,
79            i2
80        };
81        int infoSelectors[2] = {
82            SELECT_I1,
83            SELECT_I2
84        };
85
86        // Order i1,i2 so that always i1.timestamp < i2.timestamp
87        if (i1->mTimestamp > i2->mTimestamp) {
88            swap(infoPtrs[0], infoPtrs[1]);
89            swap(infoSelectors[0], infoSelectors[1]);
90        }
91
92        // Second best: closest (lower) timestamp
93        if (infoPtrs[1]->mTimestamp < mTimestamp) {
94            return infoSelectors[1];
95        } else if (infoPtrs[0]->mTimestamp < mTimestamp) {
96            return infoSelectors[0];
97        }
98
99        // Worst: closest (higher) timestamp
100        return infoSelectors[0];
101
102        /**
103         * The above cases should cover all the possibilities,
104         * and we get an 'empty' result only if the ring buffer
105         * was empty itself
106         */
107    }
108
109    const nsecs_t mTimestamp;
110}; // struct TimestampFinder
111} // namespace anonymous
112
113Camera3ZslStream::Camera3ZslStream(int id, uint32_t width, uint32_t height,
114        int bufferCount) :
115        Camera3OutputStream(id, CAMERA3_STREAM_BIDIRECTIONAL,
116                            width, height,
117                            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
118                            HAL_DATASPACE_UNKNOWN, CAMERA3_STREAM_ROTATION_0) {
119
120    sp<IGraphicBufferProducer> producer;
121    sp<IGraphicBufferConsumer> consumer;
122    BufferQueue::createBufferQueue(&producer, &consumer);
123    mProducer = new RingBufferConsumer(consumer, GRALLOC_USAGE_HW_CAMERA_ZSL, bufferCount);
124    mProducer->setName(String8("Camera2-ZslRingBufferConsumer"));
125    mConsumer = new Surface(producer);
126}
127
128Camera3ZslStream::~Camera3ZslStream() {
129}
130
131status_t Camera3ZslStream::getInputBufferLocked(camera3_stream_buffer *buffer) {
132    ATRACE_CALL();
133
134    status_t res;
135
136    // TODO: potentially register from inputBufferLocked
137    // this should be ok, registerBuffersLocked only calls getBuffer for now
138    // register in output mode instead of input mode for ZSL streams.
139    if (mState == STATE_IN_CONFIG || mState == STATE_IN_RECONFIG) {
140        ALOGE("%s: Stream %d: Buffer registration for input streams"
141              " not implemented (state %d)",
142              __FUNCTION__, mId, mState);
143        return INVALID_OPERATION;
144    }
145
146    if ((res = getBufferPreconditionCheckLocked()) != OK) {
147        return res;
148    }
149
150    ANativeWindowBuffer* anb;
151    int fenceFd;
152
153    assert(mProducer != 0);
154
155    sp<PinnedBufferItem> bufferItem;
156    {
157        List<sp<RingBufferConsumer::PinnedBufferItem> >::iterator it, end;
158        it = mInputBufferQueue.begin();
159        end = mInputBufferQueue.end();
160
161        // Need to call enqueueInputBufferByTimestamp as a prerequisite
162        if (it == end) {
163            ALOGE("%s: Stream %d: No input buffer was queued",
164                    __FUNCTION__, mId);
165            return INVALID_OPERATION;
166        }
167        bufferItem = *it;
168        mInputBufferQueue.erase(it);
169    }
170
171    anb = bufferItem->getBufferItem().mGraphicBuffer->getNativeBuffer();
172    assert(anb != NULL);
173    fenceFd = bufferItem->getBufferItem().mFence->dup();
174
175    /**
176     * FenceFD now owned by HAL except in case of error,
177     * in which case we reassign it to acquire_fence
178     */
179    handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
180                         /*releaseFence*/-1, CAMERA3_BUFFER_STATUS_OK, /*output*/false);
181
182    mBuffersInFlight.push_back(bufferItem);
183
184    return OK;
185}
186
187status_t Camera3ZslStream::returnBufferCheckedLocked(
188            const camera3_stream_buffer &buffer,
189            nsecs_t timestamp,
190            bool output,
191            /*out*/
192            sp<Fence> *releaseFenceOut) {
193
194    if (output) {
195        // Output stream path
196        return Camera3OutputStream::returnBufferCheckedLocked(buffer,
197                                                              timestamp,
198                                                              output,
199                                                              releaseFenceOut);
200    }
201
202    /**
203     * Input stream path
204     */
205    bool bufferFound = false;
206    sp<PinnedBufferItem> bufferItem;
207    {
208        // Find the buffer we are returning
209        Vector<sp<PinnedBufferItem> >::iterator it, end;
210        for (it = mBuffersInFlight.begin(), end = mBuffersInFlight.end();
211             it != end;
212             ++it) {
213
214            const sp<PinnedBufferItem>& tmp = *it;
215            ANativeWindowBuffer *anb =
216                    tmp->getBufferItem().mGraphicBuffer->getNativeBuffer();
217            if (anb != NULL && &(anb->handle) == buffer.buffer) {
218                bufferFound = true;
219                bufferItem = tmp;
220                mBuffersInFlight.erase(it);
221                break;
222            }
223        }
224    }
225    if (!bufferFound) {
226        ALOGE("%s: Stream %d: Can't return buffer that wasn't sent to HAL",
227              __FUNCTION__, mId);
228        return INVALID_OPERATION;
229    }
230
231    int releaseFenceFd = buffer.release_fence;
232
233    if (buffer.status == CAMERA3_BUFFER_STATUS_ERROR) {
234        if (buffer.release_fence != -1) {
235            ALOGE("%s: Stream %d: HAL should not set release_fence(%d) when "
236                  "there is an error", __FUNCTION__, mId, buffer.release_fence);
237            close(buffer.release_fence);
238        }
239
240        /**
241         * Reassign release fence as the acquire fence incase of error
242         */
243        releaseFenceFd = buffer.acquire_fence;
244    }
245
246    /**
247     * Unconditionally return buffer to the buffer queue.
248     * - Fwk takes over the release_fence ownership
249     */
250    sp<Fence> releaseFence = new Fence(releaseFenceFd);
251    bufferItem->getBufferItem().mFence = releaseFence;
252    bufferItem.clear(); // dropping last reference unpins buffer
253
254    *releaseFenceOut = releaseFence;
255
256    return OK;
257}
258
259status_t Camera3ZslStream::returnInputBufferLocked(
260        const camera3_stream_buffer &buffer) {
261    ATRACE_CALL();
262
263    status_t res = returnAnyBufferLocked(buffer, /*timestamp*/0,
264                                         /*output*/false);
265
266    return res;
267}
268
269void Camera3ZslStream::dump(int fd, const Vector<String16> &args) const {
270    (void) args;
271
272    String8 lines;
273    lines.appendFormat("    Stream[%d]: ZSL\n", mId);
274    write(fd, lines.string(), lines.size());
275
276    Camera3IOStreamBase::dump(fd, args);
277
278    lines = String8();
279    lines.appendFormat("      Input buffers pending: %zu, in flight %zu\n",
280            mInputBufferQueue.size(), mBuffersInFlight.size());
281    write(fd, lines.string(), lines.size());
282}
283
284status_t Camera3ZslStream::enqueueInputBufferByTimestamp(
285        nsecs_t timestamp,
286        nsecs_t* actualTimestamp) {
287
288    Mutex::Autolock l(mLock);
289
290    TimestampFinder timestampFinder = TimestampFinder(timestamp);
291
292    sp<RingBufferConsumer::PinnedBufferItem> pinnedBuffer =
293            mProducer->pinSelectedBuffer(timestampFinder,
294                                        /*waitForFence*/false);
295
296    if (pinnedBuffer == 0) {
297        ALOGE("%s: No ZSL buffers were available yet", __FUNCTION__);
298        return NO_BUFFER_AVAILABLE;
299    }
300
301    nsecs_t actual = pinnedBuffer->getBufferItem().mTimestamp;
302
303    if (actual != timestamp) {
304        // TODO: this is problematic, we'll end up with using wrong result for this pinned buffer.
305        ALOGW("%s: ZSL buffer candidate search didn't find an exact match --"
306              " requested timestamp = %" PRId64 ", actual timestamp = %" PRId64,
307              __FUNCTION__, timestamp, actual);
308    }
309
310    mInputBufferQueue.push_back(pinnedBuffer);
311
312    if (actualTimestamp != NULL) {
313        *actualTimestamp = actual;
314    }
315
316    return OK;
317}
318
319status_t Camera3ZslStream::clearInputRingBuffer(nsecs_t* latestTimestamp) {
320    Mutex::Autolock l(mLock);
321
322    return clearInputRingBufferLocked(latestTimestamp);
323}
324
325status_t Camera3ZslStream::clearInputRingBufferLocked(nsecs_t* latestTimestamp) {
326
327    if (latestTimestamp) {
328        *latestTimestamp = mProducer->getLatestTimestamp();
329    }
330    mInputBufferQueue.clear();
331
332    return mProducer->clear();
333}
334
335status_t Camera3ZslStream::disconnectLocked() {
336    clearInputRingBufferLocked(NULL);
337
338    return Camera3OutputStream::disconnectLocked();
339}
340
341status_t Camera3ZslStream::setTransform(int /*transform*/) {
342    ALOGV("%s: Not implemented", __FUNCTION__);
343    return INVALID_OPERATION;
344}
345
346}; // namespace camera3
347
348}; // namespace android
349