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 
29 namespace android {
30 
31 struct CameraDeviceClientBase :
32          public CameraService::BasicClient,
33          public hardware::camera2::BnCameraDeviceUser
34 {
35     typedef hardware::camera2::ICameraDeviceCallbacks TCamCallbacks;
36 
getRemoteCallbackCameraDeviceClientBase37     const sp<hardware::camera2::ICameraDeviceCallbacks>& getRemoteCallback() {
38         return mRemoteCallback;
39     }
40 
41 protected:
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  */
59 class CameraDeviceClient :
60         public Camera2ClientBase<CameraDeviceClientBase>,
61         public camera2::FrameProcessorBase::FilteredListener
62 {
63 public:
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      */
173 protected:
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 
181 private:
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:
StreamSurfaceId()188         StreamSurfaceId() {
189             mStreamId = -1;
190             mSurfaceId = -1;
191         }
StreamSurfaceId(int32_t streamId,int32_t surfaceId)192         StreamSurfaceId(int32_t streamId, int32_t surfaceId) {
193             mStreamId = streamId;
194             mSurfaceId = surfaceId;
195         }
streamId()196         int32_t streamId() const {
197             return mStreamId;
198         }
surfaceId()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;
OutputStreamInfo()218         OutputStreamInfo() :
219                 width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),
220                 consumerUsage(0) {}
OutputStreamInfo(int _width,int _height,int _format,android_dataspace _dataSpace,int32_t _consumerUsage)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 
227 private:
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