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