1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "Camera2-CaptureSequencer"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include <inttypes.h>
22
23 #include <utils/Log.h>
24 #include <utils/Trace.h>
25 #include <utils/Vector.h>
26
27 #include "api1/Camera2Client.h"
28 #include "api1/client2/CaptureSequencer.h"
29 #include "api1/client2/Parameters.h"
30 #include "api1/client2/ZslProcessor.h"
31
32 namespace android {
33 namespace camera2 {
34
35 /** Public members */
36
CaptureSequencer(wp<Camera2Client> client)37 CaptureSequencer::CaptureSequencer(wp<Camera2Client> client):
38 Thread(false),
39 mStartCapture(false),
40 mBusy(false),
41 mNewAEState(false),
42 mNewFrameReceived(false),
43 mNewCaptureReceived(false),
44 mNewCaptureErrorCnt(0),
45 mShutterNotified(false),
46 mHalNotifiedShutter(false),
47 mShutterCaptureId(-1),
48 mClient(client),
49 mCaptureState(IDLE),
50 mStateTransitionCount(0),
51 mTriggerId(0),
52 mTimeoutCount(0),
53 mCaptureId(Camera2Client::kCaptureRequestIdStart) {
54 ALOGV("%s", __FUNCTION__);
55 }
56
~CaptureSequencer()57 CaptureSequencer::~CaptureSequencer() {
58 ALOGV("%s: Exit", __FUNCTION__);
59 }
60
setZslProcessor(const wp<ZslProcessor> & processor)61 void CaptureSequencer::setZslProcessor(const wp<ZslProcessor>& processor) {
62 Mutex::Autolock l(mInputMutex);
63 mZslProcessor = processor;
64 }
65
startCapture()66 status_t CaptureSequencer::startCapture() {
67 ALOGV("%s", __FUNCTION__);
68 ATRACE_CALL();
69 Mutex::Autolock l(mInputMutex);
70 if (mBusy) {
71 ALOGE("%s: Already busy capturing!", __FUNCTION__);
72 return INVALID_OPERATION;
73 }
74 if (!mStartCapture) {
75 mStartCapture = true;
76 mStartCaptureSignal.signal();
77 }
78 return OK;
79 }
80
waitUntilIdle(nsecs_t timeout)81 status_t CaptureSequencer::waitUntilIdle(nsecs_t timeout) {
82 ATRACE_CALL();
83 ALOGV("%s: Waiting for idle", __FUNCTION__);
84 Mutex::Autolock l(mStateMutex);
85 status_t res = -1;
86 while (mCaptureState != IDLE) {
87 nsecs_t startTime = systemTime();
88
89 res = mStateChanged.waitRelative(mStateMutex, timeout);
90 if (res != OK) return res;
91
92 timeout -= (systemTime() - startTime);
93 }
94 ALOGV("%s: Now idle", __FUNCTION__);
95 return OK;
96 }
97
notifyAutoExposure(uint8_t newState,int triggerId)98 void CaptureSequencer::notifyAutoExposure(uint8_t newState, int triggerId) {
99 ATRACE_CALL();
100 Mutex::Autolock l(mInputMutex);
101 mAEState = newState;
102 mAETriggerId = triggerId;
103 if (!mNewAEState) {
104 mNewAEState = true;
105 mNewNotifySignal.signal();
106 }
107 }
108
notifyShutter(const CaptureResultExtras & resultExtras,nsecs_t timestamp)109 void CaptureSequencer::notifyShutter(const CaptureResultExtras& resultExtras,
110 nsecs_t timestamp) {
111 ATRACE_CALL();
112 (void) timestamp;
113 Mutex::Autolock l(mInputMutex);
114 if (!mHalNotifiedShutter && resultExtras.requestId == mShutterCaptureId) {
115 mHalNotifiedShutter = true;
116 mShutterNotifySignal.signal();
117 }
118 }
119
notifyError(int32_t errorCode,const CaptureResultExtras & resultExtras)120 void CaptureSequencer::notifyError(int32_t errorCode, const CaptureResultExtras& resultExtras) {
121 ATRACE_CALL();
122 bool jpegBufferLost = false;
123 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER) {
124 sp<Camera2Client> client = mClient.promote();
125 if (client == nullptr) {
126 return;
127 }
128 int captureStreamId = client->getCaptureStreamId();
129 if (captureStreamId == resultExtras.errorStreamId) {
130 jpegBufferLost = true;
131 }
132 } else if (errorCode ==
133 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST) {
134 if (resultExtras.requestId == mShutterCaptureId) {
135 jpegBufferLost = true;
136 }
137 }
138
139 if (jpegBufferLost) {
140 sp<MemoryBase> emptyBuffer;
141 onCaptureAvailable(/*timestamp*/0, emptyBuffer, /*captureError*/true);
142 }
143 }
144
onResultAvailable(const CaptureResult & result)145 void CaptureSequencer::onResultAvailable(const CaptureResult &result) {
146 ATRACE_CALL();
147 ALOGV("%s: New result available.", __FUNCTION__);
148 Mutex::Autolock l(mInputMutex);
149 mNewFrameId = result.mResultExtras.requestId;
150 mNewFrame = result.mMetadata;
151 if (!mNewFrameReceived) {
152 mNewFrameReceived = true;
153 mNewFrameSignal.signal();
154 }
155 }
156
onCaptureAvailable(nsecs_t timestamp,const sp<MemoryBase> & captureBuffer,bool captureError)157 void CaptureSequencer::onCaptureAvailable(nsecs_t timestamp,
158 const sp<MemoryBase>& captureBuffer, bool captureError) {
159 ATRACE_CALL();
160 ALOGV("%s", __FUNCTION__);
161 Mutex::Autolock l(mInputMutex);
162 mCaptureTimestamp = timestamp;
163 mCaptureBuffer = captureBuffer;
164 if (!mNewCaptureReceived) {
165 mNewCaptureReceived = true;
166 if (captureError) {
167 mNewCaptureErrorCnt++;
168 } else {
169 mNewCaptureErrorCnt = 0;
170 }
171 mNewCaptureSignal.signal();
172 }
173 }
174
175
dump(int fd,const Vector<String16> &)176 void CaptureSequencer::dump(int fd, const Vector<String16>& /*args*/) {
177 String8 result;
178 if (mCaptureRequest.entryCount() != 0) {
179 result = " Capture request:\n";
180 write(fd, result.string(), result.size());
181 mCaptureRequest.dump(fd, 2, 6);
182 } else {
183 result = " Capture request: undefined\n";
184 write(fd, result.string(), result.size());
185 }
186 result = String8::format(" Current capture state: %s\n",
187 kStateNames[mCaptureState]);
188 result.append(" Latest captured frame:\n");
189 write(fd, result.string(), result.size());
190 mNewFrame.dump(fd, 2, 6);
191 }
192
193 /** Private members */
194
195 const char* CaptureSequencer::kStateNames[CaptureSequencer::NUM_CAPTURE_STATES+1] =
196 {
197 "IDLE",
198 "START",
199 "ZSL_START",
200 "ZSL_WAITING",
201 "ZSL_REPROCESSING",
202 "STANDARD_START",
203 "STANDARD_PRECAPTURE_WAIT",
204 "STANDARD_CAPTURE",
205 "STANDARD_CAPTURE_WAIT",
206 "DONE",
207 "ERROR",
208 "UNKNOWN"
209 };
210
211 const CaptureSequencer::StateManager
212 CaptureSequencer::kStateManagers[CaptureSequencer::NUM_CAPTURE_STATES-1] = {
213 &CaptureSequencer::manageIdle,
214 &CaptureSequencer::manageStart,
215 &CaptureSequencer::manageZslStart,
216 &CaptureSequencer::manageZslWaiting,
217 &CaptureSequencer::manageZslReprocessing,
218 &CaptureSequencer::manageStandardStart,
219 &CaptureSequencer::manageStandardPrecaptureWait,
220 &CaptureSequencer::manageStandardCapture,
221 &CaptureSequencer::manageStandardCaptureWait,
222 &CaptureSequencer::manageDone,
223 };
224
threadLoop()225 bool CaptureSequencer::threadLoop() {
226
227 sp<Camera2Client> client = mClient.promote();
228 if (client == 0) return false;
229
230 CaptureState currentState;
231 {
232 Mutex::Autolock l(mStateMutex);
233 currentState = mCaptureState;
234 }
235
236 currentState = (this->*kStateManagers[currentState])(client);
237
238 Mutex::Autolock l(mStateMutex);
239 if (currentState != mCaptureState) {
240 if (mCaptureState != IDLE) {
241 ATRACE_ASYNC_END(kStateNames[mCaptureState], mStateTransitionCount);
242 }
243 mCaptureState = currentState;
244 mStateTransitionCount++;
245 if (mCaptureState != IDLE) {
246 ATRACE_ASYNC_BEGIN(kStateNames[mCaptureState], mStateTransitionCount);
247 }
248 ALOGV("Camera %d: New capture state %s",
249 client->getCameraId(), kStateNames[mCaptureState]);
250 mStateChanged.signal();
251 }
252
253 if (mCaptureState == ERROR) {
254 ALOGE("Camera %d: Stopping capture sequencer due to error",
255 client->getCameraId());
256 return false;
257 }
258
259 return true;
260 }
261
manageIdle(sp<Camera2Client> &)262 CaptureSequencer::CaptureState CaptureSequencer::manageIdle(
263 sp<Camera2Client> &/*client*/) {
264 status_t res;
265 Mutex::Autolock l(mInputMutex);
266 while (!mStartCapture) {
267 res = mStartCaptureSignal.waitRelative(mInputMutex,
268 kWaitDuration);
269 if (res == TIMED_OUT) break;
270 }
271 if (mStartCapture) {
272 mStartCapture = false;
273 mBusy = true;
274 return START;
275 }
276 return IDLE;
277 }
278
manageDone(sp<Camera2Client> & client)279 CaptureSequencer::CaptureState CaptureSequencer::manageDone(sp<Camera2Client> &client) {
280 status_t res = OK;
281 ATRACE_CALL();
282 mCaptureId++;
283 if (mCaptureId >= Camera2Client::kCaptureRequestIdEnd) {
284 mCaptureId = Camera2Client::kCaptureRequestIdStart;
285 }
286 {
287 Mutex::Autolock l(mInputMutex);
288 mBusy = false;
289 }
290
291 int takePictureCounter = 0;
292 {
293 SharedParameters::Lock l(client->getParameters());
294 switch (l.mParameters.state) {
295 case Parameters::DISCONNECTED:
296 ALOGW("%s: Camera %d: Discarding image data during shutdown ",
297 __FUNCTION__, client->getCameraId());
298 res = INVALID_OPERATION;
299 break;
300 case Parameters::STILL_CAPTURE:
301 res = client->getCameraDevice()->waitUntilDrained();
302 if (res != OK) {
303 ALOGE("%s: Camera %d: Can't idle after still capture: "
304 "%s (%d)", __FUNCTION__, client->getCameraId(),
305 strerror(-res), res);
306 }
307 l.mParameters.state = Parameters::STOPPED;
308 break;
309 case Parameters::VIDEO_SNAPSHOT:
310 l.mParameters.state = Parameters::RECORD;
311 break;
312 default:
313 ALOGE("%s: Camera %d: Still image produced unexpectedly "
314 "in state %s!",
315 __FUNCTION__, client->getCameraId(),
316 Parameters::getStateName(l.mParameters.state));
317 res = INVALID_OPERATION;
318 }
319 takePictureCounter = l.mParameters.takePictureCounter;
320 }
321 sp<ZslProcessor> processor = mZslProcessor.promote();
322 if (processor != 0) {
323 ALOGV("%s: Memory optimization, clearing ZSL queue",
324 __FUNCTION__);
325 processor->clearZslQueue();
326 }
327
328 /**
329 * Fire the jpegCallback in Camera#takePicture(..., jpegCallback)
330 */
331 if (mCaptureBuffer != 0 && res == OK) {
332 ATRACE_ASYNC_END(Camera2Client::kTakepictureLabel, takePictureCounter);
333
334 Camera2Client::SharedCameraCallbacks::Lock
335 l(client->mSharedCameraCallbacks);
336 ALOGV("%s: Sending still image to client", __FUNCTION__);
337 if (l.mRemoteCallback != 0) {
338 l.mRemoteCallback->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE,
339 mCaptureBuffer, NULL);
340 } else {
341 ALOGV("%s: No client!", __FUNCTION__);
342 }
343 }
344 mCaptureBuffer.clear();
345
346 return IDLE;
347 }
348
manageStart(sp<Camera2Client> & client)349 CaptureSequencer::CaptureState CaptureSequencer::manageStart(
350 sp<Camera2Client> &client) {
351 ALOGV("%s", __FUNCTION__);
352 status_t res;
353 ATRACE_CALL();
354 SharedParameters::Lock l(client->getParameters());
355 CaptureState nextState = DONE;
356
357 res = updateCaptureRequest(l.mParameters, client);
358 if (res != OK ) {
359 ALOGE("%s: Camera %d: Can't update still image capture request: %s (%d)",
360 __FUNCTION__, client->getCameraId(), strerror(-res), res);
361 return DONE;
362 }
363
364 else if (l.mParameters.useZeroShutterLag() &&
365 l.mParameters.state == Parameters::STILL_CAPTURE &&
366 l.mParameters.flashMode != Parameters::FLASH_MODE_ON) {
367 nextState = ZSL_START;
368 } else {
369 nextState = STANDARD_START;
370 }
371 {
372 Mutex::Autolock l(mInputMutex);
373 mShutterCaptureId = mCaptureId;
374 mHalNotifiedShutter = false;
375 }
376 mShutterNotified = false;
377
378 return nextState;
379 }
380
manageZslStart(sp<Camera2Client> & client)381 CaptureSequencer::CaptureState CaptureSequencer::manageZslStart(
382 sp<Camera2Client> &client) {
383 ALOGV("%s", __FUNCTION__);
384 status_t res;
385 sp<ZslProcessor> processor = mZslProcessor.promote();
386 if (processor == 0) {
387 ALOGE("%s: No ZSL queue to use!", __FUNCTION__);
388 return DONE;
389 }
390
391 // We don't want to get partial results for ZSL capture.
392 client->registerFrameListener(mCaptureId, mCaptureId + 1,
393 this,
394 /*sendPartials*/false);
395
396 // TODO: Actually select the right thing here.
397 res = processor->pushToReprocess(mCaptureId);
398 if (res != OK) {
399 if (res == NOT_ENOUGH_DATA) {
400 ALOGV("%s: Camera %d: ZSL queue doesn't have good frame, "
401 "falling back to normal capture", __FUNCTION__,
402 client->getCameraId());
403 } else {
404 ALOGE("%s: Camera %d: Error in ZSL queue: %s (%d)",
405 __FUNCTION__, client->getCameraId(), strerror(-res), res);
406 }
407 return STANDARD_START;
408 }
409
410 SharedParameters::Lock l(client->getParameters());
411 /* warning: this also locks a SharedCameraCallbacks */
412 shutterNotifyLocked(l.mParameters, client);
413 mShutterNotified = true;
414 mTimeoutCount = kMaxTimeoutsForCaptureEnd;
415 return STANDARD_CAPTURE_WAIT;
416 }
417
manageZslWaiting(sp<Camera2Client> &)418 CaptureSequencer::CaptureState CaptureSequencer::manageZslWaiting(
419 sp<Camera2Client> &/*client*/) {
420 ALOGV("%s", __FUNCTION__);
421 return DONE;
422 }
423
manageZslReprocessing(sp<Camera2Client> &)424 CaptureSequencer::CaptureState CaptureSequencer::manageZslReprocessing(
425 sp<Camera2Client> &/*client*/) {
426 ALOGV("%s", __FUNCTION__);
427 return START;
428 }
429
manageStandardStart(sp<Camera2Client> & client)430 CaptureSequencer::CaptureState CaptureSequencer::manageStandardStart(
431 sp<Camera2Client> &client) {
432 ATRACE_CALL();
433
434 bool isAeConverged = false;
435 // Get the onFrameAvailable callback when the requestID == mCaptureId
436 // We don't want to get partial results for normal capture, as we need
437 // Get ANDROID_SENSOR_TIMESTAMP from the capture result, but partial
438 // result doesn't have to have this metadata available.
439 // TODO: Update to use the HALv3 shutter notification for remove the
440 // need for this listener and make it faster. see bug 12530628.
441 client->registerFrameListener(mCaptureId, mCaptureId + 1,
442 this,
443 /*sendPartials*/false);
444
445 {
446 Mutex::Autolock l(mInputMutex);
447 isAeConverged = (mAEState == ANDROID_CONTROL_AE_STATE_CONVERGED);
448 }
449
450 {
451 SharedParameters::Lock l(client->getParameters());
452 // Skip AE precapture when it is already converged and not in force flash mode.
453 if (l.mParameters.flashMode != Parameters::FLASH_MODE_ON && isAeConverged) {
454 return STANDARD_CAPTURE;
455 }
456
457 mTriggerId = l.mParameters.precaptureTriggerCounter++;
458 }
459 client->getCameraDevice()->triggerPrecaptureMetering(mTriggerId);
460
461 mAeInPrecapture = false;
462 mTimeoutCount = kMaxTimeoutsForPrecaptureStart;
463 return STANDARD_PRECAPTURE_WAIT;
464 }
465
manageStandardPrecaptureWait(sp<Camera2Client> &)466 CaptureSequencer::CaptureState CaptureSequencer::manageStandardPrecaptureWait(
467 sp<Camera2Client> &/*client*/) {
468 status_t res;
469 ATRACE_CALL();
470 Mutex::Autolock l(mInputMutex);
471 while (!mNewAEState) {
472 res = mNewNotifySignal.waitRelative(mInputMutex, kWaitDuration);
473 if (res == TIMED_OUT) {
474 mTimeoutCount--;
475 break;
476 }
477 }
478 if (mTimeoutCount <= 0) {
479 ALOGW("Timed out waiting for precapture %s",
480 mAeInPrecapture ? "end" : "start");
481 return STANDARD_CAPTURE;
482 }
483 if (mNewAEState) {
484 if (!mAeInPrecapture) {
485 // Waiting to see PRECAPTURE state
486 if (mAETriggerId == mTriggerId) {
487 if (mAEState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
488 ALOGV("%s: Got precapture start", __FUNCTION__);
489 mAeInPrecapture = true;
490 mTimeoutCount = kMaxTimeoutsForPrecaptureEnd;
491 } else if (mAEState == ANDROID_CONTROL_AE_STATE_CONVERGED ||
492 mAEState == ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED) {
493 // It is legal to transit to CONVERGED or FLASH_REQUIRED
494 // directly after a trigger.
495 ALOGV("%s: AE is already in good state, start capture", __FUNCTION__);
496 return STANDARD_CAPTURE;
497 }
498 }
499 } else {
500 // Waiting to see PRECAPTURE state end
501 if (mAETriggerId == mTriggerId &&
502 mAEState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
503 ALOGV("%s: Got precapture end", __FUNCTION__);
504 return STANDARD_CAPTURE;
505 }
506 }
507 mNewAEState = false;
508 }
509 return STANDARD_PRECAPTURE_WAIT;
510 }
511
manageStandardCapture(sp<Camera2Client> & client)512 CaptureSequencer::CaptureState CaptureSequencer::manageStandardCapture(
513 sp<Camera2Client> &client) {
514 status_t res;
515 ATRACE_CALL();
516 SharedParameters::Lock l(client->getParameters());
517 Vector<int32_t> outputStreams;
518
519 /**
520 * Set up output streams in the request
521 * - preview
522 * - capture/jpeg
523 * - callback (if preview callbacks enabled)
524 * - recording (if recording enabled)
525 */
526 outputStreams.push(client->getPreviewStreamId());
527
528 int captureStreamId = client->getCaptureStreamId();
529 if (captureStreamId == Camera2Client::NO_STREAM) {
530 res = client->createJpegStreamL(l.mParameters);
531 if (res != OK || client->getCaptureStreamId() == Camera2Client::NO_STREAM) {
532 ALOGE("%s: Camera %d: cannot create jpeg stream for slowJpeg mode: %s (%d)",
533 __FUNCTION__, client->getCameraId(), strerror(-res), res);
534 return DONE;
535 }
536 }
537
538 outputStreams.push(client->getCaptureStreamId());
539
540 if (l.mParameters.previewCallbackFlags &
541 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
542 outputStreams.push(client->getCallbackStreamId());
543 }
544
545 if (l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
546 outputStreams.push(client->getRecordingStreamId());
547 }
548
549 res = mCaptureRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
550 outputStreams);
551 if (res == OK) {
552 res = mCaptureRequest.update(ANDROID_REQUEST_ID,
553 &mCaptureId, 1);
554 }
555 if (res == OK) {
556 res = mCaptureRequest.sort();
557 }
558
559 if (res != OK) {
560 ALOGE("%s: Camera %d: Unable to set up still capture request: %s (%d)",
561 __FUNCTION__, client->getCameraId(), strerror(-res), res);
562 return DONE;
563 }
564
565 // Create a capture copy since CameraDeviceBase#capture takes ownership
566 CameraMetadata captureCopy = mCaptureRequest;
567 if (captureCopy.entryCount() == 0) {
568 ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
569 __FUNCTION__, client->getCameraId());
570 return DONE;
571 }
572
573 if ((l.mParameters.isDeviceZslSupported) && (l.mParameters.state != Parameters::RECORD) &&
574 (l.mParameters.state != Parameters::VIDEO_SNAPSHOT)) {
575 // If device ZSL is supported, drop all pending preview buffers to reduce the chance of
576 // rendering preview frames newer than the still frame.
577 // Additionally, preview must not get interrupted during video recording.
578 client->getCameraDevice()->dropStreamBuffers(true, client->getPreviewStreamId());
579 }
580
581 /**
582 * Clear the streaming request for still-capture pictures
583 * (as opposed to i.e. video snapshots)
584 */
585 if (l.mParameters.state == Parameters::STILL_CAPTURE) {
586 // API definition of takePicture() - stop preview before taking pic
587 res = client->stopStream();
588 if (res != OK) {
589 ALOGE("%s: Camera %d: Unable to stop preview for still capture: "
590 "%s (%d)",
591 __FUNCTION__, client->getCameraId(), strerror(-res), res);
592 return DONE;
593 }
594 }
595
596 // TODO: Capture should be atomic with setStreamingRequest here
597 res = client->getCameraDevice()->capture(captureCopy);
598 if (res != OK) {
599 ALOGE("%s: Camera %d: Unable to submit still image capture request: "
600 "%s (%d)",
601 __FUNCTION__, client->getCameraId(), strerror(-res), res);
602 return DONE;
603 }
604
605 mTimeoutCount = kMaxTimeoutsForCaptureEnd;
606 return STANDARD_CAPTURE_WAIT;
607 }
608
manageStandardCaptureWait(sp<Camera2Client> & client)609 CaptureSequencer::CaptureState CaptureSequencer::manageStandardCaptureWait(
610 sp<Camera2Client> &client) {
611 status_t res;
612 ATRACE_CALL();
613 Mutex::Autolock l(mInputMutex);
614
615
616 // Wait for shutter callback
617 while (!mHalNotifiedShutter) {
618 if (mTimeoutCount <= 0) {
619 break;
620 }
621 res = mShutterNotifySignal.waitRelative(mInputMutex, kWaitDuration);
622 if (res == TIMED_OUT) {
623 mTimeoutCount--;
624 return STANDARD_CAPTURE_WAIT;
625 }
626 }
627
628 if (mHalNotifiedShutter) {
629 if (!mShutterNotified) {
630 SharedParameters::Lock l(client->getParameters());
631 /* warning: this also locks a SharedCameraCallbacks */
632 shutterNotifyLocked(l.mParameters, client);
633 mShutterNotified = true;
634 }
635 } else if (mTimeoutCount <= 0) {
636 ALOGW("Timed out waiting for shutter notification");
637 return DONE;
638 }
639
640 // Wait for new metadata result (mNewFrame)
641 while (!mNewFrameReceived) {
642 res = mNewFrameSignal.waitRelative(mInputMutex, kWaitDuration);
643 if (res == TIMED_OUT) {
644 mTimeoutCount--;
645 break;
646 }
647 }
648
649 // Wait until jpeg was captured by JpegProcessor
650 while (mNewFrameReceived && !mNewCaptureReceived) {
651 res = mNewCaptureSignal.waitRelative(mInputMutex, kWaitDuration);
652 if (res == TIMED_OUT) {
653 mTimeoutCount--;
654 break;
655 }
656 }
657 if (mNewCaptureReceived) {
658 if (mNewCaptureErrorCnt > kMaxRetryCount) {
659 ALOGW("Exceeding multiple retry limit of %d due to buffer drop", kMaxRetryCount);
660 return DONE;
661 } else if (mNewCaptureErrorCnt > 0) {
662 ALOGW("Capture error happened, retry %d...", mNewCaptureErrorCnt);
663 mNewCaptureReceived = false;
664 return STANDARD_CAPTURE;
665 }
666 }
667
668 if (mTimeoutCount <= 0) {
669 ALOGW("Timed out waiting for capture to complete");
670 return DONE;
671 }
672 if (mNewFrameReceived && mNewCaptureReceived) {
673
674 if (mNewFrameId != mCaptureId) {
675 ALOGW("Mismatched capture frame IDs: Expected %d, got %d",
676 mCaptureId, mNewFrameId);
677 }
678 camera_metadata_entry_t entry;
679 entry = mNewFrame.find(ANDROID_SENSOR_TIMESTAMP);
680 if (entry.count == 0) {
681 ALOGE("No timestamp field in capture frame!");
682 } else if (entry.count == 1) {
683 if (entry.data.i64[0] != mCaptureTimestamp) {
684 ALOGW("Mismatched capture timestamps: Metadata frame %" PRId64 ","
685 " captured buffer %" PRId64,
686 entry.data.i64[0],
687 mCaptureTimestamp);
688 }
689 } else {
690 ALOGE("Timestamp metadata is malformed!");
691 }
692 client->removeFrameListener(mCaptureId, mCaptureId + 1, this);
693
694 mNewFrameReceived = false;
695 mNewCaptureReceived = false;
696 return DONE;
697 }
698 return STANDARD_CAPTURE_WAIT;
699 }
700
updateCaptureRequest(const Parameters & params,sp<Camera2Client> & client)701 status_t CaptureSequencer::updateCaptureRequest(const Parameters ¶ms,
702 sp<Camera2Client> &client) {
703 ATRACE_CALL();
704 status_t res;
705 uint8_t captureIntent = static_cast<uint8_t>(ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE);
706
707 if (mCaptureRequest.entryCount() == 0) {
708 res = client->getCameraDevice()->createDefaultRequest(
709 CAMERA2_TEMPLATE_STILL_CAPTURE,
710 &mCaptureRequest);
711 if (res != OK) {
712 ALOGE("%s: Camera %d: Unable to create default still image request:"
713 " %s (%d)", __FUNCTION__, client->getCameraId(),
714 strerror(-res), res);
715 return res;
716 }
717 }
718
719 if (params.state == Parameters::VIDEO_SNAPSHOT) {
720 captureIntent = static_cast<uint8_t>(ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT);
721 }
722 res = mCaptureRequest.update(ANDROID_CONTROL_CAPTURE_INTENT, &captureIntent, 1);
723 if (res != OK) {
724 ALOGE("%s: Camera %d: Unable to update capture intent: %s (%d)",
725 __FUNCTION__, client->getCameraId(), strerror(-res), res);
726 return res;
727 }
728
729 res = params.updateRequest(&mCaptureRequest);
730 if (res != OK) {
731 ALOGE("%s: Camera %d: Unable to update common entries of capture "
732 "request: %s (%d)", __FUNCTION__, client->getCameraId(),
733 strerror(-res), res);
734 return res;
735 }
736
737 res = params.updateRequestJpeg(&mCaptureRequest);
738 if (res != OK) {
739 ALOGE("%s: Camera %d: Unable to update JPEG entries of capture "
740 "request: %s (%d)", __FUNCTION__, client->getCameraId(),
741 strerror(-res), res);
742 return res;
743 }
744
745 return OK;
746 }
747
shutterNotifyLocked(const Parameters & params,const sp<Camera2Client> & client)748 /*static*/ void CaptureSequencer::shutterNotifyLocked(const Parameters ¶ms,
749 const sp<Camera2Client>& client) {
750 ATRACE_CALL();
751
752 if (params.state == Parameters::STILL_CAPTURE
753 && params.playShutterSound) {
754 client->getCameraService()->playSound(CameraService::SOUND_SHUTTER);
755 }
756
757 {
758 Camera2Client::SharedCameraCallbacks::Lock
759 l(client->mSharedCameraCallbacks);
760
761 ALOGV("%s: Notifying of shutter close to client", __FUNCTION__);
762 if (l.mRemoteCallback != 0) {
763 // ShutterCallback
764 l.mRemoteCallback->notifyCallback(CAMERA_MSG_SHUTTER,
765 /*ext1*/0, /*ext2*/0);
766
767 // RawCallback with null buffer
768 l.mRemoteCallback->notifyCallback(CAMERA_MSG_RAW_IMAGE_NOTIFY,
769 /*ext1*/0, /*ext2*/0);
770 } else {
771 ALOGV("%s: No client!", __FUNCTION__);
772 }
773 }
774 }
775
776
777 }; // namespace camera2
778 }; // namespace android
779