2 * Copyright (C) 2017, The LineageOS Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #define LOG_PARAMETERS
20 #define LOG_TAG "Camera2Wrapper"
21 #include <cutils/log.h>
24 #include <stdatomic.h>
26 #include "CameraWrapper.h"
27 #include "Camera2Wrapper.h"
28 #include "CallbackWorkerThread.h"
30 CallbackWorkerThread cbThread
;
34 /* current_timestamp() function from stack overflow:
35 * https://stackoverflow.com/questions/3756323/how-to-get-the-current-time-in-milliseconds-from-c-in-linux/17083824
38 long long current_timestamp() {
40 gettimeofday(&te
, NULL
); // get current time
41 long long milliseconds
= te
.tv_sec
*1000LL + te
.tv_usec
/1000; // calculate milliseconds
42 // printf("milliseconds: %lld\n", milliseconds);
46 typedef struct wrapper_camera2_device
{
49 camera_device_t
*vendor
;
50 } wrapper_camera2_device_t
;
52 #define VENDOR_CALL(device, func, ...) ({ \
53 wrapper_camera2_device_t *__wrapper_dev = (wrapper_camera2_device_t*) device; \
54 __wrapper_dev->vendor->ops->func(__wrapper_dev->vendor, ##__VA_ARGS__); \
57 #define CAMERA_ID(device) (((wrapper_camera2_device_t *)(device))->id)
59 static camera_module_t
*gVendorModule
= 0;
60 static preview_stream_ops
*gPreviewWindow
= 0;
61 static bool gPreviewStartDeferred
= false;
63 static int check_vendor_module()
66 ALOGV("%s", __FUNCTION__
);
71 rv
= hw_get_module_by_class("camera", "vendor", (const hw_module_t
**)&gVendorModule
);
73 ALOGE("failed to open vendor camera module");
77 /*******************************************************************
78 * Camera2 wrapper fixup functions
79 *******************************************************************/
81 static char * camera2_fixup_getparams(int id __unused
, const char * settings
) {
82 android::CameraParameters params
;
83 params
.unflatten(android::String8(settings
));
86 ALOGV("%s: Original parameters:", __FUNCTION__
);
91 ALOGV("%s: Fixed parameters:", __FUNCTION__
);
95 android::String8 strParams
= params
.flatten();
96 char *ret
= strdup(strParams
.string());
101 static char * camera2_fixup_setparams(int id __unused
, const char * settings
) {
102 android::CameraParameters params
;
103 params
.unflatten(android::String8(settings
));
105 #ifdef LOG_PARAMETERS
106 ALOGV("%s: Original parameters:", __FUNCTION__
);
110 #ifdef LOG_PARAMETERS
111 ALOGV("%s: Fixed parameters:", __FUNCTION__
);
115 android::String8 strParams
= params
.flatten();
116 char *ret
= strdup(strParams
.string());
121 /*******************************************************************
122 * implementation of camera_device_ops functions
123 *******************************************************************/
125 static int camera2_set_preview_window(struct camera_device
* device
,
126 struct preview_stream_ops
*window
)
129 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
134 gPreviewWindow
= window
;
136 if (gPreviewWindow
!= 0) {
137 rc
= VENDOR_CALL(device
, set_preview_window
, window
);
139 if (gPreviewStartDeferred
) {
140 ALOGV("%s call deferred start_preview", __FUNCTION__
);
141 gPreviewStartDeferred
= false;
142 VENDOR_CALL(device
, start_preview
);
151 void WrappedNotifyCb (int32_t msg_type
, int32_t ext1
, int32_t ext2
, void *user
) {
152 ALOGV("%s->In", __FUNCTION__
);
154 /* Print a log message and return if we currently blocking adding callbacks */
156 ALOGV("%s->BlockCbs == 1", __FUNCTION__
);
160 /* Create message to send to the callback worker */
161 WorkerMessage
* newWorkerMessage
= new WorkerMessage();
162 newWorkerMessage
->CbType
= CB_TYPE_NOTIFY
;
164 /* Copy the callback data to our worker message */
165 newWorkerMessage
->msg_type
= msg_type
;
166 newWorkerMessage
->ext1
= ext1
;
167 newWorkerMessage
->ext2
= ext2
;
168 newWorkerMessage
->user
= user
;
170 /* Post the message to the callback worker */
171 cbThread
.AddCallback(newWorkerMessage
);
173 /* 5mS delay to slow down the camera hal thread */
175 ALOGV("%s->Out", __FUNCTION__
);
178 void WrappedDataCb (int32_t msg_type
, const camera_memory_t
*data
, unsigned int index
,
179 camera_frame_metadata_t
*metadata
, void *user
) {
180 ALOGV("%s->In, %i, %u", __FUNCTION__
, msg_type
, index
);
182 /* Print a log message and return if we currently blocking adding callbacks */
184 ALOGV("%s->BlockCbs == 1", __FUNCTION__
);
188 /* Create message to send to the callback worker */
189 WorkerMessage
* newWorkerMessage
= new WorkerMessage();
190 newWorkerMessage
->CbType
= CB_TYPE_DATA
;
192 /* Copy the callback data to our worker message */
193 newWorkerMessage
->msg_type
= msg_type
;
194 newWorkerMessage
->data
= data
;
195 newWorkerMessage
->index
= index
;
196 newWorkerMessage
->metadata
= metadata
;
197 newWorkerMessage
->user
= user
;
199 /* Post the message to the callback worker */
200 cbThread
.AddCallback(newWorkerMessage
);
202 /* 20mS delay to slow down the camera hal thread */
204 ALOGV("%s->Out", __FUNCTION__
);
207 static void camera2_set_callbacks(struct camera_device
* device
,
208 camera_notify_callback notify_cb
,
209 camera_data_callback data_cb
,
210 camera_data_timestamp_callback data_cb_timestamp
,
211 camera_request_memory get_memory
,
214 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
219 /* Create and populate a new callback data structure */
220 CallbackData
* newCallbackData
= new CallbackData();
221 newCallbackData
->NewUserNotifyCb
= notify_cb
;
222 newCallbackData
->NewUserDataCb
= data_cb
;
224 /* Send it to our worker thread */
225 cbThread
.SetCallbacks(newCallbackData
);
227 /* Call the set_callbacks function substituting the notify callback with our wrapper */
228 VENDOR_CALL(device
, set_callbacks
, WrappedNotifyCb
, WrappedDataCb
, data_cb_timestamp
, get_memory
, user
);
231 static void camera2_enable_msg_type(struct camera_device
* device
, int32_t msg_type
)
233 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
238 VENDOR_CALL(device
, enable_msg_type
, msg_type
);
241 static void camera2_disable_msg_type(struct camera_device
* device
, int32_t msg_type
)
243 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
248 VENDOR_CALL(device
, disable_msg_type
, msg_type
);
251 static int camera2_msg_type_enabled(struct camera_device
* device
, int32_t msg_type
)
253 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
258 return VENDOR_CALL(device
, msg_type_enabled
, msg_type
);
261 static int camera2_start_preview(struct camera_device
* device
)
264 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
269 if (gPreviewWindow
!= 0) {
270 rc
= VENDOR_CALL(device
, start_preview
);
272 ALOGV("%s invalid preview window, defer start_preview", __FUNCTION__
);
273 gPreviewStartDeferred
= true;
279 static void camera2_stop_preview(struct camera_device
* device
)
281 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
286 /* Block queueing more callbacks */
289 /* Clear the callback queue */
290 cbThread
.ClearCallbacks();
291 /* Execute stop_preview */
292 VENDOR_CALL(device
, stop_preview
);
294 /* Unblock queueing more callbacks */
298 static int camera2_preview_enabled(struct camera_device
* device
)
300 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
305 if (gPreviewStartDeferred
) {
306 ALOGV("%s deferred start_preview, return 1", __FUNCTION__
);
309 return VENDOR_CALL(device
, preview_enabled
);
313 static int camera2_store_meta_data_in_buffers(struct camera_device
* device
, int enable
)
315 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
320 return VENDOR_CALL(device
, store_meta_data_in_buffers
, enable
);
323 static int camera2_start_recording(struct camera_device
* device
)
325 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
330 return VENDOR_CALL(device
, start_recording
);
333 static void camera2_stop_recording(struct camera_device
* device
)
335 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
341 VENDOR_CALL(device
, stop_recording
);
344 static int camera2_recording_enabled(struct camera_device
* device
)
346 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
351 return VENDOR_CALL(device
, recording_enabled
);
354 static void camera2_release_recording_frame(struct camera_device
* device
,
357 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
362 VENDOR_CALL(device
, release_recording_frame
, opaque
);
365 long long CancelAFTimeGuard
= 0;
367 static int camera2_auto_focus(struct camera_device
* device
)
370 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
375 /* Clear the callback queue */
376 cbThread
.ClearCallbacks();
378 /* Call the auto_focus function */
379 Ret
= VENDOR_CALL(device
, auto_focus
);
381 /* Set the cancel_auto_focus time guard to now plus 500mS */
382 CancelAFTimeGuard
= current_timestamp() + 500;
387 static int camera2_cancel_auto_focus(struct camera_device
* device
)
390 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
395 /* Block queueing more callbacks */
398 /* Clear the callback queue */
399 cbThread
.ClearCallbacks();
401 /* Calculate the difference between our guard time and now */
402 long long TimeDiff
= CancelAFTimeGuard
- current_timestamp();
403 /* Post a log message and return success (skipping the call) if the diff is greater than 0 */
405 ALOGV("%s: CancelAFTimeGuard for %lli mS\n", __FUNCTION__
, TimeDiff
* 1000);
409 /* No active time guard so call the vendor function */
410 Ret
= VENDOR_CALL(device
, cancel_auto_focus
);
412 /* Unblock queueing more callbacks */
418 static int camera2_take_picture(struct camera_device
* device
)
420 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
425 return VENDOR_CALL(device
, take_picture
);
428 static int camera2_cancel_picture(struct camera_device
* device
)
430 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
435 return VENDOR_CALL(device
, cancel_picture
);
438 static int camera2_set_parameters(struct camera_device
* device
, const char *params
)
440 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
446 tmp
= camera2_fixup_setparams(CAMERA_ID(device
), params
);
448 int ret
= VENDOR_CALL(device
, set_parameters
, tmp
);
453 static char* camera2_get_parameters(struct camera_device
* device
)
455 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
460 char* params
= VENDOR_CALL(device
, get_parameters
);
462 char * tmp
= camera2_fixup_getparams(CAMERA_ID(device
), params
);
463 VENDOR_CALL(device
, put_parameters
, params
);
469 static void camera2_put_parameters(struct camera_device
*device
, char *params
)
471 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
477 static int camera2_send_command(struct camera_device
* device
,
478 int32_t cmd
, int32_t arg1
, int32_t arg2
)
480 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
485 return VENDOR_CALL(device
, send_command
, cmd
, arg1
, arg2
);
488 static void camera2_release(struct camera_device
* device
)
490 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
495 VENDOR_CALL(device
, release
);
498 static int camera2_dump(struct camera_device
* device
, int fd
)
500 ALOGV("%s->%08X->%08X", __FUNCTION__
, (uintptr_t)device
, (uintptr_t)(((wrapper_camera2_device_t
*)device
)->vendor
));
505 return VENDOR_CALL(device
, dump
, fd
);
508 static int camera2_device_close(hw_device_t
* device
)
511 wrapper_camera2_device_t
*wrapper_dev
= NULL
;
513 ALOGV("%s", __FUNCTION__
);
515 android::Mutex::Autolock
lock(gCameraWrapperLock
);
522 wrapper_dev
= (wrapper_camera2_device_t
*) device
;
524 wrapper_dev
->vendor
->common
.close((hw_device_t
*)wrapper_dev
->vendor
);
525 if (wrapper_dev
->base
.ops
)
526 free(wrapper_dev
->base
.ops
);
530 gPreviewStartDeferred
= false;
532 /* Exit our callback dispatch thread */
533 cbThread
.ExitThread();
538 /*******************************************************************
539 * implementation of camera_module functions
540 *******************************************************************/
542 /* open device handle to one of the cameras
544 * assume camera service will keep singleton of each camera
545 * so this function will always only be called once per camera instance
548 int camera2_device_open(const hw_module_t
* module
, const char* name
,
549 hw_device_t
** device
)
554 wrapper_camera2_device_t
* camera2_device
= NULL
;
555 camera_device_ops_t
* camera2_ops
= NULL
;
557 android::Mutex::Autolock
lock(gCameraWrapperLock
);
559 /* Create our callback dispatch thread */
560 cbThread
.CreateThread();
563 ALOGV("%s", __FUNCTION__
);
566 if (check_vendor_module())
569 cameraid
= atoi(name
);
570 num_cameras
= gVendorModule
->get_number_of_cameras();
572 if (cameraid
> num_cameras
) {
573 ALOGE("camera service provided cameraid out of bounds, "
574 "cameraid = %d, num supported = %d",
575 cameraid
, num_cameras
);
580 camera2_device
= (wrapper_camera2_device_t
*)malloc(sizeof(*camera2_device
));
581 if (!camera2_device
) {
582 ALOGE("camera2_device allocation fail");
586 memset(camera2_device
, 0, sizeof(*camera2_device
));
587 camera2_device
->id
= cameraid
;
589 rv
= gVendorModule
->common
.methods
->open((const hw_module_t
*)gVendorModule
, name
,(hw_device_t
**)&(camera2_device
->vendor
));
592 ALOGE("vendor camera open fail");
595 ALOGV("%s: got vendor camera device 0x%08X", __FUNCTION__
, (uintptr_t)(camera2_device
->vendor
));
597 camera2_ops
= (camera_device_ops_t
*)malloc(sizeof(*camera2_ops
));
599 ALOGE("camera_ops allocation fail");
604 memset(camera2_ops
, 0, sizeof(*camera2_ops
));
606 camera2_device
->base
.common
.tag
= HARDWARE_DEVICE_TAG
;
607 camera2_device
->base
.common
.version
= CAMERA_DEVICE_API_VERSION_1_0
;
608 camera2_device
->base
.common
.module
= (hw_module_t
*)(module
);
609 camera2_device
->base
.common
.close
= camera2_device_close
;
610 camera2_device
->base
.ops
= camera2_ops
;
612 camera2_ops
->set_preview_window
= camera2_set_preview_window
;
613 camera2_ops
->set_callbacks
= camera2_set_callbacks
;
614 camera2_ops
->enable_msg_type
= camera2_enable_msg_type
;
615 camera2_ops
->disable_msg_type
= camera2_disable_msg_type
;
616 camera2_ops
->msg_type_enabled
= camera2_msg_type_enabled
;
617 camera2_ops
->start_preview
= camera2_start_preview
;
618 camera2_ops
->stop_preview
= camera2_stop_preview
;
619 camera2_ops
->preview_enabled
= camera2_preview_enabled
;
620 camera2_ops
->store_meta_data_in_buffers
= camera2_store_meta_data_in_buffers
;
621 camera2_ops
->start_recording
= camera2_start_recording
;
622 camera2_ops
->stop_recording
= camera2_stop_recording
;
623 camera2_ops
->recording_enabled
= camera2_recording_enabled
;
624 camera2_ops
->release_recording_frame
= camera2_release_recording_frame
;
625 camera2_ops
->auto_focus
= camera2_auto_focus
;
626 camera2_ops
->cancel_auto_focus
= camera2_cancel_auto_focus
;
627 camera2_ops
->take_picture
= camera2_take_picture
;
628 camera2_ops
->cancel_picture
= camera2_cancel_picture
;
629 camera2_ops
->set_parameters
= camera2_set_parameters
;
630 camera2_ops
->get_parameters
= camera2_get_parameters
;
631 camera2_ops
->put_parameters
= camera2_put_parameters
;
632 camera2_ops
->send_command
= camera2_send_command
;
633 camera2_ops
->release
= camera2_release
;
634 camera2_ops
->dump
= camera2_dump
;
636 *device
= &camera2_device
->base
.common
;
643 free(camera2_device
);
644 camera2_device
= NULL
;