1/*
2 * Copyright (C) 2013 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_PHOTOGRAPHY_CAMERADEVICECLIENT_H
18#define ANDROID_SERVERS_CAMERA_PHOTOGRAPHY_CAMERADEVICECLIENT_H
19
20#include <android/hardware/camera2/BnCameraDeviceUser.h>
21#include <android/hardware/camera2/ICameraDeviceCallbacks.h>
22#include <camera/camera2/OutputConfiguration.h>
23#include <camera/camera2/SubmitInfo.h>
24
25#include "CameraService.h"
26#include "common/FrameProcessorBase.h"
27#include "common/Camera2ClientBase.h"
28
29namespace android {
30
31struct CameraDeviceClientBase :
32         public CameraService::BasicClient,
33         public hardware::camera2::BnCameraDeviceUser
34{
35    typedef hardware::camera2::ICameraDeviceCallbacks TCamCallbacks;
36
37    const sp<hardware::camera2::ICameraDeviceCallbacks>& getRemoteCallback() {
38        return mRemoteCallback;
39    }
40
41protected:
42    CameraDeviceClientBase(const sp<CameraService>& cameraService,
43            const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
44            const String16& clientPackageName,
45            const String8& cameraId,
46            int cameraFacing,
47            int clientPid,
48            uid_t clientUid,
49            int servicePid);
50
51    sp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback;
52};
53
54/**
55 * Implements the binder ICameraDeviceUser API,
56 * meant for HAL3-public implementation of
57 * android.hardware.photography.CameraDevice
58 */
59class CameraDeviceClient :
60        public Camera2ClientBase<CameraDeviceClientBase>,
61        public camera2::FrameProcessorBase::FilteredListener
62{
63public:
64    /**
65     * ICameraDeviceUser interface (see ICameraDeviceUser for details)
66     */
67
68    // Note that the callee gets a copy of the metadata.
69    virtual binder::Status submitRequest(
70            const hardware::camera2::CaptureRequest& request,
71            bool streaming = false,
72            /*out*/
73            hardware::camera2::utils::SubmitInfo *submitInfo = nullptr) override;
74    // List of requests are copied.
75    virtual binder::Status submitRequestList(
76            const std::vector<hardware::camera2::CaptureRequest>& requests,
77            bool streaming = false,
78            /*out*/
79            hardware::camera2::utils::SubmitInfo *submitInfo = nullptr) override;
80    virtual binder::Status cancelRequest(int requestId,
81            /*out*/
82            int64_t* lastFrameNumber = NULL) override;
83
84    virtual binder::Status beginConfigure() override;
85
86    virtual binder::Status endConfigure(int operatingMode) override;
87
88    // Returns -EBUSY if device is not idle
89    virtual binder::Status deleteStream(int streamId) override;
90
91    virtual binder::Status createStream(
92            const hardware::camera2::params::OutputConfiguration &outputConfiguration,
93            /*out*/
94            int32_t* newStreamId = NULL) override;
95
96    // Create an input stream of width, height, and format.
97    virtual binder::Status createInputStream(int width, int height, int format,
98            /*out*/
99            int32_t* newStreamId = NULL) override;
100
101    // Get the buffer producer of the input stream
102    virtual binder::Status getInputSurface(
103            /*out*/
104            view::Surface *inputSurface) override;
105
106    // Create a request object from a template.
107    virtual binder::Status createDefaultRequest(int templateId,
108            /*out*/
109            hardware::camera2::impl::CameraMetadataNative* request) override;
110
111    // Get the static metadata for the camera
112    // -- Caller owns the newly allocated metadata
113    virtual binder::Status getCameraInfo(
114            /*out*/
115            hardware::camera2::impl::CameraMetadataNative* cameraCharacteristics) override;
116
117    // Wait until all the submitted requests have finished processing
118    virtual binder::Status waitUntilIdle() override;
119
120    // Flush all active and pending requests as fast as possible
121    virtual binder::Status flush(
122            /*out*/
123            int64_t* lastFrameNumber = NULL) override;
124
125    // Prepare stream by preallocating its buffers
126    virtual binder::Status prepare(int32_t streamId) override;
127
128    // Tear down stream resources by freeing its unused buffers
129    virtual binder::Status tearDown(int32_t streamId) override;
130
131    // Prepare stream by preallocating up to maxCount of its buffers
132    virtual binder::Status prepare2(int32_t maxCount, int32_t streamId) override;
133
134    // Finalize the output configurations with surfaces not added before.
135    virtual binder::Status finalizeOutputConfigurations(int32_t streamId,
136            const hardware::camera2::params::OutputConfiguration &outputConfiguration) override;
137
138    /**
139     * Interface used by CameraService
140     */
141
142    CameraDeviceClient(const sp<CameraService>& cameraService,
143            const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
144            const String16& clientPackageName,
145            const String8& cameraId,
146            int cameraFacing,
147            int clientPid,
148            uid_t clientUid,
149            int servicePid);
150    virtual ~CameraDeviceClient();
151
152    virtual status_t      initialize(sp<CameraProviderManager> manager) override;
153
154    virtual status_t      dump(int fd, const Vector<String16>& args);
155
156    virtual status_t      dumpClient(int fd, const Vector<String16>& args);
157
158    /**
159     * Device listener interface
160     */
161
162    virtual void notifyIdle();
163    virtual void notifyError(int32_t errorCode,
164                             const CaptureResultExtras& resultExtras);
165    virtual void notifyShutter(const CaptureResultExtras& resultExtras, nsecs_t timestamp);
166    virtual void notifyPrepared(int streamId);
167    virtual void notifyRequestQueueEmpty();
168    virtual void notifyRepeatingRequestError(long lastFrameNumber);
169
170    /**
171     * Interface used by independent components of CameraDeviceClient.
172     */
173protected:
174    /** FilteredListener implementation **/
175    virtual void          onResultAvailable(const CaptureResult& result);
176    virtual void          detachDevice();
177
178    // Calculate the ANativeWindow transform from android.sensor.orientation
179    status_t              getRotationTransformLocked(/*out*/int32_t* transform);
180
181private:
182    // StreamSurfaceId encapsulates streamId + surfaceId for a particular surface.
183    // streamId specifies the index of the stream the surface belongs to, and the
184    // surfaceId specifies the index of the surface within the stream. (one stream
185    // could contain multiple surfaces.)
186    class StreamSurfaceId final {
187    public:
188        StreamSurfaceId() {
189            mStreamId = -1;
190            mSurfaceId = -1;
191        }
192        StreamSurfaceId(int32_t streamId, int32_t surfaceId) {
193            mStreamId = streamId;
194            mSurfaceId = surfaceId;
195        }
196        int32_t streamId() const {
197            return mStreamId;
198        }
199        int32_t surfaceId() const {
200            return mSurfaceId;
201        }
202
203    private:
204        int32_t mStreamId;
205        int32_t mSurfaceId;
206
207    }; // class StreamSurfaceId
208
209    // OutputStreamInfo describes the property of a camera stream.
210    class OutputStreamInfo {
211    public:
212        int width;
213        int height;
214        int format;
215        android_dataspace dataSpace;
216        int32_t consumerUsage;
217        bool finalized = false;
218        OutputStreamInfo() :
219                width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),
220                consumerUsage(0) {}
221        OutputStreamInfo(int _width, int _height, int _format, android_dataspace _dataSpace,
222                int32_t _consumerUsage) :
223                    width(_width), height(_height), format(_format),
224                    dataSpace(_dataSpace), consumerUsage(_consumerUsage) {}
225    };
226
227private:
228    /** ICameraDeviceUser interface-related private members */
229
230    /** Preview callback related members */
231    sp<camera2::FrameProcessorBase> mFrameProcessor;
232    static const int32_t FRAME_PROCESSOR_LISTENER_MIN_ID = 0;
233    static const int32_t FRAME_PROCESSOR_LISTENER_MAX_ID = 0x7fffffffL;
234
235    template<typename TProviderPtr>
236    status_t      initializeImpl(TProviderPtr providerPtr);
237
238    /** Utility members */
239    binder::Status checkPidStatus(const char* checkLocation);
240    bool enforceRequestPermissions(CameraMetadata& metadata);
241
242    // Find the square of the euclidean distance between two points
243    static int64_t euclidDistSquare(int32_t x0, int32_t y0, int32_t x1, int32_t y1);
244
245    // Create an output stream with surface deferred for future.
246    binder::Status createDeferredSurfaceStreamLocked(
247            const hardware::camera2::params::OutputConfiguration &outputConfiguration,
248            bool isShared,
249            int* newStreamId = NULL);
250
251    // Set the stream transform flags to automatically rotate the camera stream for preview use
252    // cases.
253    binder::Status setStreamTransformLocked(int streamId);
254
255    // Find the closest dimensions for a given format in available stream configurations with
256    // a width <= ROUNDING_WIDTH_CAP
257    static const int32_t ROUNDING_WIDTH_CAP = 1920;
258    static bool roundBufferDimensionNearest(int32_t width, int32_t height, int32_t format,
259            android_dataspace dataSpace, const CameraMetadata& info,
260            /*out*/int32_t* outWidth, /*out*/int32_t* outHeight);
261
262    //check if format is not custom format
263    static bool isPublicFormat(int32_t format);
264
265    // Create a Surface from an IGraphicBufferProducer. Returns error if
266    // IGraphicBufferProducer's property doesn't match with streamInfo
267    binder::Status createSurfaceFromGbp(OutputStreamInfo& streamInfo, bool isStreamInfoValid,
268            sp<Surface>& surface, const sp<IGraphicBufferProducer>& gbp);
269
270    // IGraphicsBufferProducer binder -> Stream ID + Surface ID for output streams
271    KeyedVector<sp<IBinder>, StreamSurfaceId> mStreamMap;
272
273    struct InputStreamConfiguration {
274        bool configured;
275        int32_t width;
276        int32_t height;
277        int32_t format;
278        int32_t id;
279    } mInputStream;
280
281    // Streaming request ID
282    int32_t mStreamingRequestId;
283    Mutex mStreamingRequestIdLock;
284    static const int32_t REQUEST_ID_NONE = -1;
285
286    int32_t mRequestIdCounter;
287
288    // The list of output streams whose surfaces are deferred. We have to track them separately
289    // as there are no surfaces available and can not be put into mStreamMap. Once the deferred
290    // Surface is configured, the stream id will be moved to mStreamMap.
291    Vector<int32_t> mDeferredStreams;
292
293    // stream ID -> outputStreamInfo mapping
294    std::unordered_map<int32_t, OutputStreamInfo> mStreamInfoMap;
295
296    static const int32_t MAX_SURFACES_PER_STREAM = 2;
297};
298
299}; // namespace android
300
301#endif
302