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