diff options
Diffstat (limited to 'guest/hals/camera/CallbackNotifier.cpp')
| -rw-r--r-- | guest/hals/camera/CallbackNotifier.cpp | 313 |
1 files changed, 313 insertions, 0 deletions
diff --git a/guest/hals/camera/CallbackNotifier.cpp b/guest/hals/camera/CallbackNotifier.cpp new file mode 100644 index 000000000..765d4e7d9 --- /dev/null +++ b/guest/hals/camera/CallbackNotifier.cpp @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2011 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. + */ + +/* + * Contains implementation of a class CallbackNotifier that manages callbacks + * set via set_callbacks, enable_msg_type, and disable_msg_type camera HAL API. + */ + +#define LOG_NDEBUG 0 +#define LOG_TAG "EmulatedCamera_CallbackNotifier" +#include "CallbackNotifier.h" +#include <MetadataBufferType.h> +#include <log/log.h> +#include "EmulatedCameraDevice.h" +#include "JpegCompressor.h" +#include "Exif.h" +#include "Thumbnail.h" + +namespace android { + +/* String representation of camera messages. */ +static const char* lCameraMessages[] = {"CAMERA_MSG_ERROR", + "CAMERA_MSG_SHUTTER", + "CAMERA_MSG_FOCUS", + "CAMERA_MSG_ZOOM", + "CAMERA_MSG_PREVIEW_FRAME", + "CAMERA_MSG_VIDEO_FRAME", + "CAMERA_MSG_POSTVIEW_FRAME", + "CAMERA_MSG_RAW_IMAGE", + "CAMERA_MSG_COMPRESSED_IMAGE", + "CAMERA_MSG_RAW_IMAGE_NOTIFY", + "CAMERA_MSG_PREVIEW_METADATA"}; +static const int lCameraMessagesNum = sizeof(lCameraMessages) / sizeof(char*); + +/* Builds an array of strings for the given set of messages. + * Param: + * msg - Messages to get strings for, + * strings - Array where to save strings + * max - Maximum number of entries in the array. + * Return: + * Number of strings saved into the 'strings' array. + */ +static int GetMessageStrings(uint32_t msg, const char** strings, int max) { + int index = 0; + int out = 0; + while (msg != 0 && out < max && index < lCameraMessagesNum) { + while ((msg & 0x1) == 0 && index < lCameraMessagesNum) { + msg >>= 1; + index++; + } + if ((msg & 0x1) != 0 && index < lCameraMessagesNum) { + strings[out] = lCameraMessages[index]; + out++; + msg >>= 1; + index++; + } + } + + return out; +} + +/* Logs messages, enabled by the mask. */ +static void PrintMessages(uint32_t msg) { + const char* strs[lCameraMessagesNum]; + const int translated = GetMessageStrings(msg, strs, lCameraMessagesNum); + for (int n = 0; n < translated; n++) { + ALOGV(" %s", strs[n]); + } +} + +CallbackNotifier::CallbackNotifier() + : mNotifyCB(NULL), + mDataCB(NULL), + mDataCBTimestamp(NULL), + mGetMemoryCB(NULL), + mCBOpaque(NULL), + mLastFrameTimestamp(0), + mFrameRefreshFreq(0), + mMessageEnabler(0), + mJpegQuality(90), + mVideoRecEnabled(false), + mTakingPicture(false) {} + +CallbackNotifier::~CallbackNotifier() {} + +/**************************************************************************** + * Camera API + ***************************************************************************/ + +void CallbackNotifier::setCallbacks( + camera_notify_callback notify_cb, camera_data_callback data_cb, + camera_data_timestamp_callback data_cb_timestamp, + camera_request_memory get_memory, void* user) { + ALOGV("%s: %p, %p, %p, %p (%p)", __FUNCTION__, notify_cb, data_cb, + data_cb_timestamp, get_memory, user); + + Mutex::Autolock locker(&mObjectLock); + mNotifyCB = notify_cb; + mDataCB = data_cb; + mDataCBTimestamp = data_cb_timestamp; + mGetMemoryCB = get_memory; + mCBOpaque = user; +} + +void CallbackNotifier::enableMessage(uint msg_type) { + ALOGV("%s: msg_type = 0x%x", __FUNCTION__, msg_type); + PrintMessages(msg_type); + + Mutex::Autolock locker(&mObjectLock); + mMessageEnabler |= msg_type; + ALOGV("**** Currently enabled messages:"); + PrintMessages(mMessageEnabler); +} + +void CallbackNotifier::disableMessage(uint msg_type) { + ALOGV("%s: msg_type = 0x%x", __FUNCTION__, msg_type); + PrintMessages(msg_type); + + Mutex::Autolock locker(&mObjectLock); + mMessageEnabler &= ~msg_type; + ALOGV("**** Currently enabled messages:"); + PrintMessages(mMessageEnabler); +} + +status_t CallbackNotifier::enableVideoRecording(int fps) { + ALOGV("%s: FPS = %d", __FUNCTION__, fps); + + Mutex::Autolock locker(&mObjectLock); + mVideoRecEnabled = true; + mLastFrameTimestamp = 0; + mFrameRefreshFreq = 1000000000LL / fps; + + return NO_ERROR; +} + +void CallbackNotifier::disableVideoRecording() { + ALOGV("%s:", __FUNCTION__); + + Mutex::Autolock locker(&mObjectLock); + mVideoRecEnabled = false; + mLastFrameTimestamp = 0; + mFrameRefreshFreq = 0; +} + +void CallbackNotifier::releaseRecordingFrame(const void* opaque) { + List<camera_memory_t*>::iterator it = mCameraMemoryTs.begin(); + for (; it != mCameraMemoryTs.end(); ++it) { + if ((*it)->data == opaque) { + (*it)->release(*it); + mCameraMemoryTs.erase(it); + break; + } + } +} + +status_t CallbackNotifier::storeMetaDataInBuffers(bool enable) { + // Return error if metadata is request, otherwise silently agree. + return enable ? INVALID_OPERATION : NO_ERROR; +} + +/**************************************************************************** + * Public API + ***************************************************************************/ + +void CallbackNotifier::cleanupCBNotifier() { + Mutex::Autolock locker(&mObjectLock); + mMessageEnabler = 0; + mNotifyCB = NULL; + mDataCB = NULL; + mDataCBTimestamp = NULL; + mGetMemoryCB = NULL; + mCBOpaque = NULL; + mLastFrameTimestamp = 0; + mFrameRefreshFreq = 0; + mJpegQuality = 90; + mVideoRecEnabled = false; + mTakingPicture = false; +} + +void CallbackNotifier::onNextFrameAvailable(const void* frame, + nsecs_t timestamp, + EmulatedCameraDevice* camera_dev) { + if (isMessageEnabled(CAMERA_MSG_VIDEO_FRAME) && isVideoRecordingEnabled() && + isNewVideoFrameTime(timestamp)) { + camera_memory_t* cam_buff = + mGetMemoryCB(-1, camera_dev->getFrameBufferSize(), 1, mCBOpaque); + if (NULL != cam_buff && NULL != cam_buff->data) { + memcpy(cam_buff->data, frame, camera_dev->getFrameBufferSize()); + mDataCBTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, cam_buff, 0, + mCBOpaque); + + mCameraMemoryTs.push_back(cam_buff); + } else { + ALOGE("%s: Memory failure in CAMERA_MSG_VIDEO_FRAME", __FUNCTION__); + } + } + + if (isMessageEnabled(CAMERA_MSG_PREVIEW_FRAME)) { + camera_memory_t* cam_buff = + mGetMemoryCB(-1, camera_dev->getFrameBufferSize(), 1, mCBOpaque); + if (NULL != cam_buff && NULL != cam_buff->data) { + memcpy(cam_buff->data, frame, camera_dev->getFrameBufferSize()); + mDataCB(CAMERA_MSG_PREVIEW_FRAME, cam_buff, 0, NULL, mCBOpaque); + cam_buff->release(cam_buff); + } else { + ALOGE("%s: Memory failure in CAMERA_MSG_PREVIEW_FRAME", __FUNCTION__); + } + } + + if (mTakingPicture) { + /* This happens just once. */ + mTakingPicture = false; + /* The sequence of callbacks during picture taking is: + * - CAMERA_MSG_SHUTTER + * - CAMERA_MSG_RAW_IMAGE_NOTIFY + * - CAMERA_MSG_COMPRESSED_IMAGE + */ + if (isMessageEnabled(CAMERA_MSG_SHUTTER)) { + mNotifyCB(CAMERA_MSG_SHUTTER, 0, 0, mCBOpaque); + } + if (isMessageEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY)) { + mNotifyCB(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCBOpaque); + } + if (isMessageEnabled(CAMERA_MSG_COMPRESSED_IMAGE)) { + /* Compress the frame to JPEG. Note that when taking pictures, we + * have requested camera device to provide us with NV21 frames. */ + NV21JpegCompressor compressor; + const CameraParameters* cameraParameters = camera_dev->getCameraParameters(); + if (cameraParameters == nullptr) { + ALOGE("%s: Could not get camera parameters to take picture.", __FUNCTION__); + return; + } + + ExifData* exifData = createExifData(*cameraParameters); + + // Create a thumbnail and place the pointer and size in the EXIF + // data structure. This transfers ownership to the EXIF data and + // the memory will be deallocated in the freeExifData call below. + int width = camera_dev->getFrameWidth(); + int height = camera_dev->getFrameHeight(); + int thumbWidth = cameraParameters->getInt( + CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); + int thumbHeight = cameraParameters->getInt( + CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); + if (thumbWidth > 0 && thumbHeight > 0) { + if (!createThumbnail(static_cast<const unsigned char*>(frame), + width, height, thumbWidth, thumbHeight, + mJpegQuality, exifData)) { + // Not really a fatal error, we'll just keep going + ALOGE("%s: Failed to create thumbnail for image", + __FUNCTION__); + } + } + + status_t res = compressor.compressRawImage(frame, exifData, mJpegQuality, width, height); + if (res == NO_ERROR) { + camera_memory_t* jpeg_buff = + mGetMemoryCB(-1, compressor.getCompressedSize(), 1, mCBOpaque); + if (NULL != jpeg_buff && NULL != jpeg_buff->data) { + compressor.getCompressedImage(jpeg_buff->data); + mDataCB(CAMERA_MSG_COMPRESSED_IMAGE, jpeg_buff, 0, NULL, mCBOpaque); + jpeg_buff->release(jpeg_buff); + } else { + ALOGE("%s: Memory failure in CAMERA_MSG_VIDEO_FRAME", __FUNCTION__); + } + } else { + ALOGE("%s: Compression failure in CAMERA_MSG_VIDEO_FRAME", + __FUNCTION__); + } + freeExifData(exifData); + } + } +} + +void CallbackNotifier::onCameraDeviceError(int err) { + if (isMessageEnabled(CAMERA_MSG_ERROR) && mNotifyCB != NULL) { + mNotifyCB(CAMERA_MSG_ERROR, err, 0, mCBOpaque); + } +} + +void CallbackNotifier::onCameraFocusAcquired() { + if (isMessageEnabled(CAMERA_MSG_FOCUS) && mNotifyCB != NULL) { + mNotifyCB(CAMERA_MSG_FOCUS, 1, 0, mCBOpaque); + } +} + +/**************************************************************************** + * Private API + ***************************************************************************/ + +bool CallbackNotifier::isNewVideoFrameTime(nsecs_t timestamp) { + Mutex::Autolock locker(&mObjectLock); + if ((timestamp - mLastFrameTimestamp) >= mFrameRefreshFreq) { + mLastFrameTimestamp = timestamp; + return true; + } + return false; +} + +}; /* namespace android */ |