Camera3Device.cpp revision abaa51d3ca31f0eda99e1d271e6dc64c877dbf58 
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-Device"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20//#define LOG_NNDEBUG 0  // Per-frame verbose logging
21
22#ifdef LOG_NNDEBUG
23#define ALOGVV(...) ALOGV(__VA_ARGS__)
24#else
25#define ALOGVV(...) ((void)0)
26#endif
27
28// Convenience macro for transient errors
29#define CLOGE(fmt, ...) ALOGE("Camera %d: %s: " fmt, mId, __FUNCTION__, \
30            ##__VA_ARGS__)
31
32// Convenience macros for transitioning to the error state
33#define SET_ERR(fmt, ...) setErrorState(   \
34    "%s: " fmt, __FUNCTION__,              \
35    ##__VA_ARGS__)
36#define SET_ERR_L(fmt, ...) setErrorStateLocked( \
37    "%s: " fmt, __FUNCTION__,                    \
38    ##__VA_ARGS__)
39
40#include <utils/Log.h>
41#include <utils/Trace.h>
42#include <utils/Timers.h>
43
44#include "device3/Camera3Device.h"
45#include "device3/Camera3OutputStream.h"
46#include "device3/Camera3InputStream.h"
47#include "device3/Camera3ZslStream.h"
48
49using namespace android::camera3;
50
51namespace android {
52
53Camera3Device::Camera3Device(int id):
54        mId(id),
55        mHal3Device(NULL),
56        mStatus(STATUS_UNINITIALIZED),
57        mNextResultFrameNumber(0),
58        mNextShutterFrameNumber(0),
59        mListener(NULL)
60{
61    ATRACE_CALL();
62    camera3_callback_ops::notify = &sNotify;
63    camera3_callback_ops::process_capture_result = &sProcessCaptureResult;
64    ALOGV("%s: Created device for camera %d", __FUNCTION__, id);
65}
66
67Camera3Device::~Camera3Device()
68{
69    ATRACE_CALL();
70    ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId);
71    disconnect();
72}
73
74int Camera3Device::getId() const {
75    return mId;
76}
77
78/**
79 * CameraDeviceBase interface
80 */
81
82status_t Camera3Device::initialize(camera_module_t *module)
83{
84    ATRACE_CALL();
85    Mutex::Autolock l(mLock);
86
87    ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId);
88    if (mStatus != STATUS_UNINITIALIZED) {
89        CLOGE("Already initialized!");
90        return INVALID_OPERATION;
91    }
92
93    /** Open HAL device */
94
95    status_t res;
96    String8 deviceName = String8::format("%d", mId);
97
98    camera3_device_t *device;
99
100    res = module->common.methods->open(&module->common, deviceName.string(),
101            reinterpret_cast<hw_device_t**>(&device));
102
103    if (res != OK) {
104        SET_ERR_L("Could not open camera: %s (%d)", strerror(-res), res);
105        return res;
106    }
107
108    /** Cross-check device version */
109
110    if (device->common.version != CAMERA_DEVICE_API_VERSION_3_0) {
111        SET_ERR_L("Could not open camera: "
112                "Camera device is not version %x, reports %x instead",
113                CAMERA_DEVICE_API_VERSION_3_0,
114                device->common.version);
115        device->common.close(&device->common);
116        return BAD_VALUE;
117    }
118
119    camera_info info;
120    res = module->get_camera_info(mId, &info);
121    if (res != OK) return res;
122
123    if (info.device_version != device->common.version) {
124        SET_ERR_L("HAL reporting mismatched camera_info version (%x)"
125                " and device version (%x).",
126                device->common.version, info.device_version);
127        device->common.close(&device->common);
128        return BAD_VALUE;
129    }
130
131    /** Initialize device with callback functions */
132
133    ATRACE_BEGIN("camera3->initialize");
134    res = device->ops->initialize(device, this);
135    ATRACE_END();
136
137    if (res != OK) {
138        SET_ERR_L("Unable to initialize HAL device: %s (%d)",
139                strerror(-res), res);
140        device->common.close(&device->common);
141        return BAD_VALUE;
142    }
143
144    /** Get vendor metadata tags */
145
146    mVendorTagOps.get_camera_vendor_section_name = NULL;
147
148    ATRACE_BEGIN("camera3->get_metadata_vendor_tag_ops");
149    device->ops->get_metadata_vendor_tag_ops(device, &mVendorTagOps);
150    ATRACE_END();
151
152    if (mVendorTagOps.get_camera_vendor_section_name != NULL) {
153        res = set_camera_metadata_vendor_tag_ops(&mVendorTagOps);
154        if (res != OK) {
155            SET_ERR_L("Unable to set tag ops: %s (%d)",
156                    strerror(-res), res);
157            device->common.close(&device->common);
158            return res;
159        }
160    }
161
162    /** Start up request queue thread */
163
164    mRequestThread = new RequestThread(this, device);
165    res = mRequestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string());
166    if (res != OK) {
167        SET_ERR_L("Unable to start request queue thread: %s (%d)",
168                strerror(-res), res);
169        device->common.close(&device->common);
170        mRequestThread.clear();
171        return res;
172    }
173
174    /** Everything is good to go */
175
176    mDeviceInfo = info.static_camera_characteristics;
177    mHal3Device = device;
178    mStatus = STATUS_IDLE;
179    mNextStreamId = 0;
180    mNeedConfig = true;
181
182    return OK;
183}
184
185status_t Camera3Device::disconnect() {
186    ATRACE_CALL();
187    Mutex::Autolock l(mLock);
188
189    ALOGV("%s: E", __FUNCTION__);
190
191    status_t res = OK;
192    if (mStatus == STATUS_UNINITIALIZED) return res;
193
194    if (mStatus == STATUS_ACTIVE ||
195            (mStatus == STATUS_ERROR && mRequestThread != NULL)) {
196        res = mRequestThread->clearRepeatingRequests();
197        if (res != OK) {
198            SET_ERR_L("Can't stop streaming");
199            // Continue to close device even in case of error
200        } else {
201            res = waitUntilDrainedLocked();
202            if (res != OK) {
203                SET_ERR_L("Timeout waiting for HAL to drain");
204                // Continue to close device even in case of error
205            }
206        }
207    }
208    assert(mStatus == STATUS_IDLE || mStatus == STATUS_ERROR);
209
210    if (mStatus == STATUS_ERROR) {
211        CLOGE("Shutting down in an error state");
212    }
213
214    if (mRequestThread != NULL) {
215        mRequestThread->requestExit();
216    }
217
218    mOutputStreams.clear();
219    mInputStream.clear();
220
221    if (mRequestThread != NULL) {
222        if (mStatus != STATUS_ERROR) {
223            // HAL may be in a bad state, so waiting for request thread
224            // (which may be stuck in the HAL processCaptureRequest call)
225            // could be dangerous.
226            mRequestThread->join();
227        }
228        mRequestThread.clear();
229    }
230
231    if (mHal3Device != NULL) {
232        mHal3Device->common.close(&mHal3Device->common);
233        mHal3Device = NULL;
234    }
235
236    mStatus = STATUS_UNINITIALIZED;
237
238    ALOGV("%s: X", __FUNCTION__);
239    return res;
240}
241
242status_t Camera3Device::dump(int fd, const Vector<String16> &args) {
243    ATRACE_CALL();
244    (void)args;
245    String8 lines;
246
247    const char *status =
248            mStatus == STATUS_ERROR         ? "ERROR" :
249            mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" :
250            mStatus == STATUS_IDLE          ? "IDLE" :
251            mStatus == STATUS_ACTIVE        ? "ACTIVE" :
252            "Unknown";
253    lines.appendFormat("    Device status: %s\n", status);
254    if (mStatus == STATUS_ERROR) {
255        lines.appendFormat("    Error cause: %s\n", mErrorCause.string());
256    }
257    lines.appendFormat("    Stream configuration:\n");
258
259    if (mInputStream != NULL) {
260        write(fd, lines.string(), lines.size());
261        mInputStream->dump(fd, args);
262    } else {
263        lines.appendFormat("      No input stream.\n");
264        write(fd, lines.string(), lines.size());
265    }
266    for (size_t i = 0; i < mOutputStreams.size(); i++) {
267        mOutputStreams[i]->dump(fd,args);
268    }
269
270    lines = String8("    In-flight requests:\n");
271    if (mInFlightMap.size() == 0) {
272        lines.append("      None\n");
273    } else {
274        for (size_t i = 0; i < mInFlightMap.size(); i++) {
275            InFlightRequest r = mInFlightMap.valueAt(i);
276            lines.appendFormat("      Frame %d |  Timestamp: %lld, metadata"
277                    " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i),
278                    r.captureTimestamp, r.haveResultMetadata ? "true" : "false",
279                    r.numBuffersLeft);
280        }
281    }
282    write(fd, lines.string(), lines.size());
283
284    if (mHal3Device != NULL) {
285        lines = String8("    HAL device dump:\n");
286        write(fd, lines.string(), lines.size());
287        mHal3Device->ops->dump(mHal3Device, fd);
288    }
289
290    return OK;
291}
292
293const CameraMetadata& Camera3Device::info() const {
294    ALOGVV("%s: E", __FUNCTION__);
295    if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED ||
296                    mStatus == STATUS_ERROR)) {
297        ALOGW("%s: Access to static info %s!", __FUNCTION__,
298                mStatus == STATUS_ERROR ?
299                "when in error state" : "before init");
300    }
301    return mDeviceInfo;
302}
303
304status_t Camera3Device::capture(CameraMetadata &request) {
305    ATRACE_CALL();
306    Mutex::Autolock l(mLock);
307
308    // TODO: take ownership of the request
309
310    switch (mStatus) {
311        case STATUS_ERROR:
312            CLOGE("Device has encountered a serious error");
313            return INVALID_OPERATION;
314        case STATUS_UNINITIALIZED:
315            CLOGE("Device not initialized");
316            return INVALID_OPERATION;
317        case STATUS_IDLE:
318        case STATUS_ACTIVE:
319            // OK
320            break;
321        default:
322            SET_ERR_L("Unexpected status: %d", mStatus);
323            return INVALID_OPERATION;
324    }
325
326    sp<CaptureRequest> newRequest = setUpRequestLocked(request);
327    if (newRequest == NULL) {
328        CLOGE("Can't create capture request");
329        return BAD_VALUE;
330    }
331
332    return mRequestThread->queueRequest(newRequest);
333}
334
335
336status_t Camera3Device::setStreamingRequest(const CameraMetadata &request) {
337    ATRACE_CALL();
338    Mutex::Autolock l(mLock);
339
340    switch (mStatus) {
341        case STATUS_ERROR:
342            CLOGE("Device has encountered a serious error");
343            return INVALID_OPERATION;
344        case STATUS_UNINITIALIZED:
345            CLOGE("Device not initialized");
346            return INVALID_OPERATION;
347        case STATUS_IDLE:
348        case STATUS_ACTIVE:
349            // OK
350            break;
351        default:
352            SET_ERR_L("Unexpected status: %d", mStatus);
353            return INVALID_OPERATION;
354    }
355
356    sp<CaptureRequest> newRepeatingRequest = setUpRequestLocked(request);
357    if (newRepeatingRequest == NULL) {
358        CLOGE("Can't create repeating request");
359        return BAD_VALUE;
360    }
361
362    RequestList newRepeatingRequests;
363    newRepeatingRequests.push_back(newRepeatingRequest);
364
365    return mRequestThread->setRepeatingRequests(newRepeatingRequests);
366}
367
368
369sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(
370        const CameraMetadata &request) {
371    status_t res;
372
373    if (mStatus == STATUS_IDLE) {
374        res = configureStreamsLocked();
375        if (res != OK) {
376            SET_ERR_L("Can't set up streams: %s (%d)", strerror(-res), res);
377            return NULL;
378        }
379    }
380
381    sp<CaptureRequest> newRequest = createCaptureRequest(request);
382    return newRequest;
383}
384
385status_t Camera3Device::clearStreamingRequest() {
386    ATRACE_CALL();
387    Mutex::Autolock l(mLock);
388
389    switch (mStatus) {
390        case STATUS_ERROR:
391            CLOGE("Device has encountered a serious error");
392            return INVALID_OPERATION;
393        case STATUS_UNINITIALIZED:
394            CLOGE("Device not initialized");
395            return INVALID_OPERATION;
396        case STATUS_IDLE:
397        case STATUS_ACTIVE:
398            // OK
399            break;
400        default:
401            SET_ERR_L("Unexpected status: %d", mStatus);
402            return INVALID_OPERATION;
403    }
404
405    return mRequestThread->clearRepeatingRequests();
406}
407
408status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) {
409    ATRACE_CALL();
410
411    return mRequestThread->waitUntilRequestProcessed(requestId, timeout);
412}
413
414status_t Camera3Device::createInputStream(
415        uint32_t width, uint32_t height, int format, int *id) {
416    ATRACE_CALL();
417    Mutex::Autolock l(mLock);
418
419    status_t res;
420    bool wasActive = false;
421
422    switch (mStatus) {
423        case STATUS_ERROR:
424            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
425            return INVALID_OPERATION;
426        case STATUS_UNINITIALIZED:
427            ALOGE("%s: Device not initialized", __FUNCTION__);
428            return INVALID_OPERATION;
429        case STATUS_IDLE:
430            // OK
431            break;
432        case STATUS_ACTIVE:
433            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
434            mRequestThread->setPaused(true);
435            res = waitUntilDrainedLocked();
436            if (res != OK) {
437                ALOGE("%s: Can't pause captures to reconfigure streams!",
438                        __FUNCTION__);
439                mStatus = STATUS_ERROR;
440                return res;
441            }
442            wasActive = true;
443            break;
444        default:
445            ALOGE("%s: Unexpected status: %d", __FUNCTION__, mStatus);
446            return INVALID_OPERATION;
447    }
448    assert(mStatus == STATUS_IDLE);
449
450    if (mInputStream != 0) {
451        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
452        return INVALID_OPERATION;
453    }
454
455    sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId,
456                width, height, format);
457
458    mInputStream = newStream;
459
460    *id = mNextStreamId++;
461
462    // Continue captures if active at start
463    if (wasActive) {
464        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
465        res = configureStreamsLocked();
466        if (res != OK) {
467            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
468                    __FUNCTION__, mNextStreamId, strerror(-res), res);
469            return res;
470        }
471        mRequestThread->setPaused(false);
472    }
473
474    return OK;
475}
476
477
478status_t Camera3Device::createZslStream(
479            uint32_t width, uint32_t height,
480            int depth,
481            /*out*/
482            int *id,
483            sp<Camera3ZslStream>* zslStream) {
484    ATRACE_CALL();
485    Mutex::Autolock l(mLock);
486
487    status_t res;
488    bool wasActive = false;
489
490    switch (mStatus) {
491        case STATUS_ERROR:
492            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
493            return INVALID_OPERATION;
494        case STATUS_UNINITIALIZED:
495            ALOGE("%s: Device not initialized", __FUNCTION__);
496            return INVALID_OPERATION;
497        case STATUS_IDLE:
498            // OK
499            break;
500        case STATUS_ACTIVE:
501            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
502            mRequestThread->setPaused(true);
503            res = waitUntilDrainedLocked();
504            if (res != OK) {
505                ALOGE("%s: Can't pause captures to reconfigure streams!",
506                        __FUNCTION__);
507                mStatus = STATUS_ERROR;
508                return res;
509            }
510            wasActive = true;
511            break;
512        default:
513            ALOGE("%s: Unexpected status: %d", __FUNCTION__, mStatus);
514            return INVALID_OPERATION;
515    }
516    assert(mStatus == STATUS_IDLE);
517
518    if (mInputStream != 0) {
519        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
520        return INVALID_OPERATION;
521    }
522
523    sp<Camera3ZslStream> newStream = new Camera3ZslStream(mNextStreamId,
524                width, height, depth);
525
526    res = mOutputStreams.add(mNextStreamId, newStream);
527    if (res < 0) {
528        ALOGE("%s: Can't add new stream to set: %s (%d)",
529                __FUNCTION__, strerror(-res), res);
530        return res;
531    }
532    mInputStream = newStream;
533
534    *id = mNextStreamId++;
535    *zslStream = newStream;
536
537    // Continue captures if active at start
538    if (wasActive) {
539        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
540        res = configureStreamsLocked();
541        if (res != OK) {
542            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
543                    __FUNCTION__, mNextStreamId, strerror(-res), res);
544            return res;
545        }
546        mRequestThread->setPaused(false);
547    }
548
549    return OK;
550}
551
552status_t Camera3Device::createStream(sp<ANativeWindow> consumer,
553        uint32_t width, uint32_t height, int format, size_t size, int *id) {
554    ATRACE_CALL();
555    Mutex::Autolock l(mLock);
556
557    status_t res;
558    bool wasActive = false;
559
560    switch (mStatus) {
561        case STATUS_ERROR:
562            CLOGE("Device has encountered a serious error");
563            return INVALID_OPERATION;
564        case STATUS_UNINITIALIZED:
565            CLOGE("Device not initialized");
566            return INVALID_OPERATION;
567        case STATUS_IDLE:
568            // OK
569            break;
570        case STATUS_ACTIVE:
571            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
572            mRequestThread->setPaused(true);
573            res = waitUntilDrainedLocked();
574            if (res != OK) {
575                ALOGE("%s: Can't pause captures to reconfigure streams!",
576                        __FUNCTION__);
577                return res;
578            }
579            wasActive = true;
580            break;
581        default:
582            SET_ERR_L("Unexpected status: %d", mStatus);
583            return INVALID_OPERATION;
584    }
585    assert(mStatus == STATUS_IDLE);
586
587    sp<Camera3OutputStream> newStream;
588    if (format == HAL_PIXEL_FORMAT_BLOB) {
589        newStream = new Camera3OutputStream(mNextStreamId, consumer,
590                width, height, size, format);
591    } else {
592        newStream = new Camera3OutputStream(mNextStreamId, consumer,
593                width, height, format);
594    }
595
596    res = mOutputStreams.add(mNextStreamId, newStream);
597    if (res < 0) {
598        SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);
599        return res;
600    }
601
602    *id = mNextStreamId++;
603    mNeedConfig = true;
604
605    // Continue captures if active at start
606    if (wasActive) {
607        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
608        res = configureStreamsLocked();
609        if (res != OK) {
610            CLOGE("Can't reconfigure device for new stream %d: %s (%d)",
611                    mNextStreamId, strerror(-res), res);
612            return res;
613        }
614        mRequestThread->setPaused(false);
615    }
616
617    return OK;
618}
619
620status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) {
621    ATRACE_CALL();
622    (void)outputId; (void)id;
623
624    CLOGE("Unimplemented");
625    return INVALID_OPERATION;
626}
627
628
629status_t Camera3Device::getStreamInfo(int id,
630        uint32_t *width, uint32_t *height, uint32_t *format) {
631    ATRACE_CALL();
632    Mutex::Autolock l(mLock);
633
634    switch (mStatus) {
635        case STATUS_ERROR:
636            CLOGE("Device has encountered a serious error");
637            return INVALID_OPERATION;
638        case STATUS_UNINITIALIZED:
639            CLOGE("Device not initialized!");
640            return INVALID_OPERATION;
641        case STATUS_IDLE:
642        case STATUS_ACTIVE:
643            // OK
644            break;
645        default:
646            SET_ERR_L("Unexpected status: %d", mStatus);
647            return INVALID_OPERATION;
648    }
649
650    ssize_t idx = mOutputStreams.indexOfKey(id);
651    if (idx == NAME_NOT_FOUND) {
652        CLOGE("Stream %d is unknown", id);
653        return idx;
654    }
655
656    if (width) *width  = mOutputStreams[idx]->getWidth();
657    if (height) *height = mOutputStreams[idx]->getHeight();
658    if (format) *format = mOutputStreams[idx]->getFormat();
659
660    return OK;
661}
662
663status_t Camera3Device::setStreamTransform(int id,
664        int transform) {
665    ATRACE_CALL();
666    Mutex::Autolock l(mLock);
667
668    switch (mStatus) {
669        case STATUS_ERROR:
670            CLOGE("Device has encountered a serious error");
671            return INVALID_OPERATION;
672        case STATUS_UNINITIALIZED:
673            CLOGE("Device not initialized");
674            return INVALID_OPERATION;
675        case STATUS_IDLE:
676        case STATUS_ACTIVE:
677            // OK
678            break;
679        default:
680            SET_ERR_L("Unexpected status: %d", mStatus);
681            return INVALID_OPERATION;
682    }
683
684    ssize_t idx = mOutputStreams.indexOfKey(id);
685    if (idx == NAME_NOT_FOUND) {
686        CLOGE("Stream %d does not exist",
687                id);
688        return BAD_VALUE;
689    }
690
691    return mOutputStreams.editValueAt(idx)->setTransform(transform);
692}
693
694status_t Camera3Device::deleteStream(int id) {
695    ATRACE_CALL();
696    Mutex::Autolock l(mLock);
697    status_t res;
698
699    ALOGV("%s: Camera %d: Deleting stream %d", __FUNCTION__, mId, id);
700
701    // CameraDevice semantics require device to already be idle before
702    // deleteStream is called, unlike for createStream.
703    if (mStatus != STATUS_IDLE) {
704        ALOGV("%s: Camera %d: Device not idle", __FUNCTION__, mId);
705        return -EBUSY;
706    }
707
708    sp<Camera3StreamInterface> deletedStream;
709    if (mInputStream != NULL && id == mInputStream->getId()) {
710        deletedStream = mInputStream;
711        mInputStream.clear();
712    } else {
713        ssize_t idx = mOutputStreams.indexOfKey(id);
714        if (idx == NAME_NOT_FOUND) {
715            CLOGE("Stream %d does not exist", id);
716            return BAD_VALUE;
717        }
718        deletedStream = mOutputStreams.editValueAt(idx);
719        mOutputStreams.removeItem(id);
720    }
721
722    // Free up the stream endpoint so that it can be used by some other stream
723    res = deletedStream->disconnect();
724    if (res != OK) {
725        SET_ERR_L("Can't disconnect deleted stream %d", id);
726        // fall through since we want to still list the stream as deleted.
727    }
728    mDeletedStreams.add(deletedStream);
729    mNeedConfig = true;
730
731    return res;
732}
733
734status_t Camera3Device::deleteReprocessStream(int id) {
735    ATRACE_CALL();
736    (void)id;
737
738    CLOGE("Unimplemented");
739    return INVALID_OPERATION;
740}
741
742
743status_t Camera3Device::createDefaultRequest(int templateId,
744        CameraMetadata *request) {
745    ATRACE_CALL();
746    ALOGV("%s: for template %d", __FUNCTION__, templateId);
747    Mutex::Autolock l(mLock);
748
749    switch (mStatus) {
750        case STATUS_ERROR:
751            CLOGE("Device has encountered a serious error");
752            return INVALID_OPERATION;
753        case STATUS_UNINITIALIZED:
754            CLOGE("Device is not initialized!");
755            return INVALID_OPERATION;
756        case STATUS_IDLE:
757        case STATUS_ACTIVE:
758            // OK
759            break;
760        default:
761            SET_ERR_L("Unexpected status: %d", mStatus);
762            return INVALID_OPERATION;
763    }
764
765    const camera_metadata_t *rawRequest;
766    ATRACE_BEGIN("camera3->construct_default_request_settings");
767    rawRequest = mHal3Device->ops->construct_default_request_settings(
768        mHal3Device, templateId);
769    ATRACE_END();
770    if (rawRequest == NULL) {
771        SET_ERR_L("HAL is unable to construct default settings for template %d",
772                templateId);
773        return DEAD_OBJECT;
774    }
775    *request = rawRequest;
776
777    return OK;
778}
779
780status_t Camera3Device::waitUntilDrained() {
781    ATRACE_CALL();
782    Mutex::Autolock l(mLock);
783
784    return waitUntilDrainedLocked();
785}
786
787status_t Camera3Device::waitUntilDrainedLocked() {
788    ATRACE_CALL();
789    status_t res;
790
791    switch (mStatus) {
792        case STATUS_UNINITIALIZED:
793        case STATUS_IDLE:
794            ALOGV("%s: Already idle", __FUNCTION__);
795            return OK;
796        case STATUS_ERROR:
797        case STATUS_ACTIVE:
798            // Need to shut down
799            break;
800        default:
801            SET_ERR_L("Unexpected status: %d",mStatus);
802            return INVALID_OPERATION;
803    }
804
805    if (mRequestThread != NULL) {
806        res = mRequestThread->waitUntilPaused(kShutdownTimeout);
807        if (res != OK) {
808            SET_ERR_L("Can't stop request thread in %f seconds!",
809                    kShutdownTimeout/1e9);
810            return res;
811        }
812    }
813    if (mInputStream != NULL) {
814        res = mInputStream->waitUntilIdle(kShutdownTimeout);
815        if (res != OK) {
816            SET_ERR_L("Can't idle input stream %d in %f seconds!",
817                    mInputStream->getId(), kShutdownTimeout/1e9);
818            return res;
819        }
820    }
821    for (size_t i = 0; i < mOutputStreams.size(); i++) {
822        res = mOutputStreams.editValueAt(i)->waitUntilIdle(kShutdownTimeout);
823        if (res != OK) {
824            SET_ERR_L("Can't idle output stream %d in %f seconds!",
825                    mOutputStreams.keyAt(i), kShutdownTimeout/1e9);
826            return res;
827        }
828    }
829
830    if (mStatus != STATUS_ERROR) {
831        mStatus = STATUS_IDLE;
832    }
833
834    return OK;
835}
836
837status_t Camera3Device::setNotifyCallback(NotificationListener *listener) {
838    ATRACE_CALL();
839    Mutex::Autolock l(mOutputLock);
840
841    if (listener != NULL && mListener != NULL) {
842        ALOGW("%s: Replacing old callback listener", __FUNCTION__);
843    }
844    mListener = listener;
845
846    return OK;
847}
848
849bool Camera3Device::willNotify3A() {
850    return false;
851}
852
853status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {
854    ATRACE_CALL();
855    status_t res;
856    Mutex::Autolock l(mOutputLock);
857
858    while (mResultQueue.empty()) {
859        res = mResultSignal.waitRelative(mOutputLock, timeout);
860        if (res == TIMED_OUT) {
861            return res;
862        } else if (res != OK) {
863            ALOGW("%s: Camera %d: No frame in %lld ns: %s (%d)",
864                    __FUNCTION__, mId, timeout, strerror(-res), res);
865            return res;
866        }
867    }
868    return OK;
869}
870
871status_t Camera3Device::getNextFrame(CameraMetadata *frame) {
872    ATRACE_CALL();
873    Mutex::Autolock l(mOutputLock);
874
875    if (mResultQueue.empty()) {
876        return NOT_ENOUGH_DATA;
877    }
878
879    CameraMetadata &result = *(mResultQueue.begin());
880    frame->acquire(result);
881    mResultQueue.erase(mResultQueue.begin());
882
883    return OK;
884}
885
886status_t Camera3Device::triggerAutofocus(uint32_t id) {
887    ATRACE_CALL();
888
889    ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id);
890    // Mix-in this trigger into the next request and only the next request.
891    RequestTrigger trigger[] = {
892        {
893            ANDROID_CONTROL_AF_TRIGGER,
894            ANDROID_CONTROL_AF_TRIGGER_START
895        },
896        {
897            ANDROID_CONTROL_AF_TRIGGER_ID,
898            static_cast<int32_t>(id)
899        },
900    };
901
902    return mRequestThread->queueTrigger(trigger,
903                                        sizeof(trigger)/sizeof(trigger[0]));
904}
905
906status_t Camera3Device::triggerCancelAutofocus(uint32_t id) {
907    ATRACE_CALL();
908
909    ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id);
910    // Mix-in this trigger into the next request and only the next request.
911    RequestTrigger trigger[] = {
912        {
913            ANDROID_CONTROL_AF_TRIGGER,
914            ANDROID_CONTROL_AF_TRIGGER_CANCEL
915        },
916        {
917            ANDROID_CONTROL_AF_TRIGGER_ID,
918            static_cast<int32_t>(id)
919        },
920    };
921
922    return mRequestThread->queueTrigger(trigger,
923                                        sizeof(trigger)/sizeof(trigger[0]));
924}
925
926status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) {
927    ATRACE_CALL();
928
929    ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id);
930    // Mix-in this trigger into the next request and only the next request.
931    RequestTrigger trigger[] = {
932        {
933            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
934            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START
935        },
936        {
937            ANDROID_CONTROL_AE_PRECAPTURE_ID,
938            static_cast<int32_t>(id)
939        },
940    };
941
942    return mRequestThread->queueTrigger(trigger,
943                                        sizeof(trigger)/sizeof(trigger[0]));
944}
945
946status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId,
947        buffer_handle_t *buffer, wp<BufferReleasedListener> listener) {
948    ATRACE_CALL();
949    (void)reprocessStreamId; (void)buffer; (void)listener;
950
951    CLOGE("Unimplemented");
952    return INVALID_OPERATION;
953}
954
955status_t Camera3Device::flush() {
956    ATRACE_CALL();
957    ALOGV("%s: Camera %d: Flushing all requests", __FUNCTION__, mId);
958
959    Mutex::Autolock l(mLock);
960
961    mRequestThread->clear();
962    return mHal3Device->ops->flush(mHal3Device);
963}
964
965/**
966 * Camera3Device private methods
967 */
968
969sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(
970        const CameraMetadata &request) {
971    ATRACE_CALL();
972    status_t res;
973
974    sp<CaptureRequest> newRequest = new CaptureRequest;
975    newRequest->mSettings = request;
976
977    camera_metadata_entry_t inputStreams =
978            newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);
979    if (inputStreams.count > 0) {
980        if (mInputStream == NULL ||
981                mInputStream->getId() != inputStreams.data.u8[0]) {
982            CLOGE("Request references unknown input stream %d",
983                    inputStreams.data.u8[0]);
984            return NULL;
985        }
986        // Lazy completion of stream configuration (allocation/registration)
987        // on first use
988        if (mInputStream->isConfiguring()) {
989            res = mInputStream->finishConfiguration(mHal3Device);
990            if (res != OK) {
991                SET_ERR_L("Unable to finish configuring input stream %d:"
992                        " %s (%d)",
993                        mInputStream->getId(), strerror(-res), res);
994                return NULL;
995            }
996        }
997
998        newRequest->mInputStream = mInputStream;
999        newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);
1000    }
1001
1002    camera_metadata_entry_t streams =
1003            newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);
1004    if (streams.count == 0) {
1005        CLOGE("Zero output streams specified!");
1006        return NULL;
1007    }
1008
1009    for (size_t i = 0; i < streams.count; i++) {
1010        int idx = mOutputStreams.indexOfKey(streams.data.u8[i]);
1011        if (idx == NAME_NOT_FOUND) {
1012            CLOGE("Request references unknown stream %d",
1013                    streams.data.u8[i]);
1014            return NULL;
1015        }
1016        sp<Camera3OutputStreamInterface> stream =
1017                mOutputStreams.editValueAt(idx);
1018
1019        // Lazy completion of stream configuration (allocation/registration)
1020        // on first use
1021        if (stream->isConfiguring()) {
1022            res = stream->finishConfiguration(mHal3Device);
1023            if (res != OK) {
1024                SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",
1025                        stream->getId(), strerror(-res), res);
1026                return NULL;
1027            }
1028        }
1029
1030        newRequest->mOutputStreams.push(stream);
1031    }
1032    newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);
1033
1034    return newRequest;
1035}
1036
1037status_t Camera3Device::configureStreamsLocked() {
1038    ATRACE_CALL();
1039    status_t res;
1040
1041    if (mStatus != STATUS_IDLE) {
1042        CLOGE("Not idle");
1043        return INVALID_OPERATION;
1044    }
1045
1046    if (!mNeedConfig) {
1047        ALOGV("%s: Skipping config, no stream changes", __FUNCTION__);
1048        mStatus = STATUS_ACTIVE;
1049        return OK;
1050    }
1051
1052    // Start configuring the streams
1053
1054    camera3_stream_configuration config;
1055
1056    config.num_streams = (mInputStream != NULL) + mOutputStreams.size();
1057
1058    Vector<camera3_stream_t*> streams;
1059    streams.setCapacity(config.num_streams);
1060
1061    if (mInputStream != NULL) {
1062        camera3_stream_t *inputStream;
1063        inputStream = mInputStream->startConfiguration();
1064        if (inputStream == NULL) {
1065            SET_ERR_L("Can't start input stream configuration");
1066            return INVALID_OPERATION;
1067        }
1068        streams.add(inputStream);
1069    }
1070
1071    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1072
1073        // Don't configure bidi streams twice, nor add them twice to the list
1074        if (mOutputStreams[i].get() ==
1075            static_cast<Camera3StreamInterface*>(mInputStream.get())) {
1076
1077            config.num_streams--;
1078            continue;
1079        }
1080
1081        camera3_stream_t *outputStream;
1082        outputStream = mOutputStreams.editValueAt(i)->startConfiguration();
1083        if (outputStream == NULL) {
1084            SET_ERR_L("Can't start output stream configuration");
1085            return INVALID_OPERATION;
1086        }
1087        streams.add(outputStream);
1088    }
1089
1090    config.streams = streams.editArray();
1091
1092    // Do the HAL configuration; will potentially touch stream
1093    // max_buffers, usage, priv fields.
1094    ATRACE_BEGIN("camera3->configure_streams");
1095    res = mHal3Device->ops->configure_streams(mHal3Device, &config);
1096    ATRACE_END();
1097
1098    if (res != OK) {
1099        SET_ERR_L("Unable to configure streams with HAL: %s (%d)",
1100                strerror(-res), res);
1101        return res;
1102    }
1103
1104    // Finish all stream configuration immediately.
1105    // TODO: Try to relax this later back to lazy completion, which should be
1106    // faster
1107
1108    if (mInputStream != NULL && mInputStream->isConfiguring()) {
1109        res = mInputStream->finishConfiguration(mHal3Device);
1110        if (res != OK) {
1111            SET_ERR_L("Can't finish configuring input stream %d: %s (%d)",
1112                    mInputStream->getId(), strerror(-res), res);
1113            return res;
1114        }
1115    }
1116
1117    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1118        sp<Camera3OutputStreamInterface> outputStream =
1119            mOutputStreams.editValueAt(i);
1120        if (outputStream->isConfiguring()) {
1121            res = outputStream->finishConfiguration(mHal3Device);
1122            if (res != OK) {
1123                SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
1124                        outputStream->getId(), strerror(-res), res);
1125                return res;
1126            }
1127        }
1128    }
1129
1130    // Request thread needs to know to avoid using repeat-last-settings protocol
1131    // across configure_streams() calls
1132    mRequestThread->configurationComplete();
1133
1134    // Finish configuring the streams lazily on first reference
1135
1136    mStatus = STATUS_ACTIVE;
1137    mNeedConfig = false;
1138
1139    return OK;
1140}
1141
1142void Camera3Device::setErrorState(const char *fmt, ...) {
1143    Mutex::Autolock l(mLock);
1144    va_list args;
1145    va_start(args, fmt);
1146
1147    setErrorStateLockedV(fmt, args);
1148
1149    va_end(args);
1150}
1151
1152void Camera3Device::setErrorStateV(const char *fmt, va_list args) {
1153    Mutex::Autolock l(mLock);
1154    setErrorStateLockedV(fmt, args);
1155}
1156
1157void Camera3Device::setErrorStateLocked(const char *fmt, ...) {
1158    va_list args;
1159    va_start(args, fmt);
1160
1161    setErrorStateLockedV(fmt, args);
1162
1163    va_end(args);
1164}
1165
1166void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
1167    // Print out all error messages to log
1168    String8 errorCause = String8::formatV(fmt, args);
1169    ALOGE("Camera %d: %s", mId, errorCause.string());
1170
1171    // But only do error state transition steps for the first error
1172    if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
1173
1174    mErrorCause = errorCause;
1175
1176    mRequestThread->setPaused(true);
1177    mStatus = STATUS_ERROR;
1178}
1179
1180/**
1181 * In-flight request management
1182 */
1183
1184status_t Camera3Device::registerInFlight(int32_t frameNumber,
1185        int32_t numBuffers) {
1186    ATRACE_CALL();
1187    Mutex::Autolock l(mInFlightLock);
1188
1189    ssize_t res;
1190    res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers));
1191    if (res < 0) return res;
1192
1193    return OK;
1194}
1195
1196/**
1197 * Camera HAL device callback methods
1198 */
1199
1200void Camera3Device::processCaptureResult(const camera3_capture_result *result) {
1201    ATRACE_CALL();
1202
1203    status_t res;
1204
1205    uint32_t frameNumber = result->frame_number;
1206    if (result->result == NULL && result->num_output_buffers == 0) {
1207        SET_ERR("No result data provided by HAL for frame %d",
1208                frameNumber);
1209        return;
1210    }
1211
1212    // Get capture timestamp from list of in-flight requests, where it was added
1213    // by the shutter notification for this frame. Then update the in-flight
1214    // status and remove the in-flight entry if all result data has been
1215    // received.
1216    nsecs_t timestamp = 0;
1217    {
1218        Mutex::Autolock l(mInFlightLock);
1219        ssize_t idx = mInFlightMap.indexOfKey(frameNumber);
1220        if (idx == NAME_NOT_FOUND) {
1221            SET_ERR("Unknown frame number for capture result: %d",
1222                    frameNumber);
1223            return;
1224        }
1225        InFlightRequest &request = mInFlightMap.editValueAt(idx);
1226        timestamp = request.captureTimestamp;
1227        if (timestamp == 0) {
1228            SET_ERR("Called before shutter notify for frame %d",
1229                    frameNumber);
1230            return;
1231        }
1232
1233        if (result->result != NULL) {
1234            if (request.haveResultMetadata) {
1235                SET_ERR("Called multiple times with metadata for frame %d",
1236                        frameNumber);
1237                return;
1238            }
1239            request.haveResultMetadata = true;
1240        }
1241
1242        request.numBuffersLeft -= result->num_output_buffers;
1243
1244        if (request.numBuffersLeft < 0) {
1245            SET_ERR("Too many buffers returned for frame %d",
1246                    frameNumber);
1247            return;
1248        }
1249
1250        if (request.haveResultMetadata && request.numBuffersLeft == 0) {
1251            ATRACE_ASYNC_END("frame capture", frameNumber);
1252            mInFlightMap.removeItemsAt(idx, 1);
1253        }
1254
1255        // Sanity check - if we have too many in-flight frames, something has
1256        // likely gone wrong
1257        if (mInFlightMap.size() > kInFlightWarnLimit) {
1258            CLOGE("In-flight list too large: %d", mInFlightMap.size());
1259        }
1260
1261    }
1262
1263    // Process the result metadata, if provided
1264    if (result->result != NULL) {
1265        Mutex::Autolock l(mOutputLock);
1266
1267        if (frameNumber != mNextResultFrameNumber) {
1268            SET_ERR("Out-of-order capture result metadata submitted! "
1269                    "(got frame number %d, expecting %d)",
1270                    frameNumber, mNextResultFrameNumber);
1271            return;
1272        }
1273        mNextResultFrameNumber++;
1274
1275        CameraMetadata &captureResult =
1276                *mResultQueue.insert(mResultQueue.end(), CameraMetadata());
1277
1278        captureResult = result->result;
1279        if (captureResult.update(ANDROID_REQUEST_FRAME_COUNT,
1280                        (int32_t*)&frameNumber, 1) != OK) {
1281            SET_ERR("Failed to set frame# in metadata (%d)",
1282                    frameNumber);
1283        } else {
1284            ALOGVV("%s: Camera %d: Set frame# in metadata (%d)",
1285                    __FUNCTION__, mId, frameNumber);
1286        }
1287
1288        // Check that there's a timestamp in the result metadata
1289
1290        camera_metadata_entry entry =
1291                captureResult.find(ANDROID_SENSOR_TIMESTAMP);
1292        if (entry.count == 0) {
1293            SET_ERR("No timestamp provided by HAL for frame %d!",
1294                    frameNumber);
1295        } else if (timestamp != entry.data.i64[0]) {
1296            SET_ERR("Timestamp mismatch between shutter notify and result"
1297                    " metadata for frame %d (%lld vs %lld respectively)",
1298                    frameNumber, timestamp, entry.data.i64[0]);
1299        }
1300    } // scope for mOutputLock
1301
1302    // Return completed buffers to their streams with the timestamp
1303
1304    for (size_t i = 0; i < result->num_output_buffers; i++) {
1305        Camera3Stream *stream =
1306                Camera3Stream::cast(result->output_buffers[i].stream);
1307        res = stream->returnBuffer(result->output_buffers[i], timestamp);
1308        // Note: stream may be deallocated at this point, if this buffer was the
1309        // last reference to it.
1310        if (res != OK) {
1311            SET_ERR("Can't return buffer %d for frame %d to its stream: "
1312                    " %s (%d)", i, frameNumber, strerror(-res), res);
1313        }
1314    }
1315
1316    // Finally, signal any waiters for new frames
1317
1318    if (result->result != NULL) {
1319        mResultSignal.signal();
1320    }
1321
1322}
1323
1324
1325
1326void Camera3Device::notify(const camera3_notify_msg *msg) {
1327    ATRACE_CALL();
1328    NotificationListener *listener;
1329    {
1330        Mutex::Autolock l(mOutputLock);
1331        listener = mListener;
1332    }
1333
1334    if (msg == NULL) {
1335        SET_ERR("HAL sent NULL notify message!");
1336        return;
1337    }
1338
1339    switch (msg->type) {
1340        case CAMERA3_MSG_ERROR: {
1341            int streamId = 0;
1342            if (msg->message.error.error_stream != NULL) {
1343                Camera3Stream *stream =
1344                        Camera3Stream::cast(
1345                                  msg->message.error.error_stream);
1346                streamId = stream->getId();
1347            }
1348            ALOGV("Camera %d: %s: HAL error, frame %d, stream %d: %d",
1349                    mId, __FUNCTION__, msg->message.error.frame_number,
1350                    streamId, msg->message.error.error_code);
1351            if (listener != NULL) {
1352                listener->notifyError(msg->message.error.error_code,
1353                        msg->message.error.frame_number, streamId);
1354            }
1355            break;
1356        }
1357        case CAMERA3_MSG_SHUTTER: {
1358            ssize_t idx;
1359            uint32_t frameNumber = msg->message.shutter.frame_number;
1360            nsecs_t timestamp = msg->message.shutter.timestamp;
1361            // Verify ordering of shutter notifications
1362            {
1363                Mutex::Autolock l(mOutputLock);
1364                if (frameNumber != mNextShutterFrameNumber) {
1365                    SET_ERR("Shutter notification out-of-order. Expected "
1366                            "notification for frame %d, got frame %d",
1367                            mNextShutterFrameNumber, frameNumber);
1368                    break;
1369                }
1370                mNextShutterFrameNumber++;
1371            }
1372
1373            // Set timestamp for the request in the in-flight tracking
1374            {
1375                Mutex::Autolock l(mInFlightLock);
1376                idx = mInFlightMap.indexOfKey(frameNumber);
1377                if (idx >= 0) {
1378                    mInFlightMap.editValueAt(idx).captureTimestamp = timestamp;
1379                }
1380            }
1381            if (idx < 0) {
1382                SET_ERR("Shutter notification for non-existent frame number %d",
1383                        frameNumber);
1384                break;
1385            }
1386            ALOGVV("Camera %d: %s: Shutter fired for frame %d at %lld",
1387                    mId, __FUNCTION__, frameNumber, timestamp);
1388            // Call listener, if any
1389            if (listener != NULL) {
1390                listener->notifyShutter(frameNumber, timestamp);
1391            }
1392            break;
1393        }
1394        default:
1395            SET_ERR("Unknown notify message from HAL: %d",
1396                    msg->type);
1397    }
1398}
1399
1400/**
1401 * RequestThread inner class methods
1402 */
1403
1404Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
1405        camera3_device_t *hal3Device) :
1406        Thread(false),
1407        mParent(parent),
1408        mHal3Device(hal3Device),
1409        mId(getId(parent)),
1410        mReconfigured(false),
1411        mDoPause(false),
1412        mPaused(true),
1413        mFrameNumber(0),
1414        mLatestRequestId(NAME_NOT_FOUND) {
1415}
1416
1417void Camera3Device::RequestThread::configurationComplete() {
1418    Mutex::Autolock l(mRequestLock);
1419    mReconfigured = true;
1420}
1421
1422status_t Camera3Device::RequestThread::queueRequest(
1423         sp<CaptureRequest> request) {
1424    Mutex::Autolock l(mRequestLock);
1425    mRequestQueue.push_back(request);
1426
1427    return OK;
1428}
1429
1430
1431status_t Camera3Device::RequestThread::queueTrigger(
1432        RequestTrigger trigger[],
1433        size_t count) {
1434
1435    Mutex::Autolock l(mTriggerMutex);
1436    status_t ret;
1437
1438    for (size_t i = 0; i < count; ++i) {
1439        ret = queueTriggerLocked(trigger[i]);
1440
1441        if (ret != OK) {
1442            return ret;
1443        }
1444    }
1445
1446    return OK;
1447}
1448
1449int Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
1450    sp<Camera3Device> d = device.promote();
1451    if (d != NULL) return d->mId;
1452    return 0;
1453}
1454
1455status_t Camera3Device::RequestThread::queueTriggerLocked(
1456        RequestTrigger trigger) {
1457
1458    uint32_t tag = trigger.metadataTag;
1459    ssize_t index = mTriggerMap.indexOfKey(tag);
1460
1461    switch (trigger.getTagType()) {
1462        case TYPE_BYTE:
1463        // fall-through
1464        case TYPE_INT32:
1465            break;
1466        default:
1467            ALOGE("%s: Type not supported: 0x%x", __FUNCTION__,
1468                    trigger.getTagType());
1469            return INVALID_OPERATION;
1470    }
1471
1472    /**
1473     * Collect only the latest trigger, since we only have 1 field
1474     * in the request settings per trigger tag, and can't send more than 1
1475     * trigger per request.
1476     */
1477    if (index != NAME_NOT_FOUND) {
1478        mTriggerMap.editValueAt(index) = trigger;
1479    } else {
1480        mTriggerMap.add(tag, trigger);
1481    }
1482
1483    return OK;
1484}
1485
1486status_t Camera3Device::RequestThread::setRepeatingRequests(
1487        const RequestList &requests) {
1488    Mutex::Autolock l(mRequestLock);
1489    mRepeatingRequests.clear();
1490    mRepeatingRequests.insert(mRepeatingRequests.begin(),
1491            requests.begin(), requests.end());
1492    return OK;
1493}
1494
1495status_t Camera3Device::RequestThread::clearRepeatingRequests() {
1496    Mutex::Autolock l(mRequestLock);
1497    mRepeatingRequests.clear();
1498    return OK;
1499}
1500
1501status_t Camera3Device::RequestThread::clear() {
1502    Mutex::Autolock l(mRequestLock);
1503    mRepeatingRequests.clear();
1504    mRequestQueue.clear();
1505    mTriggerMap.clear();
1506    return OK;
1507}
1508
1509void Camera3Device::RequestThread::setPaused(bool paused) {
1510    Mutex::Autolock l(mPauseLock);
1511    mDoPause = paused;
1512    mDoPauseSignal.signal();
1513}
1514
1515status_t Camera3Device::RequestThread::waitUntilPaused(nsecs_t timeout) {
1516    ATRACE_CALL();
1517    status_t res;
1518    Mutex::Autolock l(mPauseLock);
1519    while (!mPaused) {
1520        res = mPausedSignal.waitRelative(mPauseLock, timeout);
1521        if (res == TIMED_OUT) {
1522            return res;
1523        }
1524    }
1525    return OK;
1526}
1527
1528status_t Camera3Device::RequestThread::waitUntilRequestProcessed(
1529        int32_t requestId, nsecs_t timeout) {
1530    Mutex::Autolock l(mLatestRequestMutex);
1531    status_t res;
1532    while (mLatestRequestId != requestId) {
1533        nsecs_t startTime = systemTime();
1534
1535        res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
1536        if (res != OK) return res;
1537
1538        timeout -= (systemTime() - startTime);
1539    }
1540
1541    return OK;
1542}
1543
1544
1545
1546bool Camera3Device::RequestThread::threadLoop() {
1547
1548    status_t res;
1549
1550    // Handle paused state.
1551    if (waitIfPaused()) {
1552        return true;
1553    }
1554
1555    // Get work to do
1556
1557    sp<CaptureRequest> nextRequest = waitForNextRequest();
1558    if (nextRequest == NULL) {
1559        return true;
1560    }
1561
1562    // Create request to HAL
1563    camera3_capture_request_t request = camera3_capture_request_t();
1564    Vector<camera3_stream_buffer_t> outputBuffers;
1565
1566    // Insert any queued triggers (before metadata is locked)
1567    int32_t triggerCount;
1568    res = insertTriggers(nextRequest);
1569    if (res < 0) {
1570        SET_ERR("RequestThread: Unable to insert triggers "
1571                "(capture request %d, HAL device: %s (%d)",
1572                (mFrameNumber+1), strerror(-res), res);
1573        cleanUpFailedRequest(request, nextRequest, outputBuffers);
1574        return false;
1575    }
1576    triggerCount = res;
1577
1578    bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0);
1579
1580    // If the request is the same as last, or we had triggers last time
1581    if (mPrevRequest != nextRequest || triggersMixedIn) {
1582        /**
1583         * The request should be presorted so accesses in HAL
1584         *   are O(logn). Sidenote, sorting a sorted metadata is nop.
1585         */
1586        nextRequest->mSettings.sort();
1587        request.settings = nextRequest->mSettings.getAndLock();
1588        mPrevRequest = nextRequest;
1589        ALOGVV("%s: Request settings are NEW", __FUNCTION__);
1590
1591        IF_ALOGV() {
1592            camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
1593            find_camera_metadata_ro_entry(
1594                    request.settings,
1595                    ANDROID_CONTROL_AF_TRIGGER,
1596                    &e
1597            );
1598            if (e.count > 0) {
1599                ALOGV("%s: Request (frame num %d) had AF trigger 0x%x",
1600                      __FUNCTION__,
1601                      mFrameNumber+1,
1602                      e.data.u8[0]);
1603            }
1604        }
1605    } else {
1606        // leave request.settings NULL to indicate 'reuse latest given'
1607        ALOGVV("%s: Request settings are REUSED",
1608               __FUNCTION__);
1609    }
1610
1611    camera3_stream_buffer_t inputBuffer;
1612
1613    // Fill in buffers
1614
1615    if (nextRequest->mInputStream != NULL) {
1616        request.input_buffer = &inputBuffer;
1617        res = nextRequest->mInputStream->getInputBuffer(&inputBuffer);
1618        if (res != OK) {
1619            SET_ERR("RequestThread: Can't get input buffer, skipping request:"
1620                    " %s (%d)", strerror(-res), res);
1621            cleanUpFailedRequest(request, nextRequest, outputBuffers);
1622            return true;
1623        }
1624    } else {
1625        request.input_buffer = NULL;
1626    }
1627
1628    outputBuffers.insertAt(camera3_stream_buffer_t(), 0,
1629            nextRequest->mOutputStreams.size());
1630    request.output_buffers = outputBuffers.array();
1631    for (size_t i = 0; i < nextRequest->mOutputStreams.size(); i++) {
1632        res = nextRequest->mOutputStreams.editItemAt(i)->
1633                getBuffer(&outputBuffers.editItemAt(i));
1634        if (res != OK) {
1635            SET_ERR("RequestThread: Can't get output buffer, skipping request:"
1636                    "%s (%d)", strerror(-res), res);
1637            cleanUpFailedRequest(request, nextRequest, outputBuffers);
1638            return true;
1639        }
1640        request.num_output_buffers++;
1641    }
1642
1643    request.frame_number = mFrameNumber++;
1644
1645    // Log request in the in-flight queue
1646    sp<Camera3Device> parent = mParent.promote();
1647    if (parent == NULL) {
1648        CLOGE("RequestThread: Parent is gone");
1649        cleanUpFailedRequest(request, nextRequest, outputBuffers);
1650        return false;
1651    }
1652
1653    res = parent->registerInFlight(request.frame_number,
1654            request.num_output_buffers);
1655    if (res != OK) {
1656        SET_ERR("RequestThread: Unable to register new in-flight request:"
1657                " %s (%d)", strerror(-res), res);
1658        cleanUpFailedRequest(request, nextRequest, outputBuffers);
1659        return false;
1660    }
1661
1662    // Submit request and block until ready for next one
1663    ATRACE_ASYNC_BEGIN("frame capture", request.frame_number);
1664    ATRACE_BEGIN("camera3->process_capture_request");
1665    res = mHal3Device->ops->process_capture_request(mHal3Device, &request);
1666    ATRACE_END();
1667
1668    if (res != OK) {
1669        SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
1670                " device: %s (%d)", request.frame_number, strerror(-res), res);
1671        cleanUpFailedRequest(request, nextRequest, outputBuffers);
1672        return false;
1673    }
1674
1675    if (request.settings != NULL) {
1676        nextRequest->mSettings.unlock(request.settings);
1677    }
1678
1679    // Remove any previously queued triggers (after unlock)
1680    res = removeTriggers(mPrevRequest);
1681    if (res != OK) {
1682        SET_ERR("RequestThread: Unable to remove triggers "
1683              "(capture request %d, HAL device: %s (%d)",
1684              request.frame_number, strerror(-res), res);
1685        return false;
1686    }
1687    mPrevTriggers = triggerCount;
1688
1689    // Read android.request.id from the request settings metadata
1690    // - inform waitUntilRequestProcessed thread of a new request ID
1691    {
1692        Mutex::Autolock al(mLatestRequestMutex);
1693
1694        camera_metadata_entry_t requestIdEntry =
1695                nextRequest->mSettings.find(ANDROID_REQUEST_ID);
1696        if (requestIdEntry.count > 0) {
1697            mLatestRequestId = requestIdEntry.data.i32[0];
1698        } else {
1699            ALOGW("%s: Did not have android.request.id set in the request",
1700                  __FUNCTION__);
1701            mLatestRequestId = NAME_NOT_FOUND;
1702        }
1703
1704        mLatestRequestSignal.signal();
1705    }
1706
1707    // Return input buffer back to framework
1708    if (request.input_buffer != NULL) {
1709        Camera3Stream *stream =
1710            Camera3Stream::cast(request.input_buffer->stream);
1711        res = stream->returnInputBuffer(*(request.input_buffer));
1712        // Note: stream may be deallocated at this point, if this buffer was the
1713        // last reference to it.
1714        if (res != OK) {
1715            ALOGE("%s: RequestThread: Can't return input buffer for frame %d to"
1716                    "  its stream:%s (%d)",  __FUNCTION__,
1717                    request.frame_number, strerror(-res), res);
1718            // TODO: Report error upstream
1719        }
1720    }
1721
1722
1723
1724    return true;
1725}
1726
1727void Camera3Device::RequestThread::cleanUpFailedRequest(
1728        camera3_capture_request_t &request,
1729        sp<CaptureRequest> &nextRequest,
1730        Vector<camera3_stream_buffer_t> &outputBuffers) {
1731
1732    if (request.settings != NULL) {
1733        nextRequest->mSettings.unlock(request.settings);
1734    }
1735    if (request.input_buffer != NULL) {
1736        request.input_buffer->status = CAMERA3_BUFFER_STATUS_ERROR;
1737        nextRequest->mInputStream->returnInputBuffer(*(request.input_buffer));
1738    }
1739    for (size_t i = 0; i < request.num_output_buffers; i++) {
1740        outputBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
1741        nextRequest->mOutputStreams.editItemAt(i)->returnBuffer(
1742            outputBuffers[i], 0);
1743    }
1744}
1745
1746sp<Camera3Device::CaptureRequest>
1747        Camera3Device::RequestThread::waitForNextRequest() {
1748    status_t res;
1749    sp<CaptureRequest> nextRequest;
1750
1751    // Optimized a bit for the simple steady-state case (single repeating
1752    // request), to avoid putting that request in the queue temporarily.
1753    Mutex::Autolock l(mRequestLock);
1754
1755    while (mRequestQueue.empty()) {
1756        if (!mRepeatingRequests.empty()) {
1757            // Always atomically enqueue all requests in a repeating request
1758            // list. Guarantees a complete in-sequence set of captures to
1759            // application.
1760            const RequestList &requests = mRepeatingRequests;
1761            RequestList::const_iterator firstRequest =
1762                    requests.begin();
1763            nextRequest = *firstRequest;
1764            mRequestQueue.insert(mRequestQueue.end(),
1765                    ++firstRequest,
1766                    requests.end());
1767            // No need to wait any longer
1768            break;
1769        }
1770
1771        res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);
1772
1773        if (res == TIMED_OUT) {
1774            // Signal that we're paused by starvation
1775            Mutex::Autolock pl(mPauseLock);
1776            if (mPaused == false) {
1777                mPaused = true;
1778                mPausedSignal.signal();
1779            }
1780            // Stop waiting for now and let thread management happen
1781            return NULL;
1782        }
1783    }
1784
1785    if (nextRequest == NULL) {
1786        // Don't have a repeating request already in hand, so queue
1787        // must have an entry now.
1788        RequestList::iterator firstRequest =
1789                mRequestQueue.begin();
1790        nextRequest = *firstRequest;
1791        mRequestQueue.erase(firstRequest);
1792    }
1793
1794    // Not paused
1795    Mutex::Autolock pl(mPauseLock);
1796    mPaused = false;
1797
1798    // Check if we've reconfigured since last time, and reset the preview
1799    // request if so. Can't use 'NULL request == repeat' across configure calls.
1800    if (mReconfigured) {
1801        mPrevRequest.clear();
1802        mReconfigured = false;
1803    }
1804
1805    return nextRequest;
1806}
1807
1808bool Camera3Device::RequestThread::waitIfPaused() {
1809    status_t res;
1810    Mutex::Autolock l(mPauseLock);
1811    while (mDoPause) {
1812        // Signal that we're paused by request
1813        if (mPaused == false) {
1814            mPaused = true;
1815            mPausedSignal.signal();
1816        }
1817        res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout);
1818        if (res == TIMED_OUT) {
1819            return true;
1820        }
1821    }
1822    // We don't set mPaused to false here, because waitForNextRequest needs
1823    // to further manage the paused state in case of starvation.
1824    return false;
1825}
1826
1827void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) {
1828    sp<Camera3Device> parent = mParent.promote();
1829    if (parent != NULL) {
1830        va_list args;
1831        va_start(args, fmt);
1832
1833        parent->setErrorStateV(fmt, args);
1834
1835        va_end(args);
1836    }
1837}
1838
1839status_t Camera3Device::RequestThread::insertTriggers(
1840        const sp<CaptureRequest> &request) {
1841
1842    Mutex::Autolock al(mTriggerMutex);
1843
1844    CameraMetadata &metadata = request->mSettings;
1845    size_t count = mTriggerMap.size();
1846
1847    for (size_t i = 0; i < count; ++i) {
1848        RequestTrigger trigger = mTriggerMap.valueAt(i);
1849
1850        uint32_t tag = trigger.metadataTag;
1851        camera_metadata_entry entry = metadata.find(tag);
1852
1853        if (entry.count > 0) {
1854            /**
1855             * Already has an entry for this trigger in the request.
1856             * Rewrite it with our requested trigger value.
1857             */
1858            RequestTrigger oldTrigger = trigger;
1859
1860            oldTrigger.entryValue = entry.data.u8[0];
1861
1862            mTriggerReplacedMap.add(tag, oldTrigger);
1863        } else {
1864            /**
1865             * More typical, no trigger entry, so we just add it
1866             */
1867            mTriggerRemovedMap.add(tag, trigger);
1868        }
1869
1870        status_t res;
1871
1872        switch (trigger.getTagType()) {
1873            case TYPE_BYTE: {
1874                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
1875                res = metadata.update(tag,
1876                                      &entryValue,
1877                                      /*count*/1);
1878                break;
1879            }
1880            case TYPE_INT32:
1881                res = metadata.update(tag,
1882                                      &trigger.entryValue,
1883                                      /*count*/1);
1884                break;
1885            default:
1886                ALOGE("%s: Type not supported: 0x%x",
1887                      __FUNCTION__,
1888                      trigger.getTagType());
1889                return INVALID_OPERATION;
1890        }
1891
1892        if (res != OK) {
1893            ALOGE("%s: Failed to update request metadata with trigger tag %s"
1894                  ", value %d", __FUNCTION__, trigger.getTagName(),
1895                  trigger.entryValue);
1896            return res;
1897        }
1898
1899        ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__,
1900              trigger.getTagName(),
1901              trigger.entryValue);
1902    }
1903
1904    mTriggerMap.clear();
1905
1906    return count;
1907}
1908
1909status_t Camera3Device::RequestThread::removeTriggers(
1910        const sp<CaptureRequest> &request) {
1911    Mutex::Autolock al(mTriggerMutex);
1912
1913    CameraMetadata &metadata = request->mSettings;
1914
1915    /**
1916     * Replace all old entries with their old values.
1917     */
1918    for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) {
1919        RequestTrigger trigger = mTriggerReplacedMap.valueAt(i);
1920
1921        status_t res;
1922
1923        uint32_t tag = trigger.metadataTag;
1924        switch (trigger.getTagType()) {
1925            case TYPE_BYTE: {
1926                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
1927                res = metadata.update(tag,
1928                                      &entryValue,
1929                                      /*count*/1);
1930                break;
1931            }
1932            case TYPE_INT32:
1933                res = metadata.update(tag,
1934                                      &trigger.entryValue,
1935                                      /*count*/1);
1936                break;
1937            default:
1938                ALOGE("%s: Type not supported: 0x%x",
1939                      __FUNCTION__,
1940                      trigger.getTagType());
1941                return INVALID_OPERATION;
1942        }
1943
1944        if (res != OK) {
1945            ALOGE("%s: Failed to restore request metadata with trigger tag %s"
1946                  ", trigger value %d", __FUNCTION__,
1947                  trigger.getTagName(), trigger.entryValue);
1948            return res;
1949        }
1950    }
1951    mTriggerReplacedMap.clear();
1952
1953    /**
1954     * Remove all new entries.
1955     */
1956    for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) {
1957        RequestTrigger trigger = mTriggerRemovedMap.valueAt(i);
1958        status_t res = metadata.erase(trigger.metadataTag);
1959
1960        if (res != OK) {
1961            ALOGE("%s: Failed to erase metadata with trigger tag %s"
1962                  ", trigger value %d", __FUNCTION__,
1963                  trigger.getTagName(), trigger.entryValue);
1964            return res;
1965        }
1966    }
1967    mTriggerRemovedMap.clear();
1968
1969    return OK;
1970}
1971
1972
1973
1974/**
1975 * Static callback forwarding methods from HAL to instance
1976 */
1977
1978void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb,
1979        const camera3_capture_result *result) {
1980    Camera3Device *d =
1981            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
1982    d->processCaptureResult(result);
1983}
1984
1985void Camera3Device::sNotify(const camera3_callback_ops *cb,
1986        const camera3_notify_msg *msg) {
1987    Camera3Device *d =
1988            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
1989    d->notify(msg);
1990}
1991
1992}; // namespace android
1993