diff options
Diffstat (limited to 'services/camera/libcameraservice/Camera3Device.cpp')
| -rw-r--r-- | services/camera/libcameraservice/Camera3Device.cpp | 375 |
1 files changed, 375 insertions, 0 deletions
diff --git a/services/camera/libcameraservice/Camera3Device.cpp b/services/camera/libcameraservice/Camera3Device.cpp new file mode 100644 index 0000000..2a1be09 --- /dev/null +++ b/services/camera/libcameraservice/Camera3Device.cpp @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "Camera3-Device" +#define ATRACE_TAG ATRACE_TAG_CAMERA +//#define LOG_NDEBUG 0 +//#define LOG_NNDEBUG 0 // Per-frame verbose logging + +#ifdef LOG_NNDEBUG +#define ALOGVV(...) ALOGV(__VA_ARGS__) +#else +#define ALOGVV(...) ((void)0) +#endif + +#include <utils/Log.h> +#include <utils/Trace.h> +#include <utils/Timers.h> +#include "Camera3Device.h" + +namespace android { + + +Camera3Device::Camera3Device(int id): + mId(id), + mHal3Device(NULL) +{ + ATRACE_CALL(); + camera3_callback_ops::notify = &sNotify; + camera3_callback_ops::process_capture_result = &sProcessCaptureResult; + ALOGV("%s: Created device for camera %d", __FUNCTION__, id); +} + +Camera3Device::~Camera3Device() +{ + ATRACE_CALL(); + ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId); + disconnect(); +} + +status_t Camera3Device::initialize(camera_module_t *module) +{ + ATRACE_CALL(); + ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId); + if (mHal3Device != NULL) { + ALOGE("%s: Already initialized!", __FUNCTION__); + return INVALID_OPERATION; + } + + /** Open HAL device */ + + status_t res; + String8 deviceName = String8::format("%d", mId); + + camera3_device_t *device; + + res = module->common.methods->open(&module->common, deviceName.string(), + reinterpret_cast<hw_device_t**>(&device)); + + if (res != OK) { + ALOGE("%s: Could not open camera %d: %s (%d)", __FUNCTION__, + mId, strerror(-res), res); + return res; + } + + /** Cross-check device version */ + + if (device->common.version != CAMERA_DEVICE_API_VERSION_3_0) { + ALOGE("%s: Could not open camera %d: " + "Camera device is not version %x, reports %x instead", + __FUNCTION__, mId, CAMERA_DEVICE_API_VERSION_3_0, + device->common.version); + device->common.close(&device->common); + return BAD_VALUE; + } + + camera_info info; + res = module->get_camera_info(mId, &info); + if (res != OK) return res; + + if (info.device_version != device->common.version) { + ALOGE("%s: HAL reporting mismatched camera_info version (%x)" + " and device version (%x).", __FUNCTION__, + device->common.version, info.device_version); + device->common.close(&device->common); + return BAD_VALUE; + } + + /** Initialize device with callback functions */ + + res = device->ops->initialize(device, this); + if (res != OK) { + ALOGE("%s: Camera %d: Unable to initialize HAL device: %s (%d)", + __FUNCTION__, mId, strerror(-res), res); + device->common.close(&device->common); + return BAD_VALUE; + } + + /** Get vendor metadata tags */ + + mVendorTagOps.get_camera_vendor_section_name = NULL; + + device->ops->get_metadata_vendor_tag_ops(device, &mVendorTagOps); + + if (mVendorTagOps.get_camera_vendor_section_name != NULL) { + res = set_camera_metadata_vendor_tag_ops(&mVendorTagOps); + if (res != OK) { + ALOGE("%s: Camera %d: Unable to set tag ops: %s (%d)", + __FUNCTION__, mId, strerror(-res), res); + device->common.close(&device->common); + return res; + } + } + + /** Start up request queue thread */ + + requestThread = new RequestThread(this); + res = requestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string()); + if (res != OK) { + ALOGE("%s: Camera %d: Unable to start request queue thread: %s (%d)", + __FUNCTION__, mId, strerror(-res), res); + device->common.close(&device->common); + return res; + } + + /** Everything is good to go */ + + mDeviceInfo = info.static_camera_characteristics; + mHal3Device = device; + + return OK; +} + +status_t Camera3Device::disconnect() { + ATRACE_CALL(); + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::dump(int fd, const Vector<String16> &args) { + ATRACE_CALL(); + (void)args; + + mHal3Device->ops->dump(mHal3Device, fd); + + return OK; +} + +const CameraMetadata& Camera3Device::info() const { + ALOGVV("%s: E", __FUNCTION__); + + return mDeviceInfo; +} + +status_t Camera3Device::capture(CameraMetadata &request) { + ATRACE_CALL(); + (void)request; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + + +status_t Camera3Device::setStreamingRequest(const CameraMetadata &request) { + ATRACE_CALL(); + (void)request; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::clearStreamingRequest() { + ATRACE_CALL(); + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) { + ATRACE_CALL(); + (void)requestId; (void)timeout; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::createStream(sp<ANativeWindow> consumer, + uint32_t width, uint32_t height, int format, size_t size, int *id) { + ATRACE_CALL(); + (void)consumer; (void)width; (void)height; (void)format; + (void)size; (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) { + ATRACE_CALL(); + (void)outputId; (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + + +status_t Camera3Device::getStreamInfo(int id, + uint32_t *width, uint32_t *height, uint32_t *format) { + ATRACE_CALL(); + (void)id; (void)width; (void)height; (void)format; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::setStreamTransform(int id, + int transform) { + ATRACE_CALL(); + (void)id; (void)transform; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::deleteStream(int id) { + ATRACE_CALL(); + (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::deleteReprocessStream(int id) { + ATRACE_CALL(); + (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + + +status_t Camera3Device::createDefaultRequest(int templateId, + CameraMetadata *request) { + ATRACE_CALL(); + ALOGV("%s: E", __FUNCTION__); + + const camera_metadata_t *rawRequest; + rawRequest = mHal3Device->ops->construct_default_request_settings( + mHal3Device, templateId); + if (rawRequest == NULL) return DEAD_OBJECT; + *request = rawRequest; + + return OK; +} + +status_t Camera3Device::waitUntilDrained() { + ATRACE_CALL(); + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::setNotifyCallback(NotificationListener *listener) { + ATRACE_CALL(); + (void)listener; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::waitForNextFrame(nsecs_t timeout) { + (void)timeout; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::getNextFrame(CameraMetadata *frame) { + ATRACE_CALL(); + (void)frame; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::triggerAutofocus(uint32_t id) { + ATRACE_CALL(); + (void)id; + + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +status_t Camera3Device::triggerCancelAutofocus(uint32_t id) { + ATRACE_CALL(); + (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; + +} + +status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) { + ATRACE_CALL(); + (void)id; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; + +} + +status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId, + buffer_handle_t *buffer, wp<BufferReleasedListener> listener) { + ATRACE_CALL(); + (void)reprocessStreamId; (void)buffer; (void)listener; + + ALOGE("%s: Unimplemented", __FUNCTION__); + return INVALID_OPERATION; +} + +Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent) : + Thread(false), + mParent(parent) { +} + +bool Camera3Device::RequestThread::threadLoop() { + ALOGE("%s: Unimplemented", __FUNCTION__); + + return false; +} + +void Camera3Device::processCaptureResult(const camera3_capture_result *result) { + (void)result; + + ALOGE("%s: Unimplemented", __FUNCTION__); +} + +void Camera3Device::notify(const camera3_notify_msg *msg) { + (void)msg; + + ALOGE("%s: Unimplemented", __FUNCTION__); +} + +/** + * Static callback forwarding methods from HAL to instance + */ + +void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb, + const camera3_capture_result *result) { + Camera3Device *d = + const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb)); + d->processCaptureResult(result); +} + +void Camera3Device::sNotify(const camera3_callback_ops *cb, + const camera3_notify_msg *msg) { + Camera3Device *d = + const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb)); + d->notify(msg); +} + +}; // namespace android |