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