CaptureSequencer.cpp revision b0fdc1ed2182fe851ef7ca98a1b4a552b53b3033
172961230a5890071bcca436eb5630172ce84ec41Andreas Huber/* 272961230a5890071bcca436eb5630172ce84ec41Andreas Huber * Copyright (C) 2012 The Android Open Source Project 372961230a5890071bcca436eb5630172ce84ec41Andreas Huber * 472961230a5890071bcca436eb5630172ce84ec41Andreas Huber * Licensed under the Apache License, Version 2.0 (the "License"); 572961230a5890071bcca436eb5630172ce84ec41Andreas Huber * you may not use this file except in compliance with the License. 672961230a5890071bcca436eb5630172ce84ec41Andreas Huber * You may obtain a copy of the License at 772961230a5890071bcca436eb5630172ce84ec41Andreas Huber * 872961230a5890071bcca436eb5630172ce84ec41Andreas Huber * http://www.apache.org/licenses/LICENSE-2.0 972961230a5890071bcca436eb5630172ce84ec41Andreas Huber * 1072961230a5890071bcca436eb5630172ce84ec41Andreas Huber * Unless required by applicable law or agreed to in writing, software 1172961230a5890071bcca436eb5630172ce84ec41Andreas Huber * distributed under the License is distributed on an "AS IS" BASIS, 1272961230a5890071bcca436eb5630172ce84ec41Andreas Huber * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1372961230a5890071bcca436eb5630172ce84ec41Andreas Huber * See the License for the specific language governing permissions and 1472961230a5890071bcca436eb5630172ce84ec41Andreas Huber * limitations under the License. 1572961230a5890071bcca436eb5630172ce84ec41Andreas Huber */ 1672961230a5890071bcca436eb5630172ce84ec41Andreas Huber 1772961230a5890071bcca436eb5630172ce84ec41Andreas Huber#define LOG_TAG "Camera2-CaptureSequencer" 1872961230a5890071bcca436eb5630172ce84ec41Andreas Huber#define ATRACE_TAG ATRACE_TAG_CAMERA 1972961230a5890071bcca436eb5630172ce84ec41Andreas Huber//#define LOG_NDEBUG 0 2072961230a5890071bcca436eb5630172ce84ec41Andreas Huber 2172961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include <inttypes.h> 2272961230a5890071bcca436eb5630172ce84ec41Andreas Huber 2372961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include <utils/Log.h> 2472961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include <utils/Trace.h> 2572961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include <utils/Vector.h> 2672961230a5890071bcca436eb5630172ce84ec41Andreas Huber 2772961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include "api1/Camera2Client.h" 282d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber#include "api1/client2/CaptureSequencer.h" 295804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar#include "api1/client2/Parameters.h" 3072961230a5890071bcca436eb5630172ce84ec41Andreas Huber#include "api1/client2/ZslProcessor.h" 316d339f1f764bbd32e3381dae7bfa7c6c575bb493Lajos Molnar 3272961230a5890071bcca436eb5630172ce84ec41Andreas Hubernamespace android { 333f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnarnamespace camera2 { 343f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar 353f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar/** Public members */ 363f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar 373f27436a9346f043f52265da1e6a74cde2bffd4dLajos MolnarCaptureSequencer::CaptureSequencer(wp<Camera2Client> client): 383f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar Thread(false), 393f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mStartCapture(false), 403f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mBusy(false), 413f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewAEState(false), 423f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewFrameReceived(false), 433f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewCaptureReceived(false), 443f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewCaptureErrorCnt(0), 453f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mShutterNotified(false), 463f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mHalNotifiedShutter(false), 473f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mShutterCaptureId(-1), 483f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mClient(client), 493f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mCaptureState(IDLE), 503f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mStateTransitionCount(0), 513f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mTriggerId(0), 523f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mTimeoutCount(0), 533f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mCaptureId(Camera2Client::kCaptureRequestIdStart), 543f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mMsgType(0) { 553f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar ALOGV("%s", __FUNCTION__); 563f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar} 573f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar 583f27436a9346f043f52265da1e6a74cde2bffd4dLajos MolnarCaptureSequencer::~CaptureSequencer() { 593f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar ALOGV("%s: Exit", __FUNCTION__); 603f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar} 6172961230a5890071bcca436eb5630172ce84ec41Andreas Huber 625804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnarvoid CaptureSequencer::setZslProcessor(wp<ZslProcessor> processor) { 635804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar Mutex::Autolock l(mInputMutex); 6472961230a5890071bcca436eb5630172ce84ec41Andreas Huber mZslProcessor = processor; 658dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa} 668dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa 678dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasastatus_t CaptureSequencer::startCapture(int msgType) { 688dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa ALOGV("%s", __FUNCTION__); 698dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa ATRACE_CALL(); 708dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa Mutex::Autolock l(mInputMutex); 718dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa if (mBusy) { 728dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa ALOGE("%s: Already busy capturing!", __FUNCTION__); 738dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa return INVALID_OPERATION; 748dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa } 758dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa if (!mStartCapture) { 768dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa mMsgType = msgType; 778dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa mStartCapture = true; 788dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa mStartCaptureSignal.signal(); 798dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa } 808dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa return OK; 818dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa} 828dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa 838dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasastatus_t CaptureSequencer::waitUntilIdle(nsecs_t timeout) { 848dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa ATRACE_CALL(); 858dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa ALOGV("%s: Waiting for idle", __FUNCTION__); 868dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa Mutex::Autolock l(mStateMutex); 878dab17305ff72298e2b4874592ac72c004c392d8Pawin Vongmasa status_t res = -1; 8814acc736e336cbd6026df781d4f411e908831815Andreas Huber while (mCaptureState != IDLE) { 8914acc736e336cbd6026df781d4f411e908831815Andreas Huber nsecs_t startTime = systemTime(); 9072961230a5890071bcca436eb5630172ce84ec41Andreas Huber 9172961230a5890071bcca436eb5630172ce84ec41Andreas Huber res = mStateChanged.waitRelative(mStateMutex, timeout); 9272961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (res != OK) return res; 935804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar 9472961230a5890071bcca436eb5630172ce84ec41Andreas Huber timeout -= (systemTime() - startTime); 95f933441648ef6a71dee783d733aac17b9508b452Andreas Huber } 96f933441648ef6a71dee783d733aac17b9508b452Andreas Huber ALOGV("%s: Now idle", __FUNCTION__); 9772961230a5890071bcca436eb5630172ce84ec41Andreas Huber return OK; 9872961230a5890071bcca436eb5630172ce84ec41Andreas Huber} 9972961230a5890071bcca436eb5630172ce84ec41Andreas Huber 10072961230a5890071bcca436eb5630172ce84ec41Andreas Hubervoid CaptureSequencer::notifyAutoExposure(uint8_t newState, int triggerId) { 10172961230a5890071bcca436eb5630172ce84ec41Andreas Huber ATRACE_CALL(); 10272961230a5890071bcca436eb5630172ce84ec41Andreas Huber Mutex::Autolock l(mInputMutex); 10372961230a5890071bcca436eb5630172ce84ec41Andreas Huber mAEState = newState; 104513d967dae82cd03e67bff17b927cf869d9bc43eLajos Molnar mAETriggerId = triggerId; 10572961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (!mNewAEState) { 1062d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber mNewAEState = true; 10772961230a5890071bcca436eb5630172ce84ec41Andreas Huber mNewNotifySignal.signal(); 10872961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 10931e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber} 11031e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber 11131e2508c75018145a8238925ff1a08cbde4e799aAndreas Hubervoid CaptureSequencer::notifyShutter(const CaptureResultExtras& resultExtras, 11231e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber nsecs_t timestamp) { 113513d967dae82cd03e67bff17b927cf869d9bc43eLajos Molnar ATRACE_CALL(); 114513d967dae82cd03e67bff17b927cf869d9bc43eLajos Molnar (void) timestamp; 11572961230a5890071bcca436eb5630172ce84ec41Andreas Huber Mutex::Autolock l(mInputMutex); 11672961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (!mHalNotifiedShutter && resultExtras.requestId == mShutterCaptureId) { 11772961230a5890071bcca436eb5630172ce84ec41Andreas Huber mHalNotifiedShutter = true; 11872961230a5890071bcca436eb5630172ce84ec41Andreas Huber mShutterNotifySignal.signal(); 11972961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 12072961230a5890071bcca436eb5630172ce84ec41Andreas Huber} 12172961230a5890071bcca436eb5630172ce84ec41Andreas Huber 12272961230a5890071bcca436eb5630172ce84ec41Andreas Hubervoid CaptureSequencer::onResultAvailable(const CaptureResult &result) { 1232d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber ATRACE_CALL(); 12472961230a5890071bcca436eb5630172ce84ec41Andreas Huber ALOGV("%s: New result available.", __FUNCTION__); 12572961230a5890071bcca436eb5630172ce84ec41Andreas Huber Mutex::Autolock l(mInputMutex); 12631e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber mNewFrameId = result.mResultExtras.requestId; 12731e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber mNewFrame = result.mMetadata; 12831e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber if (!mNewFrameReceived) { 12931e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber mNewFrameReceived = true; 1305804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar mNewFrameSignal.signal(); 13172961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 1325df775d2f509c76e76a46615fca83dba95299f6eAndreas Huber} 1335df775d2f509c76e76a46615fca83dba95299f6eAndreas Huber 1345df775d2f509c76e76a46615fca83dba95299f6eAndreas Hubervoid CaptureSequencer::onCaptureAvailable(nsecs_t timestamp, 1355df775d2f509c76e76a46615fca83dba95299f6eAndreas Huber sp<MemoryBase> captureBuffer, bool captureError) { 1365df775d2f509c76e76a46615fca83dba95299f6eAndreas Huber ATRACE_CALL(); 1373f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar ALOGV("%s", __FUNCTION__); 1383f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar Mutex::Autolock l(mInputMutex); 1393f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mCaptureTimestamp = timestamp; 1403f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mCaptureBuffer = captureBuffer; 1413f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar if (!mNewCaptureReceived) { 1423f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewCaptureReceived = true; 1433f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar if (captureError) { 1443f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar mNewCaptureErrorCnt++; 1453f27436a9346f043f52265da1e6a74cde2bffd4dLajos Molnar } else { 1465df775d2f509c76e76a46615fca83dba95299f6eAndreas Huber mNewCaptureErrorCnt = 0; 1472c2814b900a61fa07ddfff860b143fbbe9c740e9Andreas Huber } 1482c2814b900a61fa07ddfff860b143fbbe9c740e9Andreas Huber mNewCaptureSignal.signal(); 1492c2814b900a61fa07ddfff860b143fbbe9c740e9Andreas Huber } 15072961230a5890071bcca436eb5630172ce84ec41Andreas Huber} 15172961230a5890071bcca436eb5630172ce84ec41Andreas Huber 1521734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar 1531734c7d01c1567568ced29398b23abd601fd44cbLajos Molnarvoid CaptureSequencer::dump(int fd, const Vector<String16>& /*args*/) { 1541734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar String8 result; 1551734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar if (mCaptureRequest.entryCount() != 0) { 1561734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar result = " Capture request:\n"; 1571734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar write(fd, result.string(), result.size()); 1581734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar mCaptureRequest.dump(fd, 2, 6); 1591734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar } else { 1601734c7d01c1567568ced29398b23abd601fd44cbLajos Molnar result = " Capture request: undefined\n"; 161bbc2b8289458cfde931b133bad0c9d1026674ee7Andreas Huber write(fd, result.string(), result.size()); 162bbc2b8289458cfde931b133bad0c9d1026674ee7Andreas Huber } 16372961230a5890071bcca436eb5630172ce84ec41Andreas Huber result = String8::format(" Current capture state: %s\n", 16472961230a5890071bcca436eb5630172ce84ec41Andreas Huber kStateNames[mCaptureState]); 16572961230a5890071bcca436eb5630172ce84ec41Andreas Huber result.append(" Latest captured frame:\n"); 16672961230a5890071bcca436eb5630172ce84ec41Andreas Huber write(fd, result.string(), result.size()); 16772961230a5890071bcca436eb5630172ce84ec41Andreas Huber mNewFrame.dump(fd, 2, 6); 16872961230a5890071bcca436eb5630172ce84ec41Andreas Huber} 16972961230a5890071bcca436eb5630172ce84ec41Andreas Huber 17072961230a5890071bcca436eb5630172ce84ec41Andreas Huber/** Private members */ 17172961230a5890071bcca436eb5630172ce84ec41Andreas Huber 17272961230a5890071bcca436eb5630172ce84ec41Andreas Huberconst char* CaptureSequencer::kStateNames[CaptureSequencer::NUM_CAPTURE_STATES+1] = 17331e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber{ 1742d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber "IDLE", 17572961230a5890071bcca436eb5630172ce84ec41Andreas Huber "START", 17672961230a5890071bcca436eb5630172ce84ec41Andreas Huber "ZSL_START", 1775778822d86b0337407514b9372562b86edfa91cdAndreas Huber "ZSL_WAITING", 1785778822d86b0337407514b9372562b86edfa91cdAndreas Huber "ZSL_REPROCESSING", 1795778822d86b0337407514b9372562b86edfa91cdAndreas Huber "STANDARD_START", 1805778822d86b0337407514b9372562b86edfa91cdAndreas Huber "STANDARD_PRECAPTURE_WAIT", 1815778822d86b0337407514b9372562b86edfa91cdAndreas Huber "STANDARD_CAPTURE", 1825778822d86b0337407514b9372562b86edfa91cdAndreas Huber "STANDARD_CAPTURE_WAIT", 1835778822d86b0337407514b9372562b86edfa91cdAndreas Huber "DONE", 1845804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar "ERROR", 1855804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar "UNKNOWN" 18672961230a5890071bcca436eb5630172ce84ec41Andreas Huber}; 1875804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar 1885804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnarconst CaptureSequencer::StateManager 18972961230a5890071bcca436eb5630172ce84ec41Andreas Huber CaptureSequencer::kStateManagers[CaptureSequencer::NUM_CAPTURE_STATES-1] = { 19072961230a5890071bcca436eb5630172ce84ec41Andreas Huber &CaptureSequencer::manageIdle, 1915804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar &CaptureSequencer::manageStart, 1925804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar &CaptureSequencer::manageZslStart, 1935804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar &CaptureSequencer::manageZslWaiting, 19431e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber &CaptureSequencer::manageZslReprocessing, 19531e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber &CaptureSequencer::manageStandardStart, 19631e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber &CaptureSequencer::manageStandardPrecaptureWait, 19731e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber &CaptureSequencer::manageStandardCapture, 19872961230a5890071bcca436eb5630172ce84ec41Andreas Huber &CaptureSequencer::manageStandardCaptureWait, 19972961230a5890071bcca436eb5630172ce84ec41Andreas Huber &CaptureSequencer::manageDone, 20072961230a5890071bcca436eb5630172ce84ec41Andreas Huber}; 20172961230a5890071bcca436eb5630172ce84ec41Andreas Huber 20272961230a5890071bcca436eb5630172ce84ec41Andreas Huberbool CaptureSequencer::threadLoop() { 20372961230a5890071bcca436eb5630172ce84ec41Andreas Huber 20472961230a5890071bcca436eb5630172ce84ec41Andreas Huber sp<Camera2Client> client = mClient.promote(); 20572961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (client == 0) return false; 20672961230a5890071bcca436eb5630172ce84ec41Andreas Huber 20772961230a5890071bcca436eb5630172ce84ec41Andreas Huber CaptureState currentState; 20831e2508c75018145a8238925ff1a08cbde4e799aAndreas Huber { 20972961230a5890071bcca436eb5630172ce84ec41Andreas Huber Mutex::Autolock l(mStateMutex); 21072961230a5890071bcca436eb5630172ce84ec41Andreas Huber currentState = mCaptureState; 2117ea429295a2eb31f2d9256c36c1ef53a195456acLajos Molnar } 21272961230a5890071bcca436eb5630172ce84ec41Andreas Huber 2137ea429295a2eb31f2d9256c36c1ef53a195456acLajos Molnar currentState = (this->*kStateManagers[currentState])(client); 21472961230a5890071bcca436eb5630172ce84ec41Andreas Huber 21572961230a5890071bcca436eb5630172ce84ec41Andreas Huber Mutex::Autolock l(mStateMutex); 21672961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (currentState != mCaptureState) { 217e370bb62b89d2f2980f519392010ea08a24c558eAndreas Huber if (mCaptureState != IDLE) { 21872961230a5890071bcca436eb5630172ce84ec41Andreas Huber ATRACE_ASYNC_END(kStateNames[mCaptureState], mStateTransitionCount); 21972961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 22072961230a5890071bcca436eb5630172ce84ec41Andreas Huber mCaptureState = currentState; 22172961230a5890071bcca436eb5630172ce84ec41Andreas Huber mStateTransitionCount++; 22272961230a5890071bcca436eb5630172ce84ec41Andreas Huber if (mCaptureState != IDLE) { 2237ea429295a2eb31f2d9256c36c1ef53a195456acLajos Molnar ATRACE_ASYNC_BEGIN(kStateNames[mCaptureState], mStateTransitionCount); 22472961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 22572961230a5890071bcca436eb5630172ce84ec41Andreas Huber ALOGV("Camera %d: New capture state %s", 2262d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber client->getCameraId(), kStateNames[mCaptureState]); 2272d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber mStateChanged.signal(); 2282d8bedd05437b6fccdbc6bf70f673ffd86744d59Andreas Huber } 2297ea429295a2eb31f2d9256c36c1ef53a195456acLajos Molnar 2307ea429295a2eb31f2d9256c36c1ef53a195456acLajos Molnar if (mCaptureState == ERROR) { 2315804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar ALOGE("Camera %d: Stopping capture sequencer due to error", 2325804a76ac5f9f3c311f1bbbcc5ebdc8f8568ae14Lajos Molnar client->getCameraId()); 23372961230a5890071bcca436eb5630172ce84ec41Andreas Huber return false; 23472961230a5890071bcca436eb5630172ce84ec41Andreas Huber } 23572961230a5890071bcca436eb5630172ce84ec41Andreas Huber 23672961230a5890071bcca436eb5630172ce84ec41Andreas Huber return true; 23772961230a5890071bcca436eb5630172ce84ec41Andreas Huber} 23872961230a5890071bcca436eb5630172ce84ec41Andreas Huber 239CaptureSequencer::CaptureState CaptureSequencer::manageIdle( 240 sp<Camera2Client> &/*client*/) { 241 status_t res; 242 Mutex::Autolock l(mInputMutex); 243 while (!mStartCapture) { 244 res = mStartCaptureSignal.waitRelative(mInputMutex, 245 kWaitDuration); 246 if (res == TIMED_OUT) break; 247 } 248 if (mStartCapture) { 249 mStartCapture = false; 250 mBusy = true; 251 return START; 252 } 253 return IDLE; 254} 255 256CaptureSequencer::CaptureState CaptureSequencer::manageDone(sp<Camera2Client> &client) { 257 status_t res = OK; 258 ATRACE_CALL(); 259 mCaptureId++; 260 if (mCaptureId >= Camera2Client::kCaptureRequestIdEnd) { 261 mCaptureId = Camera2Client::kCaptureRequestIdStart; 262 } 263 { 264 Mutex::Autolock l(mInputMutex); 265 mBusy = false; 266 } 267 268 int takePictureCounter = 0; 269 { 270 SharedParameters::Lock l(client->getParameters()); 271 switch (l.mParameters.state) { 272 case Parameters::DISCONNECTED: 273 ALOGW("%s: Camera %d: Discarding image data during shutdown ", 274 __FUNCTION__, client->getCameraId()); 275 res = INVALID_OPERATION; 276 break; 277 case Parameters::STILL_CAPTURE: 278 res = client->getCameraDevice()->waitUntilDrained(); 279 if (res != OK) { 280 ALOGE("%s: Camera %d: Can't idle after still capture: " 281 "%s (%d)", __FUNCTION__, client->getCameraId(), 282 strerror(-res), res); 283 } 284 l.mParameters.state = Parameters::STOPPED; 285 break; 286 case Parameters::VIDEO_SNAPSHOT: 287 l.mParameters.state = Parameters::RECORD; 288 break; 289 default: 290 ALOGE("%s: Camera %d: Still image produced unexpectedly " 291 "in state %s!", 292 __FUNCTION__, client->getCameraId(), 293 Parameters::getStateName(l.mParameters.state)); 294 res = INVALID_OPERATION; 295 } 296 takePictureCounter = l.mParameters.takePictureCounter; 297 } 298 sp<ZslProcessor> processor = mZslProcessor.promote(); 299 if (processor != 0) { 300 ALOGV("%s: Memory optimization, clearing ZSL queue", 301 __FUNCTION__); 302 processor->clearZslQueue(); 303 } 304 305 /** 306 * Fire the jpegCallback in Camera#takePicture(..., jpegCallback) 307 */ 308 if (mCaptureBuffer != 0 && res == OK) { 309 ATRACE_ASYNC_END(Camera2Client::kTakepictureLabel, takePictureCounter); 310 311 Camera2Client::SharedCameraCallbacks::Lock 312 l(client->mSharedCameraCallbacks); 313 ALOGV("%s: Sending still image to client", __FUNCTION__); 314 if (l.mRemoteCallback != 0) { 315 l.mRemoteCallback->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, 316 mCaptureBuffer, NULL); 317 } else { 318 ALOGV("%s: No client!", __FUNCTION__); 319 } 320 } 321 mCaptureBuffer.clear(); 322 323 return IDLE; 324} 325 326CaptureSequencer::CaptureState CaptureSequencer::manageStart( 327 sp<Camera2Client> &client) { 328 ALOGV("%s", __FUNCTION__); 329 status_t res; 330 ATRACE_CALL(); 331 SharedParameters::Lock l(client->getParameters()); 332 CaptureState nextState = DONE; 333 334 res = updateCaptureRequest(l.mParameters, client); 335 if (res != OK ) { 336 ALOGE("%s: Camera %d: Can't update still image capture request: %s (%d)", 337 __FUNCTION__, client->getCameraId(), strerror(-res), res); 338 return DONE; 339 } 340 341 else if (l.mParameters.zslMode && 342 l.mParameters.state == Parameters::STILL_CAPTURE && 343 l.mParameters.flashMode != Parameters::FLASH_MODE_ON) { 344 nextState = ZSL_START; 345 } else { 346 nextState = STANDARD_START; 347 } 348 { 349 Mutex::Autolock l(mInputMutex); 350 mShutterCaptureId = mCaptureId; 351 mHalNotifiedShutter = false; 352 } 353 mShutterNotified = false; 354 355 return nextState; 356} 357 358CaptureSequencer::CaptureState CaptureSequencer::manageZslStart( 359 sp<Camera2Client> &client) { 360 ALOGV("%s", __FUNCTION__); 361 status_t res; 362 sp<ZslProcessor> processor = mZslProcessor.promote(); 363 if (processor == 0) { 364 ALOGE("%s: No ZSL queue to use!", __FUNCTION__); 365 return DONE; 366 } 367 368 // We don't want to get partial results for ZSL capture. 369 client->registerFrameListener(mCaptureId, mCaptureId + 1, 370 this, 371 /*sendPartials*/false); 372 373 // TODO: Actually select the right thing here. 374 res = processor->pushToReprocess(mCaptureId); 375 if (res != OK) { 376 if (res == NOT_ENOUGH_DATA) { 377 ALOGV("%s: Camera %d: ZSL queue doesn't have good frame, " 378 "falling back to normal capture", __FUNCTION__, 379 client->getCameraId()); 380 } else { 381 ALOGE("%s: Camera %d: Error in ZSL queue: %s (%d)", 382 __FUNCTION__, client->getCameraId(), strerror(-res), res); 383 } 384 return STANDARD_START; 385 } 386 387 SharedParameters::Lock l(client->getParameters()); 388 /* warning: this also locks a SharedCameraCallbacks */ 389 shutterNotifyLocked(l.mParameters, client, mMsgType); 390 mShutterNotified = true; 391 mTimeoutCount = kMaxTimeoutsForCaptureEnd; 392 return STANDARD_CAPTURE_WAIT; 393} 394 395CaptureSequencer::CaptureState CaptureSequencer::manageZslWaiting( 396 sp<Camera2Client> &/*client*/) { 397 ALOGV("%s", __FUNCTION__); 398 return DONE; 399} 400 401CaptureSequencer::CaptureState CaptureSequencer::manageZslReprocessing( 402 sp<Camera2Client> &/*client*/) { 403 ALOGV("%s", __FUNCTION__); 404 return START; 405} 406 407CaptureSequencer::CaptureState CaptureSequencer::manageStandardStart( 408 sp<Camera2Client> &client) { 409 ATRACE_CALL(); 410 411 bool isAeConverged = false; 412 // Get the onFrameAvailable callback when the requestID == mCaptureId 413 // We don't want to get partial results for normal capture, as we need 414 // Get ANDROID_SENSOR_TIMESTAMP from the capture result, but partial 415 // result doesn't have to have this metadata available. 416 // TODO: Update to use the HALv3 shutter notification for remove the 417 // need for this listener and make it faster. see bug 12530628. 418 client->registerFrameListener(mCaptureId, mCaptureId + 1, 419 this, 420 /*sendPartials*/false); 421 422 { 423 Mutex::Autolock l(mInputMutex); 424 isAeConverged = (mAEState == ANDROID_CONTROL_AE_STATE_CONVERGED); 425 } 426 427 { 428 SharedParameters::Lock l(client->getParameters()); 429 // Skip AE precapture when it is already converged and not in force flash mode. 430 if (l.mParameters.flashMode != Parameters::FLASH_MODE_ON && isAeConverged) { 431 return STANDARD_CAPTURE; 432 } 433 434 mTriggerId = l.mParameters.precaptureTriggerCounter++; 435 } 436 client->getCameraDevice()->triggerPrecaptureMetering(mTriggerId); 437 438 mAeInPrecapture = false; 439 mTimeoutCount = kMaxTimeoutsForPrecaptureStart; 440 return STANDARD_PRECAPTURE_WAIT; 441} 442 443CaptureSequencer::CaptureState CaptureSequencer::manageStandardPrecaptureWait( 444 sp<Camera2Client> &/*client*/) { 445 status_t res; 446 ATRACE_CALL(); 447 Mutex::Autolock l(mInputMutex); 448 while (!mNewAEState) { 449 res = mNewNotifySignal.waitRelative(mInputMutex, kWaitDuration); 450 if (res == TIMED_OUT) { 451 mTimeoutCount--; 452 break; 453 } 454 } 455 if (mTimeoutCount <= 0) { 456 ALOGW("Timed out waiting for precapture %s", 457 mAeInPrecapture ? "end" : "start"); 458 return STANDARD_CAPTURE; 459 } 460 if (mNewAEState) { 461 if (!mAeInPrecapture) { 462 // Waiting to see PRECAPTURE state 463 if (mAETriggerId == mTriggerId) { 464 if (mAEState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 465 ALOGV("%s: Got precapture start", __FUNCTION__); 466 mAeInPrecapture = true; 467 mTimeoutCount = kMaxTimeoutsForPrecaptureEnd; 468 } else if (mAEState == ANDROID_CONTROL_AE_STATE_CONVERGED || 469 mAEState == ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED) { 470 // It is legal to transit to CONVERGED or FLASH_REQUIRED 471 // directly after a trigger. 472 ALOGV("%s: AE is already in good state, start capture", __FUNCTION__); 473 return STANDARD_CAPTURE; 474 } 475 } 476 } else { 477 // Waiting to see PRECAPTURE state end 478 if (mAETriggerId == mTriggerId && 479 mAEState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 480 ALOGV("%s: Got precapture end", __FUNCTION__); 481 return STANDARD_CAPTURE; 482 } 483 } 484 mNewAEState = false; 485 } 486 return STANDARD_PRECAPTURE_WAIT; 487} 488 489CaptureSequencer::CaptureState CaptureSequencer::manageStandardCapture( 490 sp<Camera2Client> &client) { 491 status_t res; 492 ATRACE_CALL(); 493 SharedParameters::Lock l(client->getParameters()); 494 Vector<int32_t> outputStreams; 495 uint8_t captureIntent = static_cast<uint8_t>(ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE); 496 497 /** 498 * Set up output streams in the request 499 * - preview 500 * - capture/jpeg 501 * - callback (if preview callbacks enabled) 502 * - recording (if recording enabled) 503 */ 504 outputStreams.push(client->getPreviewStreamId()); 505 506 int captureStreamId = client->getCaptureStreamId(); 507 if (captureStreamId == Camera2Client::NO_STREAM) { 508 res = client->createJpegStreamL(l.mParameters); 509 if (res != OK || client->getCaptureStreamId() == Camera2Client::NO_STREAM) { 510 ALOGE("%s: Camera %d: cannot create jpeg stream for slowJpeg mode: %s (%d)", 511 __FUNCTION__, client->getCameraId(), strerror(-res), res); 512 return DONE; 513 } 514 } 515 516 outputStreams.push(client->getCaptureStreamId()); 517 518 if (l.mParameters.previewCallbackFlags & 519 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) { 520 outputStreams.push(client->getCallbackStreamId()); 521 } 522 523 if (l.mParameters.state == Parameters::VIDEO_SNAPSHOT) { 524 outputStreams.push(client->getRecordingStreamId()); 525 captureIntent = static_cast<uint8_t>(ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT); 526 } 527 528 res = mCaptureRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS, 529 outputStreams); 530 if (res == OK) { 531 res = mCaptureRequest.update(ANDROID_REQUEST_ID, 532 &mCaptureId, 1); 533 } 534 if (res == OK) { 535 res = mCaptureRequest.update(ANDROID_CONTROL_CAPTURE_INTENT, 536 &captureIntent, 1); 537 } 538 if (res == OK) { 539 res = mCaptureRequest.sort(); 540 } 541 542 if (res != OK) { 543 ALOGE("%s: Camera %d: Unable to set up still capture request: %s (%d)", 544 __FUNCTION__, client->getCameraId(), strerror(-res), res); 545 return DONE; 546 } 547 548 // Create a capture copy since CameraDeviceBase#capture takes ownership 549 CameraMetadata captureCopy = mCaptureRequest; 550 if (captureCopy.entryCount() == 0) { 551 ALOGE("%s: Camera %d: Unable to copy capture request for HAL device", 552 __FUNCTION__, client->getCameraId()); 553 return DONE; 554 } 555 556 /** 557 * Clear the streaming request for still-capture pictures 558 * (as opposed to i.e. video snapshots) 559 */ 560 if (l.mParameters.state == Parameters::STILL_CAPTURE) { 561 // API definition of takePicture() - stop preview before taking pic 562 res = client->stopStream(); 563 if (res != OK) { 564 ALOGE("%s: Camera %d: Unable to stop preview for still capture: " 565 "%s (%d)", 566 __FUNCTION__, client->getCameraId(), strerror(-res), res); 567 return DONE; 568 } 569 } 570 571 // TODO: Capture should be atomic with setStreamingRequest here 572 res = client->getCameraDevice()->capture(captureCopy); 573 if (res != OK) { 574 ALOGE("%s: Camera %d: Unable to submit still image capture request: " 575 "%s (%d)", 576 __FUNCTION__, client->getCameraId(), strerror(-res), res); 577 return DONE; 578 } 579 580 mTimeoutCount = kMaxTimeoutsForCaptureEnd; 581 return STANDARD_CAPTURE_WAIT; 582} 583 584CaptureSequencer::CaptureState CaptureSequencer::manageStandardCaptureWait( 585 sp<Camera2Client> &client) { 586 status_t res; 587 ATRACE_CALL(); 588 Mutex::Autolock l(mInputMutex); 589 590 591 // Wait for shutter callback 592 while (!mHalNotifiedShutter) { 593 if (mTimeoutCount <= 0) { 594 break; 595 } 596 res = mShutterNotifySignal.waitRelative(mInputMutex, kWaitDuration); 597 if (res == TIMED_OUT) { 598 mTimeoutCount--; 599 return STANDARD_CAPTURE_WAIT; 600 } 601 } 602 603 if (mHalNotifiedShutter) { 604 if (!mShutterNotified) { 605 SharedParameters::Lock l(client->getParameters()); 606 /* warning: this also locks a SharedCameraCallbacks */ 607 shutterNotifyLocked(l.mParameters, client, mMsgType); 608 mShutterNotified = true; 609 } 610 } else if (mTimeoutCount <= 0) { 611 ALOGW("Timed out waiting for shutter notification"); 612 return DONE; 613 } 614 615 // Wait for new metadata result (mNewFrame) 616 while (!mNewFrameReceived) { 617 res = mNewFrameSignal.waitRelative(mInputMutex, kWaitDuration); 618 if (res == TIMED_OUT) { 619 mTimeoutCount--; 620 break; 621 } 622 } 623 624 // Wait until jpeg was captured by JpegProcessor 625 while (mNewFrameReceived && !mNewCaptureReceived) { 626 res = mNewCaptureSignal.waitRelative(mInputMutex, kWaitDuration); 627 if (res == TIMED_OUT) { 628 mTimeoutCount--; 629 break; 630 } 631 } 632 if (mNewCaptureReceived) { 633 if (mNewCaptureErrorCnt > kMaxRetryCount) { 634 ALOGW("Exceeding multiple retry limit of %d due to buffer drop", kMaxRetryCount); 635 return DONE; 636 } else if (mNewCaptureErrorCnt > 0) { 637 ALOGW("Capture error happened, retry %d...", mNewCaptureErrorCnt); 638 mNewCaptureReceived = false; 639 return STANDARD_CAPTURE; 640 } 641 } 642 643 if (mTimeoutCount <= 0) { 644 ALOGW("Timed out waiting for capture to complete"); 645 return DONE; 646 } 647 if (mNewFrameReceived && mNewCaptureReceived) { 648 649 if (mNewFrameId != mCaptureId) { 650 ALOGW("Mismatched capture frame IDs: Expected %d, got %d", 651 mCaptureId, mNewFrameId); 652 } 653 camera_metadata_entry_t entry; 654 entry = mNewFrame.find(ANDROID_SENSOR_TIMESTAMP); 655 if (entry.count == 0) { 656 ALOGE("No timestamp field in capture frame!"); 657 } else if (entry.count == 1) { 658 if (entry.data.i64[0] != mCaptureTimestamp) { 659 ALOGW("Mismatched capture timestamps: Metadata frame %" PRId64 "," 660 " captured buffer %" PRId64, 661 entry.data.i64[0], 662 mCaptureTimestamp); 663 } 664 } else { 665 ALOGE("Timestamp metadata is malformed!"); 666 } 667 client->removeFrameListener(mCaptureId, mCaptureId + 1, this); 668 669 mNewFrameReceived = false; 670 mNewCaptureReceived = false; 671 return DONE; 672 } 673 return STANDARD_CAPTURE_WAIT; 674} 675 676status_t CaptureSequencer::updateCaptureRequest(const Parameters ¶ms, 677 sp<Camera2Client> &client) { 678 ATRACE_CALL(); 679 status_t res; 680 if (mCaptureRequest.entryCount() == 0) { 681 res = client->getCameraDevice()->createDefaultRequest( 682 CAMERA2_TEMPLATE_STILL_CAPTURE, 683 &mCaptureRequest); 684 if (res != OK) { 685 ALOGE("%s: Camera %d: Unable to create default still image request:" 686 " %s (%d)", __FUNCTION__, client->getCameraId(), 687 strerror(-res), res); 688 return res; 689 } 690 } 691 692 res = params.updateRequest(&mCaptureRequest); 693 if (res != OK) { 694 ALOGE("%s: Camera %d: Unable to update common entries of capture " 695 "request: %s (%d)", __FUNCTION__, client->getCameraId(), 696 strerror(-res), res); 697 return res; 698 } 699 700 res = params.updateRequestJpeg(&mCaptureRequest); 701 if (res != OK) { 702 ALOGE("%s: Camera %d: Unable to update JPEG entries of capture " 703 "request: %s (%d)", __FUNCTION__, client->getCameraId(), 704 strerror(-res), res); 705 return res; 706 } 707 708 return OK; 709} 710 711/*static*/ void CaptureSequencer::shutterNotifyLocked(const Parameters ¶ms, 712 sp<Camera2Client> client, int msgType) { 713 ATRACE_CALL(); 714 715 if (params.state == Parameters::STILL_CAPTURE 716 && params.playShutterSound 717 && (msgType & CAMERA_MSG_SHUTTER)) { 718 client->getCameraService()->playSound(CameraService::SOUND_SHUTTER); 719 } 720 721 { 722 Camera2Client::SharedCameraCallbacks::Lock 723 l(client->mSharedCameraCallbacks); 724 725 ALOGV("%s: Notifying of shutter close to client", __FUNCTION__); 726 if (l.mRemoteCallback != 0) { 727 // ShutterCallback 728 l.mRemoteCallback->notifyCallback(CAMERA_MSG_SHUTTER, 729 /*ext1*/0, /*ext2*/0); 730 731 // RawCallback with null buffer 732 l.mRemoteCallback->notifyCallback(CAMERA_MSG_RAW_IMAGE_NOTIFY, 733 /*ext1*/0, /*ext2*/0); 734 } else { 735 ALOGV("%s: No client!", __FUNCTION__); 736 } 737 } 738} 739 740 741}; // namespace camera2 742}; // namespace android 743