1 /* 2 * Copyright (C) 2015 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 #ifndef _ACAMERA_DEVICE_H 17 #define _ACAMERA_DEVICE_H 18 19 #include <memory> 20 #include <map> 21 #include <set> 22 #include <atomic> 23 #include <utility> 24 #include <utils/StrongPointer.h> 25 #include <utils/Mutex.h> 26 #include <utils/String8.h> 27 #include <utils/List.h> 28 #include <utils/Vector.h> 29 30 #include <android/hardware/camera2/BnCameraDeviceCallbacks.h> 31 #include <android/hardware/camera2/ICameraDeviceUser.h> 32 #include <media/stagefright/foundation/ALooper.h> 33 #include <media/stagefright/foundation/AHandler.h> 34 #include <media/stagefright/foundation/AMessage.h> 35 #include <camera/CaptureResult.h> 36 #include <camera/camera2/OutputConfiguration.h> 37 #include <camera/camera2/CaptureRequest.h> 38 39 #include <NdkCameraDevice.h> 40 #include "ACameraMetadata.h" 41 42 namespace android { 43 44 // Wrap ACameraCaptureFailure so it can be ref-counter 45 struct CameraCaptureFailure : public RefBase, public ACameraCaptureFailure {}; 46 47 class CameraDevice final : public RefBase { 48 public: 49 CameraDevice(const char* id, ACameraDevice_StateCallbacks* cb, 50 std::unique_ptr<ACameraMetadata> chars, 51 ACameraDevice* wrapper); 52 ~CameraDevice(); 53 54 inline const char* getId() const { return mCameraId.string(); } 55 56 camera_status_t createCaptureRequest( 57 ACameraDevice_request_template templateId, 58 ACaptureRequest** request) const; 59 60 camera_status_t createCaptureSession( 61 const ACaptureSessionOutputContainer* outputs, 62 const ACameraCaptureSession_stateCallbacks* callbacks, 63 /*out*/ACameraCaptureSession** session); 64 65 // Callbacks from camera service 66 class ServiceCallback : public hardware::camera2::BnCameraDeviceCallbacks { 67 public: 68 ServiceCallback(CameraDevice* device) : mDevice(device) {} 69 binder::Status onDeviceError(int32_t errorCode, 70 const CaptureResultExtras& resultExtras) override; 71 binder::Status onDeviceIdle() override; 72 binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras, 73 int64_t timestamp) override; 74 binder::Status onResultReceived(const CameraMetadata& metadata, 75 const CaptureResultExtras& resultExtras) override; 76 binder::Status onPrepared(int streamId) override; 77 binder::Status onRepeatingRequestError(int64_t lastFrameNumber) override; 78 private: 79 const wp<CameraDevice> mDevice; 80 }; 81 inline sp<hardware::camera2::ICameraDeviceCallbacks> getServiceCallback() { 82 return mServiceCallback; 83 }; 84 85 // Camera device is only functional after remote being set 86 void setRemoteDevice(sp<hardware::camera2::ICameraDeviceUser> remote); 87 88 inline ACameraDevice* getWrapper() const { return mWrapper; }; 89 90 private: 91 friend ACameraCaptureSession; 92 camera_status_t checkCameraClosedOrErrorLocked() const; 93 94 // device goes into fatal error state after this 95 void setCameraDeviceErrorLocked(camera_status_t error); 96 97 void disconnectLocked(); // disconnect from camera service 98 99 camera_status_t stopRepeatingLocked(); 100 101 camera_status_t flushLocked(ACameraCaptureSession*); 102 103 camera_status_t waitUntilIdleLocked(); 104 105 106 camera_status_t captureLocked(sp<ACameraCaptureSession> session, 107 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 108 int numRequests, ACaptureRequest** requests, 109 /*optional*/int* captureSequenceId); 110 111 camera_status_t setRepeatingRequestsLocked(sp<ACameraCaptureSession> session, 112 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 113 int numRequests, ACaptureRequest** requests, 114 /*optional*/int* captureSequenceId); 115 116 camera_status_t submitRequestsLocked( 117 sp<ACameraCaptureSession> session, 118 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 119 int numRequests, ACaptureRequest** requests, 120 /*out*/int* captureSequenceId, 121 bool isRepeating); 122 123 static camera_status_t allocateCaptureRequest( 124 const ACaptureRequest* request, sp<CaptureRequest>& outReq); 125 126 static ACaptureRequest* allocateACaptureRequest(sp<CaptureRequest>& req); 127 static void freeACaptureRequest(ACaptureRequest*); 128 129 // only For session to hold device lock 130 // Always grab device lock before grabbing session lock 131 void lockDeviceForSessionOps() const { mDeviceLock.lock(); }; 132 void unlockDevice() const { mDeviceLock.unlock(); }; 133 134 // For capture session to notify its end of life 135 void notifySessionEndOfLifeLocked(ACameraCaptureSession* session); 136 137 camera_status_t configureStreamsLocked(const ACaptureSessionOutputContainer* outputs); 138 139 static camera_status_t getIGBPfromAnw( 140 ANativeWindow* anw, sp<IGraphicBufferProducer>& out); 141 142 static camera_status_t getSurfaceFromANativeWindow( 143 ANativeWindow* anw, sp<Surface>& out); 144 145 mutable Mutex mDeviceLock; 146 const String8 mCameraId; // Camera ID 147 const ACameraDevice_StateCallbacks mAppCallbacks; // Callback to app 148 const std::unique_ptr<ACameraMetadata> mChars; // Camera characteristics 149 const sp<ServiceCallback> mServiceCallback; 150 ACameraDevice* mWrapper; 151 152 // stream id -> pair of (ANW* from application, OutputConfiguration used for camera service) 153 std::map<int, std::pair<ANativeWindow*, OutputConfiguration>> mConfiguredOutputs; 154 155 // TODO: maybe a bool will suffice for synchronous implementation? 156 std::atomic_bool mClosing; 157 inline bool isClosed() { return mClosing; } 158 159 bool mInError = false; 160 camera_status_t mError = ACAMERA_OK; 161 void onCaptureErrorLocked( 162 int32_t errorCode, 163 const CaptureResultExtras& resultExtras); 164 165 bool mIdle = true; 166 // This will avoid a busy session being deleted before it's back to idle state 167 sp<ACameraCaptureSession> mBusySession; 168 169 sp<hardware::camera2::ICameraDeviceUser> mRemote; 170 171 // Looper thread to handle callback to app 172 sp<ALooper> mCbLooper; 173 // definition of handler and message 174 enum { 175 // Device state callbacks 176 kWhatOnDisconnected, // onDisconnected 177 kWhatOnError, // onError 178 // Session state callbacks 179 kWhatSessionStateCb, // onReady, onActive 180 // Capture callbacks 181 kWhatCaptureStart, // onCaptureStarted 182 kWhatCaptureResult, // onCaptureProgressed, onCaptureCompleted 183 kWhatCaptureFail, // onCaptureFailed 184 kWhatCaptureSeqEnd, // onCaptureSequenceCompleted 185 kWhatCaptureSeqAbort, // onCaptureSequenceAborted 186 kWhatCaptureBufferLost // onCaptureBufferLost 187 }; 188 static const char* kContextKey; 189 static const char* kDeviceKey; 190 static const char* kErrorCodeKey; 191 static const char* kCallbackFpKey; 192 static const char* kSessionSpKey; 193 static const char* kCaptureRequestKey; 194 static const char* kTimeStampKey; 195 static const char* kCaptureResultKey; 196 static const char* kCaptureFailureKey; 197 static const char* kSequenceIdKey; 198 static const char* kFrameNumberKey; 199 static const char* kAnwKey; 200 class CallbackHandler : public AHandler { 201 public: 202 CallbackHandler() {} 203 void onMessageReceived(const sp<AMessage> &msg) override; 204 }; 205 sp<CallbackHandler> mHandler; 206 207 /*********************************** 208 * Capture session related members * 209 ***********************************/ 210 // The current active session 211 ACameraCaptureSession* mCurrentSession = nullptr; 212 bool mFlushing = false; 213 214 int mNextSessionId = 0; 215 // TODO: might need another looper/handler to handle callbacks from service 216 217 static const int REQUEST_ID_NONE = -1; 218 int mRepeatingSequenceId = REQUEST_ID_NONE; 219 220 // sequence id -> last frame number map 221 std::map<int, int64_t> mSequenceLastFrameNumberMap; 222 223 struct CallbackHolder { 224 CallbackHolder(sp<ACameraCaptureSession> session, 225 const Vector<sp<CaptureRequest> >& requests, 226 bool isRepeating, 227 ACameraCaptureSession_captureCallbacks* cbs); 228 229 static ACameraCaptureSession_captureCallbacks fillCb( 230 ACameraCaptureSession_captureCallbacks* cbs) { 231 if (cbs != nullptr) { 232 return *cbs; 233 } 234 return { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; 235 } 236 237 sp<ACameraCaptureSession> mSession; 238 Vector<sp<CaptureRequest> > mRequests; 239 const bool mIsRepeating; 240 ACameraCaptureSession_captureCallbacks mCallbacks; 241 }; 242 // sequence id -> callbacks map 243 std::map<int, CallbackHolder> mSequenceCallbackMap; 244 245 static const int64_t NO_FRAMES_CAPTURED = -1; 246 class FrameNumberTracker { 247 public: 248 // TODO: Called in onResultReceived and onCaptureErrorLocked 249 void updateTracker(int64_t frameNumber, bool isError); 250 inline int64_t getCompletedFrameNumber() { return mCompletedFrameNumber; } 251 private: 252 void update(); 253 void updateCompletedFrameNumber(int64_t frameNumber); 254 255 int64_t mCompletedFrameNumber = NO_FRAMES_CAPTURED; 256 List<int64_t> mSkippedFrameNumbers; 257 std::set<int64_t> mFutureErrorSet; 258 }; 259 FrameNumberTracker mFrameNumberTracker; 260 261 void checkRepeatingSequenceCompleteLocked(const int sequenceId, const int64_t lastFrameNumber); 262 void checkAndFireSequenceCompleteLocked(); 263 264 // Misc variables 265 int32_t mShadingMapSize[2]; // const after constructor 266 int32_t mPartialResultCount; // const after constructor 267 268 }; 269 270 } // namespace android; 271 272 /** 273 * ACameraDevice opaque struct definition 274 * Leave outside of android namespace because it's NDK struct 275 */ 276 struct ACameraDevice { 277 ACameraDevice(const char* id, ACameraDevice_StateCallbacks* cb, 278 std::unique_ptr<ACameraMetadata> chars) : 279 mDevice(new CameraDevice(id, cb, std::move(chars), this)) {} 280 281 ~ACameraDevice() {}; 282 283 /******************* 284 * NDK public APIs * 285 *******************/ 286 inline const char* getId() const { return mDevice->getId(); } 287 288 camera_status_t createCaptureRequest( 289 ACameraDevice_request_template templateId, 290 ACaptureRequest** request) const { 291 return mDevice->createCaptureRequest(templateId, request); 292 } 293 294 camera_status_t createCaptureSession( 295 const ACaptureSessionOutputContainer* outputs, 296 const ACameraCaptureSession_stateCallbacks* callbacks, 297 /*out*/ACameraCaptureSession** session) { 298 return mDevice->createCaptureSession(outputs, callbacks, session); 299 } 300 301 /*********************** 302 * Device interal APIs * 303 ***********************/ 304 inline android::sp<android::hardware::camera2::ICameraDeviceCallbacks> getServiceCallback() { 305 return mDevice->getServiceCallback(); 306 }; 307 308 // Camera device is only functional after remote being set 309 inline void setRemoteDevice(android::sp<android::hardware::camera2::ICameraDeviceUser> remote) { 310 mDevice->setRemoteDevice(remote); 311 } 312 313 private: 314 android::sp<android::CameraDevice> mDevice; 315 }; 316 317 #endif // _ACAMERA_DEVICE_H 318
