Camera2Client.h revision 5a4f93eaaab7518fd734fdc9f0f686d632f31a59 
1/*
2 * Copyright (C) 2012 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
17#ifndef ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H
18#define ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H
19
20#include "Camera2Device.h"
21#include "CameraService.h"
22#include "camera2/Parameters.h"
23#include "camera2/FrameProcessor.h"
24#include "camera2/JpegProcessor.h"
25#include "camera2/ZslProcessor.h"
26#include "camera2/CaptureSequencer.h"
27#include "camera2/CallbackProcessor.h"
28#include <binder/MemoryBase.h>
29#include <binder/MemoryHeapBase.h>
30#include <gui/CpuConsumer.h>
31#include <gui/BufferItemConsumer.h>
32
33namespace android {
34
35/**
36 * Implements the android.hardware.camera API on top of
37 * camera device HAL version 2.
38 */
39class Camera2Client :
40        public CameraService::Client,
41        public Camera2Device::NotificationListener
42{
43public:
44    /**
45     * ICamera interface (see ICamera for details)
46     */
47
48    virtual void            disconnect();
49    virtual status_t        connect(const sp<ICameraClient>& client);
50    virtual status_t        lock();
51    virtual status_t        unlock();
52    virtual status_t        setPreviewDisplay(const sp<Surface>& surface);
53    virtual status_t        setPreviewTexture(
54        const sp<ISurfaceTexture>& surfaceTexture);
55    virtual void            setPreviewCallbackFlag(int flag);
56    virtual status_t        startPreview();
57    virtual void            stopPreview();
58    virtual bool            previewEnabled();
59    virtual status_t        storeMetaDataInBuffers(bool enabled);
60    virtual status_t        startRecording();
61    virtual void            stopRecording();
62    virtual bool            recordingEnabled();
63    virtual void            releaseRecordingFrame(const sp<IMemory>& mem);
64    virtual status_t        autoFocus();
65    virtual status_t        cancelAutoFocus();
66    virtual status_t        takePicture(int msgType);
67    virtual status_t        setParameters(const String8& params);
68    virtual String8         getParameters() const;
69    virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
70
71    /**
72     * Interface used by CameraService
73     */
74
75    Camera2Client(const sp<CameraService>& cameraService,
76            const sp<ICameraClient>& cameraClient,
77            int cameraId,
78            int cameraFacing,
79            int clientPid);
80    virtual ~Camera2Client();
81
82    status_t initialize(camera_module_t *module);
83
84    virtual status_t dump(int fd, const Vector<String16>& args);
85
86    /**
87     * Interface used by Camera2Device
88     */
89
90    virtual void notifyError(int errorCode, int arg1, int arg2);
91    virtual void notifyShutter(int frameNumber, nsecs_t timestamp);
92    virtual void notifyAutoFocus(uint8_t newState, int triggerId);
93    virtual void notifyAutoExposure(uint8_t newState, int triggerId);
94    virtual void notifyAutoWhitebalance(uint8_t newState, int triggerId);
95
96    /**
97     * Interface used by independent components of Camera2Client.
98     */
99
100    int getCameraId() const;
101    const sp<Camera2Device>& getCameraDevice();
102    const sp<CameraService>& getCameraService();
103    camera2::SharedParameters& getParameters();
104
105    int getPreviewStreamId() const;
106    int getCaptureStreamId() const;
107    int getCallbackStreamId() const;
108    int getRecordingStreamId() const;
109    int getZslStreamId() const;
110
111    status_t registerFrameListener(int32_t id,
112            wp<camera2::FrameProcessor::FilteredListener> listener);
113    status_t removeFrameListener(int32_t id);
114
115    // Simple class to ensure that access to ICameraClient is serialized by
116    // requiring mCameraClientLock to be locked before access to mCameraClient
117    // is possible.
118    class SharedCameraClient {
119      public:
120        class Lock {
121          public:
122            Lock(SharedCameraClient &client);
123            ~Lock();
124            sp<ICameraClient> &mCameraClient;
125          private:
126            SharedCameraClient &mSharedClient;
127        };
128        SharedCameraClient(const sp<ICameraClient>& client);
129        SharedCameraClient& operator=(const sp<ICameraClient>& client);
130        void clear();
131      private:
132        sp<ICameraClient> mCameraClient;
133        mutable Mutex mCameraClientLock;
134    } mSharedCameraClient;
135
136    static size_t calculateBufferSize(int width, int height,
137            int format, int stride);
138
139    static const int32_t kPreviewRequestId = 1000;
140    static const int32_t kRecordRequestId  = 2000;
141    static const int32_t kFirstCaptureRequestId = 3000;
142
143private:
144    /** ICamera interface-related private members */
145
146    // Mutex that must be locked by methods implementing the ICamera interface.
147    // Ensures serialization between incoming ICamera calls. All methods below
148    // that append 'L' to the name assume that mICameraLock is locked when
149    // they're called
150    mutable Mutex mICameraLock;
151
152    typedef camera2::Parameters Parameters;
153    typedef camera2::CameraMetadata CameraMetadata;
154
155    status_t setPreviewWindowL(const sp<IBinder>& binder,
156            sp<ANativeWindow> window);
157    status_t startPreviewL(Parameters &params, bool restart);
158    void     stopPreviewL();
159    status_t startRecordingL(Parameters &params, bool restart);
160    bool     recordingEnabledL();
161
162    // Individual commands for sendCommand()
163    status_t commandStartSmoothZoomL();
164    status_t commandStopSmoothZoomL();
165    status_t commandSetDisplayOrientationL(int degrees);
166    status_t commandEnableShutterSoundL(bool enable);
167    status_t commandPlayRecordingSoundL();
168    status_t commandStartFaceDetectionL(int type);
169    status_t commandStopFaceDetectionL(Parameters &params);
170    status_t commandEnableFocusMoveMsgL(bool enable);
171    status_t commandPingL();
172    status_t commandSetVideoBufferCountL(size_t count);
173
174    // Current camera device configuration
175    camera2::SharedParameters mParameters;
176
177    /** Camera device-related private members */
178
179    void     setPreviewCallbackFlagL(Parameters &params, int flag);
180    status_t updateRequests(Parameters &params);
181
182    // Used with stream IDs
183    static const int NO_STREAM = -1;
184
185    sp<camera2::FrameProcessor> mFrameProcessor;
186
187    /* Preview related members */
188
189    int mPreviewStreamId;
190    CameraMetadata mPreviewRequest;
191    sp<IBinder> mPreviewSurface;
192    sp<ANativeWindow> mPreviewWindow;
193
194    status_t updatePreviewRequest(const Parameters &params);
195    status_t updatePreviewStream(const Parameters &params);
196
197    /** Preview callback related members */
198
199    sp<camera2::CallbackProcessor> mCallbackProcessor;
200
201    /* Still image capture related members */
202
203    sp<camera2::CaptureSequencer> mCaptureSequencer;
204    sp<camera2::JpegProcessor> mJpegProcessor;
205    sp<camera2::ZslProcessor> mZslProcessor;
206
207    /* Recording related members */
208
209    int mRecordingStreamId;
210    int mRecordingFrameCount;
211    sp<BufferItemConsumer>    mRecordingConsumer;
212    sp<ANativeWindow>  mRecordingWindow;
213    // Simple listener that forwards frame available notifications from
214    // a CPU consumer to the recording notification
215    class RecordingWaiter: public BufferItemConsumer::FrameAvailableListener {
216      public:
217        RecordingWaiter(Camera2Client *parent) : mParent(parent) {}
218        void onFrameAvailable() { mParent->onRecordingFrameAvailable(); }
219      private:
220        Camera2Client *mParent;
221    };
222    sp<RecordingWaiter>  mRecordingWaiter;
223    CameraMetadata mRecordingRequest;
224    sp<camera2::Camera2Heap> mRecordingHeap;
225
226    static const size_t kDefaultRecordingHeapCount = 8;
227    size_t mRecordingHeapCount;
228    Vector<BufferItemConsumer::BufferItem> mRecordingBuffers;
229    size_t mRecordingHeapHead, mRecordingHeapFree;
230    // Handle new recording image buffers
231    void onRecordingFrameAvailable();
232
233    status_t updateRecordingRequest(const Parameters &params);
234    status_t updateRecordingStream(const Parameters &params);
235
236    /** Notification-related members */
237
238    bool mAfInMotion;
239
240    /** Camera2Device instance wrapping HAL2 entry */
241
242    sp<Camera2Device> mDevice;
243
244    /** Utility members */
245
246    // Verify that caller is the owner of the camera
247    status_t checkPid(const char *checkLocation) const;
248};
249
250}; // namespace android
251
252#endif
253