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