modules: camera: Camera v3 Devices
Default camera HAL statically allocates camera devices. Update camera
device to API v3.
Change-Id: Ic53ffcf3b746b9b4011b932e26dbb0f533cba554
diff --git a/modules/camera/Camera.cpp b/modules/camera/Camera.cpp
index 6ae0a5d..203b772 100644
--- a/modules/camera/Camera.cpp
+++ b/modules/camera/Camera.cpp
@@ -16,6 +16,8 @@
#include <cstdlib>
#include <pthread.h>
+#include <hardware/camera3.h>
+#include "CameraHAL.h"
//#define LOG_NDEBUG 0
#define LOG_TAG "Camera"
@@ -32,24 +34,24 @@
// Shim passed to the framework to close an opened device.
static int close_device(hw_device_t* dev)
{
- camera2_device_t* cam_dev = reinterpret_cast<camera2_device_t*>(dev);
+ camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(dev);
Camera* cam = static_cast<Camera*>(cam_dev->priv);
return cam->close();
}
} // extern "C"
-Camera::Camera(int id, const hw_module_t* module)
- : mId(id),
- mBusy(false),
- mMetadata(NULL)
+Camera::Camera(int id)
+ : mId(id),
+ mBusy(false),
+ mCallbackOps(NULL)
{
pthread_mutex_init(&mMutex,
NULL); // No pthread mutex attributes.
- // TODO: fill in device operations function pointers
+ memset(&mDevice, 0, sizeof(mDevice));
mDevice.common.tag = HARDWARE_DEVICE_TAG;
- mDevice.common.module = const_cast<hw_module_t*>(module);
mDevice.common.close = close_device;
+ mDevice.ops = const_cast<camera3_device_ops_t*>(&sOps);
mDevice.priv = this;
}
@@ -57,20 +59,22 @@
{
}
-int Camera::open()
+int Camera::open(const hw_module_t *module, hw_device_t **device)
{
- ALOGV("%s: camera id %d", __func__, mId);
- ATRACE_BEGIN("open");
+ ALOGI("%s:%d: Opening camera device", __func__, mId);
+ ATRACE_BEGIN(__func__);
pthread_mutex_lock(&mMutex);
if (mBusy) {
pthread_mutex_unlock(&mMutex);
ATRACE_END();
- ALOGE("%s:id%d: Error, device already in use.", __func__, mId);
+ ALOGE("%s:%d: Error! Camera device already opened", __func__, mId);
return -EBUSY;
}
// TODO: open camera dev nodes, etc
mBusy = true;
+ mDevice.common.module = const_cast<hw_module_t*>(module);
+ *device = &mDevice.common;
pthread_mutex_unlock(&mMutex);
ATRACE_END();
@@ -79,13 +83,13 @@
int Camera::close()
{
- ALOGV("%s: camera id %d", __func__, mId);
- ATRACE_BEGIN("close");
+ ALOGI("%s:%d: Closing camera device", __func__, mId);
+ ATRACE_BEGIN(__func__);
pthread_mutex_lock(&mMutex);
if (!mBusy) {
pthread_mutex_unlock(&mMutex);
ATRACE_END();
- ALOGE("%s:id%d: Error, close() on not open device.", __func__, mId);
+ ALOGE("%s:%d: Error! Camera device not open", __func__, mId);
return -EINVAL;
}
@@ -97,36 +101,121 @@
return 0;
}
-int Camera::getCameraInfo(struct camera_info* info)
+int Camera::initialize(const camera3_callback_ops_t *callback_ops)
{
- ALOGV("%s: camera id %d: info=%p", __func__, mId, info);
- init();
- if (mMetadata == NULL) {
- ALOGE("%s:id%d: unable to initialize metadata.", __func__, mId);
- return -ENOENT;
- }
-
- // TODO: fill remainder of info struct
- info->static_camera_characteristics = mMetadata;
-
+ ALOGV("%s:%d: callback_ops=%p", __func__, mId, callback_ops);
+ mCallbackOps = callback_ops;
return 0;
}
-void Camera::init()
+int Camera::configureStreams(camera3_stream_configuration_t *stream_list)
{
- ATRACE_BEGIN("init");
- pthread_mutex_lock(&mMutex);
- if (mMetadata != NULL) {
- pthread_mutex_unlock(&mMutex);
+ ALOGV("%s:%d: stream_list=%p", __func__, mId, stream_list);
+ // TODO: validate input, create internal stream representations
+ return 0;
+}
+
+int Camera::registerStreamBuffers(const camera3_stream_buffer_set_t *buf_set)
+{
+ ALOGV("%s:%d: buffer_set=%p", __func__, mId, buf_set);
+ // TODO: register buffers with hardware
+ return 0;
+}
+
+const camera_metadata_t* Camera::constructDefaultRequestSettings(int type)
+{
+ ALOGV("%s:%d: type=%d", __func__, mId, type);
+ // TODO: return statically built default request
+ return NULL;
+}
+
+int Camera::processCaptureRequest(camera3_capture_request_t *request)
+{
+ ALOGV("%s:%d: request=%p", __func__, mId, request);
+ ATRACE_BEGIN(__func__);
+
+ if (request == NULL) {
+ ALOGE("%s:%d: NULL request recieved", __func__, mId);
ATRACE_END();
- return;
+ return -EINVAL;
}
- // TODO: init metadata, dummy value for now
- mMetadata = allocate_camera_metadata(1,1);
-
- pthread_mutex_unlock(&mMutex);
+ // TODO: verify request; submit request to hardware
ATRACE_END();
+ return 0;
}
+void Camera::getMetadataVendorTagOps(vendor_tag_query_ops_t *ops)
+{
+ ALOGV("%s:%d: ops=%p", __func__, mId, ops);
+ // TODO: return vendor tag ops
+}
+
+void Camera::dump(int fd)
+{
+ ALOGV("%s:%d: Dumping to fd %d", fd);
+ // TODO: dprintf all relevant state to fd
+}
+
+extern "C" {
+// Get handle to camera from device priv data
+static Camera *camdev_to_camera(const camera3_device_t *dev)
+{
+ return reinterpret_cast<Camera*>(dev->priv);
+}
+
+static int initialize(const camera3_device_t *dev,
+ const camera3_callback_ops_t *callback_ops)
+{
+ return camdev_to_camera(dev)->initialize(callback_ops);
+}
+
+static int configure_streams(const camera3_device_t *dev,
+ camera3_stream_configuration_t *stream_list)
+{
+ return camdev_to_camera(dev)->configureStreams(stream_list);
+}
+
+static int register_stream_buffers(const camera3_device_t *dev,
+ const camera3_stream_buffer_set_t *buffer_set)
+{
+ return camdev_to_camera(dev)->registerStreamBuffers(buffer_set);
+}
+
+static const camera_metadata_t *construct_default_request_settings(
+ const camera3_device_t *dev, int type)
+{
+ return camdev_to_camera(dev)->constructDefaultRequestSettings(type);
+}
+
+static int process_capture_request(const camera3_device_t *dev,
+ camera3_capture_request_t *request)
+{
+ return camdev_to_camera(dev)->processCaptureRequest(request);
+}
+
+static void get_metadata_vendor_tag_ops(const camera3_device_t *dev,
+ vendor_tag_query_ops_t *ops)
+{
+ camdev_to_camera(dev)->getMetadataVendorTagOps(ops);
+}
+
+static void dump(const camera3_device_t *dev, int fd)
+{
+ camdev_to_camera(dev)->dump(fd);
+}
+} // extern "C"
+
+const camera3_device_ops_t Camera::sOps = {
+ .initialize = default_camera_hal::initialize,
+ .configure_streams = default_camera_hal::configure_streams,
+ .register_stream_buffers = default_camera_hal::register_stream_buffers,
+ .construct_default_request_settings =
+ default_camera_hal::construct_default_request_settings,
+ .process_capture_request = default_camera_hal::process_capture_request,
+ .get_metadata_vendor_tag_ops =
+ default_camera_hal::get_metadata_vendor_tag_ops,
+ .dump = default_camera_hal::dump
+};
+
} // namespace default_camera_hal