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 #ifndef ANDROID_SERVERS_CAMERA_CAMERA2_CAPTURESEQUENCER_H 18 #define ANDROID_SERVERS_CAMERA_CAMERA2_CAPTURESEQUENCER_H 19 20 #include <binder/MemoryBase.h> 21 #include <utils/Thread.h> 22 #include <utils/String16.h> 23 #include <utils/Vector.h> 24 #include <utils/Mutex.h> 25 #include <utils/Condition.h> 26 #include "camera/CameraMetadata.h" 27 #include "Parameters.h" 28 #include "FrameProcessor.h" 29 30 namespace android { 31 32 class Camera2Client; 33 34 namespace camera2 { 35 36 class ZslProcessorInterface; 37 class BurstCapture; 38 39 /** 40 * Manages the still image capture process for 41 * zero-shutter-lag, regular, and video snapshots. 42 */ 43 class CaptureSequencer: 44 virtual public Thread, 45 virtual public FrameProcessor::FilteredListener { 46 public: 47 CaptureSequencer(wp<Camera2Client> client); 48 ~CaptureSequencer(); 49 50 // Get reference to the ZslProcessor, which holds the ZSL buffers and frames 51 void setZslProcessor(wp<ZslProcessorInterface> processor); 52 53 // Begin still image capture 54 status_t startCapture(int msgType); 55 56 // Wait until current image capture completes; returns immediately if no 57 // capture is active. Returns TIMED_OUT if capture does not complete during 58 // the specified duration. 59 status_t waitUntilIdle(nsecs_t timeout); 60 61 // Notifications about AE state changes 62 void notifyAutoExposure(uint8_t newState, int triggerId); 63 64 // Notifications from the frame processor 65 virtual void onFrameAvailable(int32_t requestId, const CameraMetadata &frame); 66 67 // Notifications from the JPEG processor 68 void onCaptureAvailable(nsecs_t timestamp, sp<MemoryBase> captureBuffer); 69 70 void dump(int fd, const Vector<String16>& args); 71 72 private: 73 /** 74 * Accessed by other threads 75 */ 76 Mutex mInputMutex; 77 78 bool mStartCapture; 79 bool mBusy; 80 Condition mStartCaptureSignal; 81 82 bool mNewAEState; 83 uint8_t mAEState; 84 int mAETriggerId; 85 Condition mNewNotifySignal; 86 87 bool mNewFrameReceived; 88 int32_t mNewFrameId; 89 CameraMetadata mNewFrame; 90 Condition mNewFrameSignal; 91 92 bool mNewCaptureReceived; 93 nsecs_t mCaptureTimestamp; 94 sp<MemoryBase> mCaptureBuffer; 95 Condition mNewCaptureSignal; 96 97 bool mShutterNotified; 98 99 /** 100 * Internal to CaptureSequencer 101 */ 102 static const nsecs_t kWaitDuration = 100000000; // 100 ms 103 static const int kMaxTimeoutsForPrecaptureStart = 10; // 1 sec 104 static const int kMaxTimeoutsForPrecaptureEnd = 20; // 2 sec 105 static const int kMaxTimeoutsForCaptureEnd = 40; // 4 sec 106 107 wp<Camera2Client> mClient; 108 wp<ZslProcessorInterface> mZslProcessor; 109 sp<BurstCapture> mBurstCapture; 110 111 enum CaptureState { 112 IDLE, 113 START, 114 ZSL_START, 115 ZSL_WAITING, 116 ZSL_REPROCESSING, 117 STANDARD_START, 118 STANDARD_PRECAPTURE_WAIT, 119 STANDARD_CAPTURE, 120 STANDARD_CAPTURE_WAIT, 121 BURST_CAPTURE_START, 122 BURST_CAPTURE_WAIT, 123 DONE, 124 ERROR, 125 NUM_CAPTURE_STATES 126 } mCaptureState; 127 static const char* kStateNames[]; 128 int mStateTransitionCount; 129 Mutex mStateMutex; // Guards mCaptureState 130 Condition mStateChanged; 131 132 typedef CaptureState (CaptureSequencer::*StateManager)(sp<Camera2Client> &client); 133 static const StateManager kStateManagers[]; 134 135 CameraMetadata mCaptureRequest; 136 137 int mTriggerId; 138 int mTimeoutCount; 139 bool mAeInPrecapture; 140 141 int32_t mCaptureId; 142 int mMsgType; 143 144 // Main internal methods 145 146 virtual bool threadLoop(); 147 148 CaptureState manageIdle(sp<Camera2Client> &client); 149 CaptureState manageStart(sp<Camera2Client> &client); 150 151 CaptureState manageZslStart(sp<Camera2Client> &client); 152 CaptureState manageZslWaiting(sp<Camera2Client> &client); 153 CaptureState manageZslReprocessing(sp<Camera2Client> &client); 154 155 CaptureState manageStandardStart(sp<Camera2Client> &client); 156 CaptureState manageStandardPrecaptureWait(sp<Camera2Client> &client); 157 CaptureState manageStandardCapture(sp<Camera2Client> &client); 158 CaptureState manageStandardCaptureWait(sp<Camera2Client> &client); 159 160 CaptureState manageBurstCaptureStart(sp<Camera2Client> &client); 161 CaptureState manageBurstCaptureWait(sp<Camera2Client> &client); 162 163 CaptureState manageDone(sp<Camera2Client> &client); 164 165 // Utility methods 166 167 status_t updateCaptureRequest(const Parameters ¶ms, 168 sp<Camera2Client> &client); 169 170 // Emit Shutter/Raw callback to java, and maybe play a shutter sound 171 static void shutterNotifyLocked(const Parameters ¶ms, 172 sp<Camera2Client> client, int msgType); 173 }; 174 175 }; // namespace camera2 176 }; // namespace android 177 178 #endif 179