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