Camera3Stream.cpp revision 1754351d9199721e7e7943461689e399ef015260 
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-Stream"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <utils/Log.h>
22#include <utils/Trace.h>
23#include "device3/Camera3Stream.h"
24#include "device3/StatusTracker.h"
25
26#include <cutils/properties.h>
27
28namespace android {
29
30namespace camera3 {
31
32Camera3Stream::~Camera3Stream() {
33    sp<StatusTracker> statusTracker = mStatusTracker.promote();
34    if (statusTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) {
35        statusTracker->removeComponent(mStatusId);
36    }
37}
38
39Camera3Stream* Camera3Stream::cast(camera3_stream *stream) {
40    return static_cast<Camera3Stream*>(stream);
41}
42
43const Camera3Stream* Camera3Stream::cast(const camera3_stream *stream) {
44    return static_cast<const Camera3Stream*>(stream);
45}
46
47Camera3Stream::Camera3Stream(int id,
48        camera3_stream_type type,
49        uint32_t width, uint32_t height, size_t maxSize, int format) :
50    camera3_stream(),
51    mId(id),
52    mName(String8::format("Camera3Stream[%d]", id)),
53    mMaxSize(maxSize),
54    mState(STATE_CONSTRUCTED),
55    mStatusId(StatusTracker::NO_STATUS_ID) {
56
57    camera3_stream::stream_type = type;
58    camera3_stream::width = width;
59    camera3_stream::height = height;
60    camera3_stream::format = format;
61    camera3_stream::usage = 0;
62    camera3_stream::max_buffers = 0;
63    camera3_stream::priv = NULL;
64
65    if (format == HAL_PIXEL_FORMAT_BLOB && maxSize == 0) {
66        ALOGE("%s: BLOB format with size == 0", __FUNCTION__);
67        mState = STATE_ERROR;
68    }
69}
70
71int Camera3Stream::getId() const {
72    return mId;
73}
74
75uint32_t Camera3Stream::getWidth() const {
76    return camera3_stream::width;
77}
78
79uint32_t Camera3Stream::getHeight() const {
80    return camera3_stream::height;
81}
82
83int Camera3Stream::getFormat() const {
84    return camera3_stream::format;
85}
86
87camera3_stream* Camera3Stream::startConfiguration() {
88    ATRACE_CALL();
89    Mutex::Autolock l(mLock);
90    status_t res;
91
92    switch (mState) {
93        case STATE_ERROR:
94            ALOGE("%s: In error state", __FUNCTION__);
95            return NULL;
96        case STATE_CONSTRUCTED:
97            // OK
98            break;
99        case STATE_IN_CONFIG:
100        case STATE_IN_RECONFIG:
101            // Can start config again with no trouble; but don't redo
102            // oldUsage/oldMaxBuffers
103            return this;
104        case STATE_CONFIGURED:
105            if (stream_type == CAMERA3_STREAM_INPUT) {
106                ALOGE("%s: Cannot configure an input stream twice",
107                        __FUNCTION__);
108                return NULL;
109            } else if (hasOutstandingBuffersLocked()) {
110                ALOGE("%s: Cannot configure stream; has outstanding buffers",
111                        __FUNCTION__);
112                return NULL;
113            }
114            break;
115        default:
116            ALOGE("%s: Unknown state %d", __FUNCTION__, mState);
117            return NULL;
118    }
119
120    oldUsage = camera3_stream::usage;
121    oldMaxBuffers = camera3_stream::max_buffers;
122
123    res = getEndpointUsage(&(camera3_stream::usage));
124    if (res != OK) {
125        ALOGE("%s: Cannot query consumer endpoint usage!",
126                __FUNCTION__);
127        return NULL;
128    }
129
130    // Stop tracking if currently doing so
131    if (mStatusId != StatusTracker::NO_STATUS_ID) {
132        sp<StatusTracker> statusTracker = mStatusTracker.promote();
133        if (statusTracker != 0) {
134            statusTracker->removeComponent(mStatusId);
135        }
136        mStatusId = StatusTracker::NO_STATUS_ID;
137    }
138
139    if (mState == STATE_CONSTRUCTED) {
140        mState = STATE_IN_CONFIG;
141    } else { // mState == STATE_CONFIGURED
142        LOG_ALWAYS_FATAL_IF(mState != STATE_CONFIGURED, "Invalid state: 0x%x", mState);
143        mState = STATE_IN_RECONFIG;
144    }
145
146    return this;
147}
148
149bool Camera3Stream::isConfiguring() const {
150    Mutex::Autolock l(mLock);
151    return (mState == STATE_IN_CONFIG) || (mState == STATE_IN_RECONFIG);
152}
153
154status_t Camera3Stream::finishConfiguration(camera3_device *hal3Device) {
155    ATRACE_CALL();
156    Mutex::Autolock l(mLock);
157    switch (mState) {
158        case STATE_ERROR:
159            ALOGE("%s: In error state", __FUNCTION__);
160            return INVALID_OPERATION;
161        case STATE_IN_CONFIG:
162        case STATE_IN_RECONFIG:
163            // OK
164            break;
165        case STATE_CONSTRUCTED:
166        case STATE_CONFIGURED:
167            ALOGE("%s: Cannot finish configuration that hasn't been started",
168                    __FUNCTION__);
169            return INVALID_OPERATION;
170        default:
171            ALOGE("%s: Unknown state", __FUNCTION__);
172            return INVALID_OPERATION;
173    }
174
175    // Register for idle tracking
176    sp<StatusTracker> statusTracker = mStatusTracker.promote();
177    if (statusTracker != 0) {
178        mStatusId = statusTracker->addComponent();
179    }
180
181    // Check if the stream configuration is unchanged, and skip reallocation if
182    // so. As documented in hardware/camera3.h:configure_streams().
183    if (mState == STATE_IN_RECONFIG &&
184            oldUsage == camera3_stream::usage &&
185            oldMaxBuffers == camera3_stream::max_buffers) {
186        mState = STATE_CONFIGURED;
187        return OK;
188    }
189
190    status_t res;
191    res = configureQueueLocked();
192    if (res != OK) {
193        ALOGE("%s: Unable to configure stream %d queue: %s (%d)",
194                __FUNCTION__, mId, strerror(-res), res);
195        mState = STATE_ERROR;
196        return res;
197    }
198
199    res = registerBuffersLocked(hal3Device);
200    if (res != OK) {
201        ALOGE("%s: Unable to register stream buffers with HAL: %s (%d)",
202                __FUNCTION__, strerror(-res), res);
203        mState = STATE_ERROR;
204        return res;
205    }
206
207    mState = STATE_CONFIGURED;
208
209    return res;
210}
211
212status_t Camera3Stream::cancelConfiguration() {
213    ATRACE_CALL();
214    Mutex::Autolock l(mLock);
215    switch (mState) {
216        case STATE_ERROR:
217            ALOGE("%s: In error state", __FUNCTION__);
218            return INVALID_OPERATION;
219        case STATE_IN_CONFIG:
220        case STATE_IN_RECONFIG:
221            // OK
222            break;
223        case STATE_CONSTRUCTED:
224        case STATE_CONFIGURED:
225            ALOGE("%s: Cannot cancel configuration that hasn't been started",
226                    __FUNCTION__);
227            return INVALID_OPERATION;
228        default:
229            ALOGE("%s: Unknown state", __FUNCTION__);
230            return INVALID_OPERATION;
231    }
232
233    camera3_stream::usage = oldUsage;
234    camera3_stream::max_buffers = oldMaxBuffers;
235
236    mState = STATE_CONSTRUCTED;
237
238    return OK;
239}
240
241status_t Camera3Stream::getBuffer(camera3_stream_buffer *buffer) {
242    ATRACE_CALL();
243    Mutex::Autolock l(mLock);
244    status_t res = OK;
245
246    // This function should be only called when the stream is configured already.
247    if (mState != STATE_CONFIGURED) {
248        ALOGE("%s: Stream %d: Can't get buffers if stream is not in CONFIGURED state %d",
249                __FUNCTION__, mId, mState);
250        return INVALID_OPERATION;
251    }
252
253    // Wait for new buffer returned back if we are running into the limit.
254    if (getHandoutOutputBufferCountLocked() == camera3_stream::max_buffers) {
255        ALOGV("%s: Already dequeued max output buffers (%d), wait for next returned one.",
256                __FUNCTION__, camera3_stream::max_buffers);
257        res = mOutputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration);
258        if (res != OK) {
259            if (res == TIMED_OUT) {
260                ALOGE("%s: wait for output buffer return timed out after %lldms", __FUNCTION__,
261                        kWaitForBufferDuration / 1000000LL);
262            }
263            return res;
264        }
265    }
266
267    res = getBufferLocked(buffer);
268    if (res == OK) {
269        fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/true);
270    }
271
272    return res;
273}
274
275status_t Camera3Stream::returnBuffer(const camera3_stream_buffer &buffer,
276        nsecs_t timestamp) {
277    ATRACE_CALL();
278    Mutex::Autolock l(mLock);
279
280    /**
281     * TODO: Check that the state is valid first.
282     *
283     * <HAL3.2 IN_CONFIG and IN_RECONFIG in addition to CONFIGURED.
284     * >= HAL3.2 CONFIGURED only
285     *
286     * Do this for getBuffer as well.
287     */
288    status_t res = returnBufferLocked(buffer, timestamp);
289    if (res == OK) {
290        fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/true);
291        mOutputBufferReturnedSignal.signal();
292    }
293
294    return res;
295}
296
297status_t Camera3Stream::getInputBuffer(camera3_stream_buffer *buffer) {
298    ATRACE_CALL();
299    Mutex::Autolock l(mLock);
300    status_t res = OK;
301
302    // This function should be only called when the stream is configured already.
303    if (mState != STATE_CONFIGURED) {
304        ALOGE("%s: Stream %d: Can't get input buffers if stream is not in CONFIGURED state %d",
305                __FUNCTION__, mId, mState);
306        return INVALID_OPERATION;
307    }
308
309    // Wait for new buffer returned back if we are running into the limit.
310    if (getHandoutInputBufferCountLocked() == camera3_stream::max_buffers) {
311        ALOGV("%s: Already dequeued max input buffers (%d), wait for next returned one.",
312                __FUNCTION__, camera3_stream::max_buffers);
313        res = mInputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration);
314        if (res != OK) {
315            if (res == TIMED_OUT) {
316                ALOGE("%s: wait for input buffer return timed out after %lldms", __FUNCTION__,
317                        kWaitForBufferDuration / 1000000LL);
318            }
319            return res;
320        }
321    }
322
323    res = getInputBufferLocked(buffer);
324    if (res == OK) {
325        fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/false);
326    }
327
328    return res;
329}
330
331status_t Camera3Stream::returnInputBuffer(const camera3_stream_buffer &buffer) {
332    ATRACE_CALL();
333    Mutex::Autolock l(mLock);
334
335    status_t res = returnInputBufferLocked(buffer);
336    if (res == OK) {
337        fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/false);
338        mInputBufferReturnedSignal.signal();
339    }
340    return res;
341}
342
343void Camera3Stream::fireBufferListenersLocked(
344        const camera3_stream_buffer& /*buffer*/, bool acquired, bool output) {
345    List<wp<Camera3StreamBufferListener> >::iterator it, end;
346
347    // TODO: finish implementing
348
349    Camera3StreamBufferListener::BufferInfo info =
350        Camera3StreamBufferListener::BufferInfo();
351    info.mOutput = output;
352    // TODO: rest of fields
353
354    for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
355         it != end;
356         ++it) {
357
358        sp<Camera3StreamBufferListener> listener = it->promote();
359        if (listener != 0) {
360            if (acquired) {
361                listener->onBufferAcquired(info);
362            } else {
363                listener->onBufferReleased(info);
364            }
365        }
366    }
367}
368
369bool Camera3Stream::hasOutstandingBuffers() const {
370    ATRACE_CALL();
371    Mutex::Autolock l(mLock);
372    return hasOutstandingBuffersLocked();
373}
374
375status_t Camera3Stream::setStatusTracker(sp<StatusTracker> statusTracker) {
376    Mutex::Autolock l(mLock);
377    sp<StatusTracker> oldTracker = mStatusTracker.promote();
378    if (oldTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) {
379        oldTracker->removeComponent(mStatusId);
380    }
381    mStatusId = StatusTracker::NO_STATUS_ID;
382    mStatusTracker = statusTracker;
383
384    return OK;
385}
386
387status_t Camera3Stream::disconnect() {
388    ATRACE_CALL();
389    Mutex::Autolock l(mLock);
390    ALOGV("%s: Stream %d: Disconnecting...", __FUNCTION__, mId);
391    status_t res = disconnectLocked();
392
393    if (res == -ENOTCONN) {
394        // "Already disconnected" -- not an error
395        return OK;
396    } else {
397        return res;
398    }
399}
400
401status_t Camera3Stream::registerBuffersLocked(camera3_device *hal3Device) {
402    ATRACE_CALL();
403
404    /**
405     * >= CAMERA_DEVICE_API_VERSION_3_2:
406     *
407     * camera3_device_t->ops->register_stream_buffers() is not called and must
408     * be NULL.
409     */
410    if (hal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_2) {
411        ALOGV("%s: register_stream_buffers unused as of HAL3.2", __FUNCTION__);
412
413        if (hal3Device->ops->register_stream_buffers != NULL) {
414            ALOGE("%s: register_stream_buffers is deprecated in HAL3.2; "
415                    "must be set to NULL in camera3_device::ops", __FUNCTION__);
416            return INVALID_OPERATION;
417        } else {
418            ALOGD("%s: Skipping NULL check for deprecated register_stream_buffers", __FUNCTION__);
419        }
420
421        return OK;
422    } else {
423        ALOGV("%s: register_stream_buffers using deprecated code path", __FUNCTION__);
424    }
425
426    status_t res;
427
428    size_t bufferCount = getBufferCountLocked();
429
430    Vector<buffer_handle_t*> buffers;
431    buffers.insertAt(/*prototype_item*/NULL, /*index*/0, bufferCount);
432
433    camera3_stream_buffer_set bufferSet = camera3_stream_buffer_set();
434    bufferSet.stream = this;
435    bufferSet.num_buffers = bufferCount;
436    bufferSet.buffers = buffers.editArray();
437
438    Vector<camera3_stream_buffer_t> streamBuffers;
439    streamBuffers.insertAt(camera3_stream_buffer_t(), /*index*/0, bufferCount);
440
441    // Register all buffers with the HAL. This means getting all the buffers
442    // from the stream, providing them to the HAL with the
443    // register_stream_buffers() method, and then returning them back to the
444    // stream in the error state, since they won't have valid data.
445    //
446    // Only registered buffers can be sent to the HAL.
447
448    uint32_t bufferIdx = 0;
449    for (; bufferIdx < bufferCount; bufferIdx++) {
450        res = getBufferLocked( &streamBuffers.editItemAt(bufferIdx) );
451        if (res != OK) {
452            ALOGE("%s: Unable to get buffer %d for registration with HAL",
453                    __FUNCTION__, bufferIdx);
454            // Skip registering, go straight to cleanup
455            break;
456        }
457
458        sp<Fence> fence = new Fence(streamBuffers[bufferIdx].acquire_fence);
459        fence->waitForever("Camera3Stream::registerBuffers");
460
461        buffers.editItemAt(bufferIdx) = streamBuffers[bufferIdx].buffer;
462    }
463    if (bufferIdx == bufferCount) {
464        // Got all buffers, register with HAL
465        ALOGV("%s: Registering %zu buffers with camera HAL",
466                __FUNCTION__, bufferCount);
467        ATRACE_BEGIN("camera3->register_stream_buffers");
468        res = hal3Device->ops->register_stream_buffers(hal3Device,
469                &bufferSet);
470        ATRACE_END();
471    }
472
473    // Return all valid buffers to stream, in ERROR state to indicate
474    // they weren't filled.
475    for (size_t i = 0; i < bufferIdx; i++) {
476        streamBuffers.editItemAt(i).release_fence = -1;
477        streamBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
478        returnBufferLocked(streamBuffers[i], 0);
479    }
480
481    return res;
482}
483
484status_t Camera3Stream::getBufferLocked(camera3_stream_buffer *) {
485    ALOGE("%s: This type of stream does not support output", __FUNCTION__);
486    return INVALID_OPERATION;
487}
488status_t Camera3Stream::returnBufferLocked(const camera3_stream_buffer &,
489                                           nsecs_t) {
490    ALOGE("%s: This type of stream does not support output", __FUNCTION__);
491    return INVALID_OPERATION;
492}
493status_t Camera3Stream::getInputBufferLocked(camera3_stream_buffer *) {
494    ALOGE("%s: This type of stream does not support input", __FUNCTION__);
495    return INVALID_OPERATION;
496}
497status_t Camera3Stream::returnInputBufferLocked(
498        const camera3_stream_buffer &) {
499    ALOGE("%s: This type of stream does not support input", __FUNCTION__);
500    return INVALID_OPERATION;
501}
502
503void Camera3Stream::addBufferListener(
504        wp<Camera3StreamBufferListener> listener) {
505    Mutex::Autolock l(mLock);
506
507    List<wp<Camera3StreamBufferListener> >::iterator it, end;
508    for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
509         it != end;
510         ) {
511        if (*it == listener) {
512            ALOGE("%s: Try to add the same listener twice, ignoring...", __FUNCTION__);
513            return;
514        }
515        it++;
516    }
517
518    mBufferListenerList.push_back(listener);
519}
520
521void Camera3Stream::removeBufferListener(
522        const sp<Camera3StreamBufferListener>& listener) {
523    Mutex::Autolock l(mLock);
524
525    bool erased = true;
526    List<wp<Camera3StreamBufferListener> >::iterator it, end;
527    for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
528         it != end;
529         ) {
530
531        if (*it == listener) {
532            it = mBufferListenerList.erase(it);
533            erased = true;
534        } else {
535            ++it;
536        }
537    }
538
539    if (!erased) {
540        ALOGW("%s: Could not find listener to remove, already removed",
541              __FUNCTION__);
542    }
543}
544
545}; // namespace camera3
546
547}; // namespace android
548