1 /*
2  * Copyright (C) 2011 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 HW_EMULATOR_CAMERA_EMULATED_CAMERA_H
18 #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_H
19 
20 /*
21  * Contains declaration of a class EmulatedCamera that encapsulates
22  * functionality common to all version 1.0 emulated camera devices ("fake",
23  * "webcam", "video file", etc.).  Instances of this class (for each emulated
24  * camera) are created during the construction of the EmulatedCameraFactory
25  * instance.  This class serves as an entry point for all camera API calls that
26  * defined by camera_device_ops_t API.
27  */
28 
29 #include <camera/CameraParameters.h>
30 #include "EmulatedBaseCamera.h"
31 #include "EmulatedCameraDevice.h"
32 #include "PreviewWindow.h"
33 #include "CallbackNotifier.h"
34 
35 namespace android {
36 
37 /* Encapsulates functionality common to all version 1.0 emulated camera devices
38  * ("fake", "webcam", "file stream", etc.).
39  *
40  * Note that EmulatedCameraFactory instantiates object of this class just once,
41  * when EmulatedCameraFactory instance gets constructed. Connection to /
42  * disconnection from the actual camera device is handled by calls to
43  * connectDevice(), and closeCamera() methods of this class that are ivoked in
44  * response to hw_module_methods_t::open, and camera_device::close callbacks.
45  */
46 class EmulatedCamera : public camera_device, public EmulatedBaseCamera {
47 public:
48     /* Constructs EmulatedCamera instance.
49      * Param:
50      *  cameraId - Zero based camera identifier, which is an index of the camera
51      *      instance in camera factory's array.
52      *  module - Emulated camera HAL module descriptor.
53      */
54     EmulatedCamera(int cameraId,
55                    struct hw_module_t* module);
56 
57     /* Destructs EmulatedCamera instance. */
58     virtual ~EmulatedCamera();
59 
60     /****************************************************************************
61      * Abstract API
62      ***************************************************************************/
63 
64 public:
65     /* Gets emulated camera device used by this instance of the emulated camera.
66      */
67     virtual EmulatedCameraDevice* getCameraDevice() = 0;
68 
69     /****************************************************************************
70      * Public API
71      ***************************************************************************/
72 
73 public:
74     /** Override of base class method */
75     virtual status_t Initialize();
76 
77     /* Next frame is available in the camera device.
78      * This is a notification callback that is invoked by the camera device when
79      * a new frame is available.
80      * Note that most likely this method is called in context of a worker thread
81      * that camera device has created for frame capturing.
82      * Param:
83      *  frame - Captured frame, or NULL if camera device didn't pull the frame
84      *      yet. If NULL is passed in this parameter use GetCurrentFrame method
85      *      of the camera device class to obtain the next frame. Also note that
86      *      the size of the frame that is passed here (as well as the frame
87      *      returned from the GetCurrentFrame method) is defined by the current
88      *      frame settings (width + height + pixel format) for the camera device.
89      * timestamp - Frame's timestamp.
90      * camera_dev - Camera device instance that delivered the frame.
91      */
92     virtual void onNextFrameAvailable(const void* frame,
93                                       nsecs_t timestamp,
94                                       EmulatedCameraDevice* camera_dev);
95 
96     /* Entry point for notifications that occur in camera device.
97      * Param:
98      *  err - CAMERA_ERROR_XXX error code.
99      */
100     virtual void onCameraDeviceError(int err);
101 
102     /****************************************************************************
103      * Camera API implementation
104      ***************************************************************************/
105 
106 public:
107     /** Override of base class method */
108     virtual status_t connectCamera(hw_device_t** device);
109 
110     /** Override of base class method */
111     virtual status_t closeCamera();
112 
113     /** Override of base class method */
114     virtual status_t getCameraInfo(struct camera_info* info);
115 
116     /****************************************************************************
117      * Camera API implementation.
118      * These methods are called from the camera API callback routines.
119      ***************************************************************************/
120 
121 protected:
122     /* Actual handler for camera_device_ops_t::set_preview_window callback.
123      * NOTE: When this method is called the object is locked.
124      * Note that failures in this method are reported as negave EXXX statuses.
125      */
126     virtual status_t setPreviewWindow(struct preview_stream_ops *window);
127 
128     /* Actual handler for camera_device_ops_t::set_callbacks callback.
129      * NOTE: When this method is called the object is locked.
130      */
131     virtual void setCallbacks(camera_notify_callback notify_cb,
132                               camera_data_callback data_cb,
133                               camera_data_timestamp_callback data_cb_timestamp,
134                               camera_request_memory get_memory,
135                               void* user);
136 
137     /* Actual handler for camera_device_ops_t::enable_msg_type callback.
138      * NOTE: When this method is called the object is locked.
139      */
140     virtual void enableMsgType(int32_t msg_type);
141 
142     /* Actual handler for camera_device_ops_t::disable_msg_type callback.
143      * NOTE: When this method is called the object is locked.
144      */
145     virtual void disableMsgType(int32_t msg_type);
146 
147     /* Actual handler for camera_device_ops_t::msg_type_enabled callback.
148      * NOTE: When this method is called the object is locked.
149      * Return:
150      *  0 if message(s) is (are) disabled, != 0 if enabled.
151      */
152     virtual int isMsgTypeEnabled(int32_t msg_type);
153 
154     /* Actual handler for camera_device_ops_t::start_preview callback.
155      * NOTE: When this method is called the object is locked.
156      * Note that failures in this method are reported as negave EXXX statuses.
157      */
158     virtual status_t startPreview();
159 
160     /* Actual handler for camera_device_ops_t::stop_preview callback.
161      * NOTE: When this method is called the object is locked.
162      */
163     virtual void stopPreview();
164 
165     /* Actual handler for camera_device_ops_t::preview_enabled callback.
166      * NOTE: When this method is called the object is locked.
167      * Return:
168      *  0 if preview is disabled, != 0 if enabled.
169      */
170     virtual int isPreviewEnabled();
171 
172     /* Actual handler for camera_device_ops_t::store_meta_data_in_buffers callback.
173      * NOTE: When this method is called the object is locked.
174      * Note that failures in this method are reported as negave EXXX statuses.
175      */
176     virtual status_t storeMetaDataInBuffers(int enable);
177 
178     /* Actual handler for camera_device_ops_t::start_recording callback.
179      * NOTE: When this method is called the object is locked.
180      * Note that failures in this method are reported as negave EXXX statuses.
181      */
182     virtual status_t startRecording();
183 
184     /* Actual handler for camera_device_ops_t::stop_recording callback.
185      * NOTE: When this method is called the object is locked.
186      */
187     virtual void stopRecording();
188 
189     /* Actual handler for camera_device_ops_t::recording_enabled callback.
190      * NOTE: When this method is called the object is locked.
191      * Return:
192      *  0 if recording is disabled, != 0 if enabled.
193      */
194     virtual int isRecordingEnabled();
195 
196     /* Actual handler for camera_device_ops_t::release_recording_frame callback.
197      * NOTE: When this method is called the object is locked.
198      */
199     virtual void releaseRecordingFrame(const void* opaque);
200 
201     /* Actual handler for camera_device_ops_t::auto_focus callback.
202      * NOTE: When this method is called the object is locked.
203      * Note that failures in this method are reported as negave EXXX statuses.
204      */
205     virtual status_t setAutoFocus();
206 
207     /* Actual handler for camera_device_ops_t::cancel_auto_focus callback.
208      * NOTE: When this method is called the object is locked.
209      * Note that failures in this method are reported as negave EXXX statuses.
210      */
211     virtual status_t cancelAutoFocus();
212 
213     /* Actual handler for camera_device_ops_t::take_picture callback.
214      * NOTE: When this method is called the object is locked.
215      * Note that failures in this method are reported as negave EXXX statuses.
216      */
217     virtual status_t takePicture();
218 
219     /* Actual handler for camera_device_ops_t::cancel_picture callback.
220      * NOTE: When this method is called the object is locked.
221      * Note that failures in this method are reported as negave EXXX statuses.
222      */
223     virtual status_t cancelPicture();
224 
225     /* Actual handler for camera_device_ops_t::set_parameters callback.
226      * NOTE: When this method is called the object is locked.
227      * Note that failures in this method are reported as negave EXXX statuses.
228      */
229     virtual status_t setParameters(const char* parms);
230 
231     /* Actual handler for camera_device_ops_t::get_parameters callback.
232      * NOTE: When this method is called the object is locked.
233      * Return:
234      *  Flattened parameters string. The caller will free the buffer allocated
235      *  for the string by calling camera_device_ops_t::put_parameters callback.
236      */
237     virtual char* getParameters();
238 
239     /* Actual handler for camera_device_ops_t::put_parameters callback.
240      * Called to free the string returned from camera_device_ops_t::get_parameters
241      * callback. There is nothing more to it: the name of the callback is just
242      * misleading.
243      * NOTE: When this method is called the object is locked.
244      */
245     virtual void putParameters(char* params);
246 
247     /* Actual handler for camera_device_ops_t::send_command callback.
248      * NOTE: When this method is called the object is locked.
249      * Note that failures in this method are reported as negave EXXX statuses.
250      */
251     virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
252 
253     /* Actual handler for camera_device_ops_t::release callback.
254      * NOTE: When this method is called the object is locked.
255      */
256     virtual void releaseCamera();
257 
258     /* Actual handler for camera_device_ops_t::dump callback.
259      * NOTE: When this method is called the object is locked.
260      * Note that failures in this method are reported as negave EXXX statuses.
261      */
262     virtual status_t dumpCamera(int fd);
263 
264     /****************************************************************************
265      * Preview management.
266      ***************************************************************************/
267 
268 protected:
269     /* Starts preview.
270      * Note that when this method is called mPreviewWindow may be NULL,
271      * indicating that framework has an intention to start displaying video
272      * frames, but didn't create the preview window yet.
273      * Return:
274      *  NO_ERROR on success, or an appropriate error status on failure.
275      */
276     virtual status_t doStartPreview();
277 
278     /* Stops preview.
279      * This method reverts DoStartPreview.
280      * Return:
281      *  NO_ERROR on success, or an appropriate error status on failure.
282      */
283     virtual status_t doStopPreview();
284 
285     /****************************************************************************
286      * Private API.
287      ***************************************************************************/
288 
289 protected:
290     /* Cleans up camera when released. */
291     virtual status_t cleanupCamera();
292 
293     /****************************************************************************
294      * Camera API callbacks as defined by camera_device_ops structure.
295      * See hardware/libhardware/include/hardware/camera.h for information on
296      * each of these callbacks. Implemented in this class, these callbacks simply
297      * dispatch the call into an instance of EmulatedCamera class defined by the
298      * 'camera_device' parameter.
299      ***************************************************************************/
300 
301 private:
302     static int set_preview_window(struct camera_device* dev,
303                                    struct preview_stream_ops* window);
304 
305     static void set_callbacks(struct camera_device* dev,
306                               camera_notify_callback notify_cb,
307                               camera_data_callback data_cb,
308                               camera_data_timestamp_callback data_cb_timestamp,
309                               camera_request_memory get_memory,
310                               void* user);
311 
312     static void enable_msg_type(struct camera_device* dev, int32_t msg_type);
313 
314     static void disable_msg_type(struct camera_device* dev, int32_t msg_type);
315 
316     static int msg_type_enabled(struct camera_device* dev, int32_t msg_type);
317 
318     static int start_preview(struct camera_device* dev);
319 
320     static void stop_preview(struct camera_device* dev);
321 
322     static int preview_enabled(struct camera_device* dev);
323 
324     static int store_meta_data_in_buffers(struct camera_device* dev, int enable);
325 
326     static int start_recording(struct camera_device* dev);
327 
328     static void stop_recording(struct camera_device* dev);
329 
330     static int recording_enabled(struct camera_device* dev);
331 
332     static void release_recording_frame(struct camera_device* dev,
333                                         const void* opaque);
334 
335     static int auto_focus(struct camera_device* dev);
336 
337     static int cancel_auto_focus(struct camera_device* dev);
338 
339     static int take_picture(struct camera_device* dev);
340 
341     static int cancel_picture(struct camera_device* dev);
342 
343     static int set_parameters(struct camera_device* dev, const char* parms);
344 
345     static char* get_parameters(struct camera_device* dev);
346 
347     static void put_parameters(struct camera_device* dev, char* params);
348 
349     static int send_command(struct camera_device* dev,
350                             int32_t cmd,
351                             int32_t arg1,
352                             int32_t arg2);
353 
354     static void release(struct camera_device* dev);
355 
356     static int dump(struct camera_device* dev, int fd);
357 
358     static int close(struct hw_device_t* device);
359 
360     /****************************************************************************
361      * Data members
362      ***************************************************************************/
363 
364 protected:
365     /* Locks this instance for parameters, state, etc. change. */
366     Mutex                           mObjectLock;
367 
368     /* Camera parameters. */
369     CameraParameters                mParameters;
370 
371     /* Preview window. */
372     PreviewWindow                   mPreviewWindow;
373 
374     /* Callback notifier. */
375     CallbackNotifier                mCallbackNotifier;
376 
377 private:
378     /* Registered callbacks implementing camera API. */
379     static camera_device_ops_t      mDeviceOps;
380 
381     /****************************************************************************
382      * Common keys
383      ***************************************************************************/
384 
385 public:
386     static const char FACING_KEY[];
387     static const char ORIENTATION_KEY[];
388     static const char RECORDING_HINT_KEY[];
389 
390      /****************************************************************************
391      * Common string values
392      ***************************************************************************/
393 
394     /* Possible values for FACING_KEY */
395     static const char FACING_BACK[];
396     static const char FACING_FRONT[];
397 };
398 
399 }; /* namespace android */
400 
401 #endif  /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_H */
402