darkkirb/android_device_lenovo_msm8937-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
android_device_lenovo_msm89.../camera/QCamera2/HAL/QCamera2HWI.cpp
Zhao Wei Liew 669d233045 land: Import OSS camera HAL 
CAF revision: AU_LINUX_ANDROID_LA.UM.5.1_RB1.06.00.01.192.038

Change-Id: I87589fea5e9c00c3bdc9c79cc6b2d6453c3d09b3
2017-02-12 07:26:24 +08:00

10067 lines
342 KiB
C++
Raw Blame History

/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_TAG "QCamera2HWI"
// To remove
#include <cutils/properties.h>
// System definitions
#include <utils/Errors.h>
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include "gralloc_priv.h"
#include "native_handle.h"
// Camera definitions
#include "android/QCamera2External.h"
#include "QCamera2HWI.h"
#include "QCameraBufferMaps.h"
#include "QCameraFlash.h"
#include "QCameraTrace.h"
extern "C" {
#include "mm_camera_dbg.h"
}
#define MAP_TO_DRIVER_COORDINATE(val, base, scale, offset) \
((int32_t)val * (int32_t)scale / (int32_t)base + (int32_t)offset)
#define CAMERA_MIN_STREAMING_BUFFERS 3
#define EXTRA_ZSL_PREVIEW_STREAM_BUF 2
#define CAMERA_MIN_JPEG_ENCODING_BUFFERS 2
#define CAMERA_MIN_VIDEO_BUFFERS 9
#define CAMERA_MIN_CALLBACK_BUFFERS 5
#define CAMERA_LONGSHOT_STAGES 4
#define CAMERA_MIN_CAMERA_BATCH_BUFFERS 6
#define CAMERA_ISP_PING_PONG_BUFFERS 2
#define MIN_UNDEQUEUED_BUFFERS 1 // This is required if preview window is not set
#define HDR_CONFIDENCE_THRESHOLD 0.4
#define CAMERA_OPEN_PERF_TIME_OUT 500 // 500 milliseconds
// Very long wait, just to be sure we don't deadlock
#define CAMERA_DEFERRED_THREAD_TIMEOUT 5000000000 // 5 seconds
#define CAMERA_DEFERRED_MAP_BUF_TIMEOUT 2000000000 // 2 seconds
#define CAMERA_MIN_METADATA_BUFFERS 10 // Need at least 10 for ZSL snapshot
#define CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS 5
namespace qcamera {
extern cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS];
extern pthread_mutex_t gCamLock;
volatile uint32_t gCamHalLogLevel = 1;
extern uint8_t gNumCameraSessions;
uint32_t QCamera2HardwareInterface::sNextJobId = 1;
camera_device_ops_t QCamera2HardwareInterface::mCameraOps = {
set_preview_window: QCamera2HardwareInterface::set_preview_window,
set_callbacks: QCamera2HardwareInterface::set_CallBacks,
enable_msg_type: QCamera2HardwareInterface::enable_msg_type,
disable_msg_type: QCamera2HardwareInterface::disable_msg_type,
msg_type_enabled: QCamera2HardwareInterface::msg_type_enabled,
start_preview: QCamera2HardwareInterface::start_preview,
stop_preview: QCamera2HardwareInterface::stop_preview,
preview_enabled: QCamera2HardwareInterface::preview_enabled,
store_meta_data_in_buffers: QCamera2HardwareInterface::store_meta_data_in_buffers,
start_recording: QCamera2HardwareInterface::start_recording,
stop_recording: QCamera2HardwareInterface::stop_recording,
recording_enabled: QCamera2HardwareInterface::recording_enabled,
release_recording_frame: QCamera2HardwareInterface::release_recording_frame,
auto_focus: QCamera2HardwareInterface::auto_focus,
cancel_auto_focus: QCamera2HardwareInterface::cancel_auto_focus,
take_picture: QCamera2HardwareInterface::take_picture,
cancel_picture: QCamera2HardwareInterface::cancel_picture,
set_parameters: QCamera2HardwareInterface::set_parameters,
get_parameters: QCamera2HardwareInterface::get_parameters,
put_parameters: QCamera2HardwareInterface::put_parameters,
send_command: QCamera2HardwareInterface::send_command,
release: QCamera2HardwareInterface::release,
dump: QCamera2HardwareInterface::dump,
};
/*===========================================================================
* FUNCTION : set_preview_window
*
* DESCRIPTION: set preview window.
*
* PARAMETERS :
* @device : ptr to camera device struct
* @window : window ops table
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::set_preview_window(struct camera_device *device,
struct preview_stream_ops *window)
{
ATRACE_CALL();
int rc = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d window = %p", hw->getCameraId(), window);
hw->lockAPI();
qcamera_api_result_t apiResult;
rc = hw->processAPI(QCAMERA_SM_EVT_SET_PREVIEW_WINDOW, (void *)window);
if (rc == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PREVIEW_WINDOW, &apiResult);
rc = apiResult.status;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return rc;
}
/*===========================================================================
* FUNCTION : set_CallBacks
*
* DESCRIPTION: set callbacks for notify and data
*
* PARAMETERS :
* @device : ptr to camera device struct
* @notify_cb : notify cb
* @data_cb : data cb
* @data_cb_timestamp : video data cd with timestamp
* @get_memory : ops table for request gralloc memory
* @user : user data ptr
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::set_CallBacks(struct camera_device *device,
camera_notify_callback notify_cb,
camera_data_callback data_cb,
camera_data_timestamp_callback data_cb_timestamp,
camera_request_memory get_memory,
void *user)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGD("E camera id %d", hw->getCameraId());
qcamera_sm_evt_setcb_payload_t payload;
payload.notify_cb = notify_cb;
payload.data_cb = data_cb;
payload.data_cb_timestamp = data_cb_timestamp;
payload.get_memory = get_memory;
payload.user = user;
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t rc = hw->processAPI(QCAMERA_SM_EVT_SET_CALLBACKS, (void *)&payload);
if (rc == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_CALLBACKS, &apiResult);
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : enable_msg_type
*
* DESCRIPTION: enable certain msg type
*
* PARAMETERS :
* @device : ptr to camera device struct
* @msg_type : msg type mask
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::enable_msg_type(struct camera_device *device, int32_t msg_type)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t rc = hw->processAPI(QCAMERA_SM_EVT_ENABLE_MSG_TYPE, (void *)&msg_type);
if (rc == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_ENABLE_MSG_TYPE, &apiResult);
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : disable_msg_type
*
* DESCRIPTION: disable certain msg type
*
* PARAMETERS :
* @device : ptr to camera device struct
* @msg_type : msg type mask
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::disable_msg_type(struct camera_device *device, int32_t msg_type)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t rc = hw->processAPI(QCAMERA_SM_EVT_DISABLE_MSG_TYPE, (void *)&msg_type);
if (rc == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_DISABLE_MSG_TYPE, &apiResult);
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : msg_type_enabled
*
* DESCRIPTION: if certain msg type is enabled
*
* PARAMETERS :
* @device : ptr to camera device struct
* @msg_type : msg type mask
*
* RETURN : 1 -- enabled
* 0 -- not enabled
*==========================================================================*/
int QCamera2HardwareInterface::msg_type_enabled(struct camera_device *device, int32_t msg_type)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_MSG_TYPE_ENABLED, (void *)&msg_type);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_MSG_TYPE_ENABLED, &apiResult);
ret = apiResult.enabled;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : prepare_preview
*
* DESCRIPTION: prepare preview
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::prepare_preview(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGH("[KPI Perf]: E PROFILE_PREPARE_PREVIEW camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
qcamera_sm_evt_enum_t evt = QCAMERA_SM_EVT_PREPARE_PREVIEW;
ret = hw->processAPI(evt, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(evt, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGH("[KPI Perf]: X");
return ret;
}
/*===========================================================================
* FUNCTION : start_preview
*
* DESCRIPTION: start preview
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::start_preview(struct camera_device *device)
{
KPI_ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("[KPI Perf]: E PROFILE_START_PREVIEW camera id %d",
hw->getCameraId());
// Release the timed perf lock acquired in openCamera
hw->m_perfLock.lock_rel_timed();
hw->m_perfLock.lock_acq();
hw->lockAPI();
qcamera_api_result_t apiResult;
qcamera_sm_evt_enum_t evt = QCAMERA_SM_EVT_START_PREVIEW;
if (hw->isNoDisplayMode()) {
evt = QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW;
}
ret = hw->processAPI(evt, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(evt, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
hw->m_bPreviewStarted = true;
LOGI("[KPI Perf]: X ret = %d", ret);
return ret;
}
/*===========================================================================
* FUNCTION : stop_preview
*
* DESCRIPTION: stop preview
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::stop_preview(struct camera_device *device)
{
KPI_ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGI("[KPI Perf]: E PROFILE_STOP_PREVIEW camera id %d",
hw->getCameraId());
// Disable power Hint for preview
hw->m_perfLock.powerHint(POWER_HINT_CAM_PREVIEW, false);
hw->m_perfLock.lock_acq();
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t ret = hw->processAPI(QCAMERA_SM_EVT_STOP_PREVIEW, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_STOP_PREVIEW, &apiResult);
}
hw->unlockAPI();
LOGI("[KPI Perf]: X ret = %d", ret);
}
/*===========================================================================
* FUNCTION : preview_enabled
*
* DESCRIPTION: if preview is running
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : 1 -- running
* 0 -- not running
*==========================================================================*/
int QCamera2HardwareInterface::preview_enabled(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_PREVIEW_ENABLED, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_PREVIEW_ENABLED, &apiResult);
ret = apiResult.enabled;
}
//if preview enabled, can enable preview callback send
if(apiResult.enabled) {
hw->m_stateMachine.setPreviewCallbackNeeded(true);
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : store_meta_data_in_buffers
*
* DESCRIPTION: if need to store meta data in buffers for video frame
*
* PARAMETERS :
* @device : ptr to camera device struct
* @enable : flag if enable
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::store_meta_data_in_buffers(
struct camera_device *device, int enable)
{
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS, (void *)&enable);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : restart_start_preview
*
* DESCRIPTION: start preview as part of the restart preview
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::restart_start_preview(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
ret = hw->processAPI(QCAMERA_SM_EVT_RESTART_START_PREVIEW, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_RESTART_START_PREVIEW, &apiResult);
ret = apiResult.status;
}
} else {
LOGE("This function is not supposed to be called in single-camera mode");
ret = INVALID_OPERATION;
}
// Preview restart done, update the mPreviewRestartNeeded flag to false.
hw->mPreviewRestartNeeded = false;
hw->unlockAPI();
LOGI("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : restart_stop_preview
*
* DESCRIPTION: stop preview as part of the restart preview
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::restart_stop_preview(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
ret = hw->processAPI(QCAMERA_SM_EVT_RESTART_STOP_PREVIEW, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_RESTART_STOP_PREVIEW, &apiResult);
ret = apiResult.status;
}
} else {
LOGE("This function is not supposed to be called in single-camera mode");
ret = INVALID_OPERATION;
}
hw->unlockAPI();
LOGI("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : pre_start_recording
*
* DESCRIPTION: prepare for the start recording
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::pre_start_recording(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGH("[KPI Perf]: E PROFILE_PRE_START_RECORDING camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_PRE_START_RECORDING, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_PRE_START_RECORDING, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGH("[KPI Perf]: X");
return ret;
}
/*===========================================================================
* FUNCTION : start_recording
*
* DESCRIPTION: start recording
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::start_recording(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("[KPI Perf]: E PROFILE_START_RECORDING camera id %d",
hw->getCameraId());
// Give HWI control to call pre_start_recording in single camera mode.
// In dual-cam mode, this control belongs to muxer.
if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
ret = pre_start_recording(device);
if (ret != NO_ERROR) {
LOGE("pre_start_recording failed with ret = %d", ret);
return ret;
}
}
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_START_RECORDING, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_START_RECORDING, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
hw->m_bRecordStarted = true;
LOGI("[KPI Perf]: X ret = %d", ret);
if (ret == NO_ERROR) {
// Set power Hint for video encoding
hw->m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, true);
}
return ret;
}
/*===========================================================================
* FUNCTION : stop_recording
*
* DESCRIPTION: stop recording
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::stop_recording(struct camera_device *device)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGI("[KPI Perf]: E PROFILE_STOP_RECORDING camera id %d",
hw->getCameraId());
// Disable power hint for video encoding
hw->m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, false);
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t ret = hw->processAPI(QCAMERA_SM_EVT_STOP_RECORDING, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_STOP_RECORDING, &apiResult);
}
hw->unlockAPI();
LOGI("[KPI Perf]: X ret = %d", ret);
}
/*===========================================================================
* FUNCTION : recording_enabled
*
* DESCRIPTION: if recording is running
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : 1 -- running
* 0 -- not running
*==========================================================================*/
int QCamera2HardwareInterface::recording_enabled(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_RECORDING_ENABLED, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_RECORDING_ENABLED, &apiResult);
ret = apiResult.enabled;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : release_recording_frame
*
* DESCRIPTION: return recording frame back
*
* PARAMETERS :
* @device : ptr to camera device struct
* @opaque : ptr to frame to be returned
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::release_recording_frame(
struct camera_device *device, const void *opaque)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
if (!opaque) {
LOGE("Error!! Frame info is NULL");
return;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t ret = hw->processAPI(QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME, (void *)opaque);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME, &apiResult);
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : auto_focus
*
* DESCRIPTION: start auto focus
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::auto_focus(struct camera_device *device)
{
KPI_ATRACE_INT("Camera:AutoFocus", 1);
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGH("[KPI Perf] : E PROFILE_AUTO_FOCUS camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_START_AUTO_FOCUS, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_START_AUTO_FOCUS, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGH("[KPI Perf] : X ret = %d", ret);
return ret;
}
/*===========================================================================
* FUNCTION : cancel_auto_focus
*
* DESCRIPTION: cancel auto focus
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::cancel_auto_focus(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGH("[KPI Perf] : E PROFILE_CANCEL_AUTO_FOCUS camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_STOP_AUTO_FOCUS, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_STOP_AUTO_FOCUS, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGH("[KPI Perf] : X ret = %d", ret);
return ret;
}
/*===========================================================================
* FUNCTION : pre_take_picture
*
* DESCRIPTION: pre take picture, restart preview if necessary.
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::pre_take_picture(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGH("[KPI Perf]: E PROFILE_PRE_TAKE_PICTURE camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_PRE_TAKE_PICTURE, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_PRE_TAKE_PICTURE, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGH("[KPI Perf]: X");
return ret;
}
/*===========================================================================
* FUNCTION : take_picture
*
* DESCRIPTION: take picture
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::take_picture(struct camera_device *device)
{
KPI_ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("[KPI Perf]: E PROFILE_TAKE_PICTURE camera id %d",
hw->getCameraId());
if (!hw->mLongshotEnabled) {
hw->m_perfLock.lock_acq();
}
qcamera_api_result_t apiResult;
/** Added support for Retro-active Frames:
* takePicture() is called before preparing Snapshot to indicate the
* mm-camera-channel to pick up legacy frames even
* before LED estimation is triggered.
*/
LOGH("isLiveSnap %d, isZSL %d, isHDR %d longshot = %d",
hw->isLiveSnapshot(), hw->isZSLMode(), hw->isHDRMode(),
hw->isLongshotEnabled());
// Check for Retro-active Frames
if ((hw->mParameters.getNumOfRetroSnapshots() > 0) &&
!hw->isLiveSnapshot() && hw->isZSLMode() &&
!hw->isHDRMode() && !hw->isLongshotEnabled()) {
// Set Retro Picture Mode
hw->setRetroPicture(1);
hw->m_bLedAfAecLock = 0;
LOGL("Retro Enabled");
// Give HWI control to call pre_take_picture in single camera mode.
// In dual-cam mode, this control belongs to muxer.
if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
ret = pre_take_picture(device);
if (ret != NO_ERROR) {
LOGE("pre_take_picture failed with ret = %d",ret);
return ret;
}
}
/* Call take Picture for total number of snapshots required.
This includes the number of retro frames and normal frames */
hw->lockAPI();
ret = hw->processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
if (ret == NO_ERROR) {
// Wait for retro frames, before calling prepare snapshot
LOGD("Wait for Retro frames to be done");
hw->waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
ret = apiResult.status;
}
/* Unlock API since it is acquired in prepare snapshot seperately */
hw->unlockAPI();
/* Prepare snapshot in case LED needs to be flashed */
LOGD("Start Prepare Snapshot");
ret = hw->prepare_snapshot(device);
}
else {
hw->setRetroPicture(0);
// Check if prepare snapshot is done
if (!hw->mPrepSnapRun) {
// Ignore the status from prepare_snapshot
hw->prepare_snapshot(device);
}
// Give HWI control to call pre_take_picture in single camera mode.
// In dual-cam mode, this control belongs to muxer.
if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
ret = pre_take_picture(device);
if (ret != NO_ERROR) {
LOGE("pre_take_picture failed with ret = %d",ret);
return ret;
}
}
// Regardless what the result value for prepare_snapshot,
// go ahead with capture anyway. Just like the way autofocus
// is handled in capture case
/* capture */
LOGL("Capturing normal frames");
hw->lockAPI();
ret = hw->processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
if (!hw->isLongshotEnabled()){
// For longshot mode, we prepare snapshot only once
hw->mPrepSnapRun = false;
}
}
LOGI("[KPI Perf]: X ret = %d", ret);
return ret;
}
/*===========================================================================
* FUNCTION : cancel_picture
*
* DESCRIPTION: cancel current take picture request
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::cancel_picture(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("[KPI Perf]: E PROFILE_CANCEL_PICTURE camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_CANCEL_PICTURE, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_CANCEL_PICTURE, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGI("[KPI Perf]: X camera id %d ret = %d", hw->getCameraId(), ret);
return ret;
}
/*===========================================================================
* FUNCTION : set_parameters
*
* DESCRIPTION: set camera parameters
*
* PARAMETERS :
* @device : ptr to camera device struct
* @parms : string of packed parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::set_parameters(struct camera_device *device,
const char *parms)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS, (void *)parms);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS, &apiResult);
ret = apiResult.status;
}
// Give HWI control to restart (if necessary) after set params
// in single camera mode. In dual-cam mode, this control belongs to muxer.
if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
if ((ret == NO_ERROR) && hw->getNeedRestart()) {
LOGD("stopping after param change");
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_STOP, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_STOP, &apiResult);
ret = apiResult.status;
}
}
if (ret == NO_ERROR) {
LOGD("committing param change");
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, &apiResult);
ret = apiResult.status;
}
}
if ((ret == NO_ERROR) && hw->getNeedRestart()) {
LOGD("restarting after param change");
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_RESTART, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_RESTART, &apiResult);
ret = apiResult.status;
}
}
}
hw->unlockAPI();
LOGD("X camera id %d ret %d", hw->getCameraId(), ret);
return ret;
}
/*===========================================================================
* FUNCTION : stop_after_set_params
*
* DESCRIPTION: stop after a set param call, if necessary
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::stop_after_set_params(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_STOP, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_STOP, &apiResult);
ret = apiResult.status;
}
} else {
LOGE("is not supposed to be called in single-camera mode");
ret = INVALID_OPERATION;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : commit_params
*
* DESCRIPTION: commit after a set param call
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::commit_params(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, &apiResult);
ret = apiResult.status;
}
} else {
LOGE("is not supposed to be called in single-camera mode");
ret = INVALID_OPERATION;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : restart_after_set_params
*
* DESCRIPTION: restart after a set param call, if necessary
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::restart_after_set_params(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_RESTART, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_RESTART, &apiResult);
ret = apiResult.status;
}
} else {
LOGE("is not supposed to be called in single-camera mode");
ret = INVALID_OPERATION;
}
hw->unlockAPI();
LOGD("X camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : get_parameters
*
* DESCRIPTION: query camera parameters
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : packed parameters in a string
*==========================================================================*/
char* QCamera2HardwareInterface::get_parameters(struct camera_device *device)
{
ATRACE_CALL();
char *ret = NULL;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return NULL;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t rc = hw->processAPI(QCAMERA_SM_EVT_GET_PARAMS, NULL);
if (rc == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_GET_PARAMS, &apiResult);
ret = apiResult.params;
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : put_parameters
*
* DESCRIPTION: return camera parameters string back to HAL
*
* PARAMETERS :
* @device : ptr to camera device struct
* @parm : ptr to parameter string to be returned
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::put_parameters(struct camera_device *device,
char *parm)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t ret = hw->processAPI(QCAMERA_SM_EVT_PUT_PARAMS, (void *)parm);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_PUT_PARAMS, &apiResult);
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : send_command
*
* DESCRIPTION: command to be executed
*
* PARAMETERS :
* @device : ptr to camera device struct
* @cmd : cmd to be executed
* @arg1 : ptr to optional argument1
* @arg2 : ptr to optional argument2
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::send_command(struct camera_device *device,
int32_t cmd,
int32_t arg1,
int32_t arg2)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
qcamera_sm_evt_command_payload_t payload;
memset(&payload, 0, sizeof(qcamera_sm_evt_command_payload_t));
payload.cmd = cmd;
payload.arg1 = arg1;
payload.arg2 = arg2;
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_SEND_COMMAND, (void *)&payload);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SEND_COMMAND, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : send_command_restart
*
* DESCRIPTION: restart if necessary after a send_command
*
* PARAMETERS :
* @device : ptr to camera device struct
* @cmd : cmd to be executed
* @arg1 : ptr to optional argument1
* @arg2 : ptr to optional argument2
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::send_command_restart(struct camera_device *device,
int32_t cmd,
int32_t arg1,
int32_t arg2)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
qcamera_sm_evt_command_payload_t payload;
memset(&payload, 0, sizeof(qcamera_sm_evt_command_payload_t));
payload.cmd = cmd;
payload.arg1 = arg1;
payload.arg2 = arg2;
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_SEND_COMMAND_RESTART, (void *)&payload);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_SEND_COMMAND_RESTART, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : release
*
* DESCRIPTION: release camera resource
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::release(struct camera_device *device)
{
ATRACE_CALL();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
int32_t ret = hw->processAPI(QCAMERA_SM_EVT_RELEASE, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_RELEASE, &apiResult);
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
}
/*===========================================================================
* FUNCTION : dump
*
* DESCRIPTION: dump camera status
*
* PARAMETERS :
* @device : ptr to camera device struct
* @fd : fd for status to be dumped to
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::dump(struct camera_device *device, int fd)
{
int ret = NO_ERROR;
//Log level property is read when "adb shell dumpsys media.camera" is
//called so that the log level can be controlled without restarting
//media server
getLogLevel();
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_DUMP, (void *)&fd);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_DUMP, &apiResult);
ret = apiResult.status;
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : close_camera_device
*
* DESCRIPTION: close camera device
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::close_camera_device(hw_device_t *hw_dev)
{
KPI_ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(
reinterpret_cast<camera_device_t *>(hw_dev)->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGI("[KPI Perf]: E camera id %d", hw->getCameraId());
delete hw;
LOGI("[KPI Perf]: X");
return ret;
}
/*===========================================================================
* FUNCTION : register_face_image
*
* DESCRIPTION: register a face image into imaging lib for face authenticatio/
* face recognition
*
* PARAMETERS :
* @device : ptr to camera device struct
* @img_ptr : ptr to image buffer
* @config : ptr to config about input image, i.e., format, dimension, and etc.
*
* RETURN : >=0 unique ID of face registerd.
* <0 failure.
*==========================================================================*/
int QCamera2HardwareInterface::register_face_image(struct camera_device *device,
void *img_ptr,
cam_pp_offline_src_config_t *config)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
LOGD("E camera id %d", hw->getCameraId());
qcamera_sm_evt_reg_face_payload_t payload;
memset(&payload, 0, sizeof(qcamera_sm_evt_reg_face_payload_t));
payload.img_ptr = img_ptr;
payload.config = config;
hw->lockAPI();
qcamera_api_result_t apiResult;
ret = hw->processAPI(QCAMERA_SM_EVT_REG_FACE_IMAGE, (void *)&payload);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_REG_FACE_IMAGE, &apiResult);
ret = apiResult.handle;
}
hw->unlockAPI();
LOGD("E camera id %d", hw->getCameraId());
return ret;
}
/*===========================================================================
* FUNCTION : prepare_snapshot
*
* DESCRIPTION: prepares hardware for snapshot
*
* PARAMETERS :
* @device : ptr to camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::prepare_snapshot(struct camera_device *device)
{
ATRACE_CALL();
int ret = NO_ERROR;
QCamera2HardwareInterface *hw =
reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
if (!hw) {
LOGE("NULL camera device");
return BAD_VALUE;
}
if (hw->isLongshotEnabled() && hw->mPrepSnapRun == true) {
// For longshot mode, we prepare snapshot only once
LOGH("prepare snapshot only once ");
return NO_ERROR;
}
LOGH("[KPI Perf]: E PROFILE_PREPARE_SNAPSHOT camera id %d",
hw->getCameraId());
hw->lockAPI();
qcamera_api_result_t apiResult;
/* Prepare snapshot in case LED needs to be flashed */
if (hw->mFlashNeeded || hw->mParameters.isChromaFlashEnabled()) {
/* Prepare snapshot in case LED needs to be flashed */
ret = hw->processAPI(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, NULL);
if (ret == NO_ERROR) {
hw->waitAPIResult(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, &apiResult);
ret = apiResult.status;
}
hw->mPrepSnapRun = true;
}
hw->unlockAPI();
LOGH("[KPI Perf]: X, ret: %d", ret);
return ret;
}
/*===========================================================================
* FUNCTION : QCamera2HardwareInterface
*
* DESCRIPTION: constructor of QCamera2HardwareInterface
*
* PARAMETERS :
* @cameraId : camera ID
*
* RETURN : none
*==========================================================================*/
QCamera2HardwareInterface::QCamera2HardwareInterface(uint32_t cameraId)
: mCameraId(cameraId),
mCameraHandle(NULL),
mCameraOpened(false),
m_bRelCamCalibValid(false),
mPreviewWindow(NULL),
mMsgEnabled(0),
mStoreMetaDataInFrame(0),
mJpegCb(NULL),
mCallbackCookie(NULL),
mJpegCallbackCookie(NULL),
m_bMpoEnabled(TRUE),
m_stateMachine(this),
m_smThreadActive(true),
m_postprocessor(this),
m_thermalAdapter(QCameraThermalAdapter::getInstance()),
m_cbNotifier(this),
m_bPreviewStarted(false),
m_bRecordStarted(false),
m_currentFocusState(CAM_AF_STATE_INACTIVE),
mDumpFrmCnt(0U),
mDumpSkipCnt(0U),
mThermalLevel(QCAMERA_THERMAL_NO_ADJUSTMENT),
mActiveAF(false),
m_HDRSceneEnabled(false),
mLongshotEnabled(false),
mLiveSnapshotThread(0),
mIntPicThread(0),
mFlashNeeded(false),
mDeviceRotation(0U),
mCaptureRotation(0U),
mJpegExifRotation(0U),
mUseJpegExifRotation(false),
mIs3ALocked(false),
mPrepSnapRun(false),
mZoomLevel(0),
mPreviewRestartNeeded(false),
mVFrameCount(0),
mVLastFrameCount(0),
mVLastFpsTime(0),
mVFps(0),
mPFrameCount(0),
mPLastFrameCount(0),
mPLastFpsTime(0),
mPFps(0),
m_bIntJpegEvtPending(false),
m_bIntRawEvtPending(false),
mReprocJob(0),
mJpegJob(0),
mMetadataAllocJob(0),
mInitPProcJob(0),
mParamAllocJob(0),
mParamInitJob(0),
mOutputCount(0),
mInputCount(0),
mAdvancedCaptureConfigured(false),
mHDRBracketingEnabled(false),
mNumPreviewFaces(-1),
mJpegClientHandle(0),
mJpegHandleOwner(false),
mMetadataMem(NULL),
mCACDoneReceived(false),
m_bNeedRestart(false),
mIgnoredPreviewCount(0)
{
#ifdef TARGET_TS_MAKEUP
memset(&mFaceRect, -1, sizeof(mFaceRect));
#endif
getLogLevel();
ATRACE_CALL();
mCameraDevice.common.tag = HARDWARE_DEVICE_TAG;
mCameraDevice.common.version = HARDWARE_DEVICE_API_VERSION(1, 0);
mCameraDevice.common.close = close_camera_device;
mCameraDevice.ops = &mCameraOps;
mCameraDevice.priv = this;
pthread_mutex_init(&m_lock, NULL);
pthread_cond_init(&m_cond, NULL);
m_apiResultList = NULL;
pthread_mutex_init(&m_evtLock, NULL);
pthread_cond_init(&m_evtCond, NULL);
memset(&m_evtResult, 0, sizeof(qcamera_api_result_t));
pthread_mutex_init(&m_int_lock, NULL);
pthread_cond_init(&m_int_cond, NULL);
memset(m_channels, 0, sizeof(m_channels));
memset(&mExifParams, 0, sizeof(mm_jpeg_exif_params_t));
memset(m_BackendFileName, 0, QCAMERA_MAX_FILEPATH_LENGTH);
memset(mDefOngoingJobs, 0, sizeof(mDefOngoingJobs));
memset(&mJpegMetadata, 0, sizeof(mJpegMetadata));
memset(&mJpegHandle, 0, sizeof(mJpegHandle));
memset(&mJpegMpoHandle, 0, sizeof(mJpegMpoHandle));
mDeferredWorkThread.launch(deferredWorkRoutine, this);
mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
m_perfLock.lock_init();
pthread_mutex_init(&mGrallocLock, NULL);
mEnqueuedBuffers = 0;
//Load and read GPU library.
lib_surface_utils = NULL;
LINK_get_surface_pixel_alignment = NULL;
mSurfaceStridePadding = CAM_PAD_TO_32;
lib_surface_utils = dlopen("libadreno_utils.so", RTLD_NOW);
if (lib_surface_utils) {
*(void **)&LINK_get_surface_pixel_alignment =
dlsym(lib_surface_utils, "get_gpu_pixel_alignment");
if (LINK_get_surface_pixel_alignment) {
mSurfaceStridePadding = LINK_get_surface_pixel_alignment();
}
dlclose(lib_surface_utils);
}
}
/*===========================================================================
* FUNCTION : ~QCamera2HardwareInterface
*
* DESCRIPTION: destructor of QCamera2HardwareInterface
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
QCamera2HardwareInterface::~QCamera2HardwareInterface()
{
LOGH("E");
mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
mDeferredWorkThread.exit();
if (mMetadataMem != NULL) {
delete mMetadataMem;
mMetadataMem = NULL;
}
m_perfLock.lock_acq();
lockAPI();
m_smThreadActive = false;
unlockAPI();
m_stateMachine.releaseThread();
closeCamera();
m_perfLock.lock_rel();
m_perfLock.lock_deinit();
pthread_mutex_destroy(&m_lock);
pthread_cond_destroy(&m_cond);
pthread_mutex_destroy(&m_evtLock);
pthread_cond_destroy(&m_evtCond);
pthread_mutex_destroy(&m_int_lock);
pthread_cond_destroy(&m_int_cond);
pthread_mutex_destroy(&mGrallocLock);
LOGH("X");
}
/*===========================================================================
* FUNCTION : deferPPInit
*
* DESCRIPTION: Queue postproc init task to deferred thread
*
* PARAMETERS : none
*
* RETURN : uint32_t job id of pproc init job
* 0 -- failure
*==========================================================================*/
uint32_t QCamera2HardwareInterface::deferPPInit()
{
// init pproc
DeferWorkArgs args;
DeferPProcInitArgs pprocInitArgs;
memset(&args, 0, sizeof(DeferWorkArgs));
memset(&pprocInitArgs, 0, sizeof(DeferPProcInitArgs));
pprocInitArgs.jpeg_cb = jpegEvtHandle;
pprocInitArgs.user_data = this;
args.pprocInitArgs = pprocInitArgs;
return queueDeferredWork(CMD_DEF_PPROC_INIT,
args);
}
/*===========================================================================
* FUNCTION : openCamera
*
* DESCRIPTION: open camera
*
* PARAMETERS :
* @hw_device : double ptr for camera device struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::openCamera(struct hw_device_t **hw_device)
{
KPI_ATRACE_CALL();
int rc = NO_ERROR;
if (mCameraOpened) {
*hw_device = NULL;
LOGE("Permission Denied");
return PERMISSION_DENIED;
}
LOGI("[KPI Perf]: E PROFILE_OPEN_CAMERA camera id %d",
mCameraId);
m_perfLock.lock_acq_timed(CAMERA_OPEN_PERF_TIME_OUT);
rc = openCamera();
if (rc == NO_ERROR){
*hw_device = &mCameraDevice.common;
if (m_thermalAdapter.init(this) != 0) {
LOGW("Init thermal adapter failed");
}
}
else
*hw_device = NULL;
LOGI("[KPI Perf]: X PROFILE_OPEN_CAMERA camera id %d, rc: %d",
mCameraId, rc);
return rc;
}
/*===========================================================================
* FUNCTION : openCamera
*
* DESCRIPTION: open camera
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::openCamera()
{
size_t i;
int32_t rc = NO_ERROR;
char value[PROPERTY_VALUE_MAX];
if (mCameraHandle) {
LOGE("Failure: Camera already opened");
return ALREADY_EXISTS;
}
rc = QCameraFlash::getInstance().reserveFlashForCamera(mCameraId);
if (rc < 0) {
LOGE("Failed to reserve flash for camera id: %d",
mCameraId);
return UNKNOWN_ERROR;
}
// alloc param buffer
DeferWorkArgs args;
memset(&args, 0, sizeof(args));
mParamAllocJob = queueDeferredWork(CMD_DEF_PARAM_ALLOC, args);
if (mParamAllocJob == 0) {
LOGE("Failed queueing PARAM_ALLOC job");
return -ENOMEM;
}
if (gCamCapability[mCameraId] != NULL) {
// allocate metadata buffers
DeferWorkArgs args;
DeferMetadataAllocArgs metadataAllocArgs;
memset(&args, 0, sizeof(args));
memset(&metadataAllocArgs, 0, sizeof(metadataAllocArgs));
uint32_t padding =
gCamCapability[mCameraId]->padding_info.plane_padding;
metadataAllocArgs.size = PAD_TO_SIZE(sizeof(metadata_buffer_t),
padding);
metadataAllocArgs.bufferCnt = CAMERA_MIN_METADATA_BUFFERS;
args.metadataAllocArgs = metadataAllocArgs;
mMetadataAllocJob = queueDeferredWork(CMD_DEF_METADATA_ALLOC, args);
if (mMetadataAllocJob == 0) {
LOGE("Failed to allocate metadata buffer");
rc = -ENOMEM;
goto error_exit1;
}
rc = camera_open((uint8_t)mCameraId, &mCameraHandle);
if (rc) {
LOGE("camera_open failed. rc = %d, mCameraHandle = %p",
rc, mCameraHandle);
goto error_exit2;
}
mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
camEvtHandle,
(void *) this);
} else {
LOGH("Capabilities not inited, initializing now.");
rc = camera_open((uint8_t)mCameraId, &mCameraHandle);
if (rc) {
LOGE("camera_open failed. rc = %d, mCameraHandle = %p",
rc, mCameraHandle);
goto error_exit2;
}
if(NO_ERROR != initCapabilities(mCameraId,mCameraHandle)) {
LOGE("initCapabilities failed.");
rc = UNKNOWN_ERROR;
goto error_exit3;
}
mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
camEvtHandle,
(void *) this);
}
// Init params in the background
// 1. It's safe to queue init job, even if alloc job is not yet complete.
// It will be queued to the same thread, so the alloc is guaranteed to
// finish first.
// 2. However, it is not safe to begin param init until after camera is
// open. That is why we wait until after camera open completes to schedule
// this task.
memset(&args, 0, sizeof(args));
mParamInitJob = queueDeferredWork(CMD_DEF_PARAM_INIT, args);
if (mParamInitJob == 0) {
LOGE("Failed queuing PARAM_INIT job");
rc = -ENOMEM;
goto error_exit3;
}
mCameraOpened = true;
//Notify display HAL that a camera session is active.
//But avoid calling the same during bootup because camera service might open/close
//cameras at boot time during its initialization and display service will also internally
//wait for camera service to initialize first while calling this display API, resulting in a
//deadlock situation. Since boot time camera open/close calls are made only to fetch
//capabilities, no need of this display bw optimization.
//Use "service.bootanim.exit" property to know boot status.
property_get("service.bootanim.exit", value, "0");
if (atoi(value) == 1) {
pthread_mutex_lock(&gCamLock);
if (gNumCameraSessions++ == 0) {
setCameraLaunchStatus(true);
}
pthread_mutex_unlock(&gCamLock);
}
return NO_ERROR;
error_exit3:
if(mJpegClientHandle) {
deinitJpegHandle();
}
mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
mCameraHandle = NULL;
error_exit2:
waitDeferredWork(mMetadataAllocJob);
error_exit1:
waitDeferredWork(mParamAllocJob);
return rc;
}
/*===========================================================================
* FUNCTION : bundleRelatedCameras
*
* DESCRIPTION: bundle cameras to enable syncing of cameras
*
* PARAMETERS :
* @sync :indicates whether syncing is On or Off
* @sessionid :session id for other camera session
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::bundleRelatedCameras(bool syncOn,
uint32_t sessionid)
{
LOGD("bundleRelatedCameras sync %d with sessionid %d",
syncOn, sessionid);
int32_t rc = mParameters.bundleRelatedCameras(syncOn, sessionid);
if (rc != NO_ERROR) {
LOGE("bundleRelatedCameras failed %d", rc);
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : getCameraSessionId
*
* DESCRIPTION: gets the backend session Id of this HWI instance
*
* PARAMETERS :
* @sessionid : pointer to the output session id
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::getCameraSessionId(uint32_t* session_id)
{
int32_t rc = NO_ERROR;
if(session_id != NULL) {
rc = mCameraHandle->ops->get_session_id(mCameraHandle->camera_handle,
session_id);
LOGD("Getting Camera Session Id %d", *session_id);
} else {
LOGE("Session Id is Null");
return UNKNOWN_ERROR;
}
return rc;
}
/*===========================================================================
* FUNCTION : getRelatedCamSyncInfo
*
* DESCRIPTION:returns the related cam sync info for this HWI instance
*
* PARAMETERS :none
*
* RETURN : const pointer to cam_sync_related_sensors_event_info_t
*==========================================================================*/
const cam_sync_related_sensors_event_info_t*
QCamera2HardwareInterface::getRelatedCamSyncInfo(void)
{
return mParameters.getRelatedCamSyncInfo();
}
/*===========================================================================
* FUNCTION : setRelatedCamSyncInfo
*
* DESCRIPTION:sets the related cam sync info for this HWI instance
*
* PARAMETERS :
* @info : ptr to related cam info parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setRelatedCamSyncInfo(
cam_sync_related_sensors_event_info_t* info)
{
if(info) {
return mParameters.setRelatedCamSyncInfo(info);
} else {
return BAD_TYPE;
}
}
/*===========================================================================
* FUNCTION : getMpoComposition
*
* DESCRIPTION:function to retrieve whether Mpo composition should be enabled
* or not
*
* PARAMETERS :none
*
* RETURN : bool indicates whether mpo composition is enabled or not
*==========================================================================*/
bool QCamera2HardwareInterface::getMpoComposition(void)
{
LOGH("MpoComposition:%d ", m_bMpoEnabled);
return m_bMpoEnabled;
}
/*===========================================================================
* FUNCTION : setMpoComposition
*
* DESCRIPTION:set if Mpo composition should be enabled for this HWI instance
*
* PARAMETERS :
* @enable : indicates whether Mpo composition enabled or not
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setMpoComposition(bool enable)
{
// By default set Mpo composition to disable
m_bMpoEnabled = false;
// Enable Mpo composition only if
// 1) frame sync is ON between two cameras and
// 2) any advanced features are not enabled (AOST features) and
// 3) not in recording mode (for liveshot case)
// 4) flash is not needed
if ((getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) &&
!mParameters.isAdvCamFeaturesEnabled() &&
!mParameters.getRecordingHintValue() &&
!mFlashNeeded &&
!isLongshotEnabled()) {
m_bMpoEnabled = enable;
LOGH("MpoComposition:%d ", m_bMpoEnabled);
return NO_ERROR;
} else {
return BAD_TYPE;
}
}
/*===========================================================================
* FUNCTION : getRecordingHintValue
*
* DESCRIPTION:function to retrieve recording hint value
*
* PARAMETERS :none
*
* RETURN : bool indicates whether recording hint is enabled or not
*==========================================================================*/
bool QCamera2HardwareInterface::getRecordingHintValue(void)
{
return mParameters.getRecordingHintValue();
}
/*===========================================================================
* FUNCTION : setRecordingHintValue
*
* DESCRIPTION:set recording hint value
*
* PARAMETERS :
* @enable : video hint value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setRecordingHintValue(int32_t value)
{
return mParameters.updateRecordingHintValue(value);
}
/*===========================================================================
* FUNCTION : closeCamera
*
* DESCRIPTION: close camera
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::closeCamera()
{
int rc = NO_ERROR;
int i;
char value[PROPERTY_VALUE_MAX];
LOGI("E");
if (!mCameraOpened) {
return NO_ERROR;
}
LOGI("[KPI Perf]: E PROFILE_CLOSE_CAMERA camera id %d",
mCameraId);
// set open flag to false
mCameraOpened = false;
// Reset Stream config info
mParameters.setStreamConfigure(false, false, true);
// deinit Parameters
mParameters.deinit();
// exit notifier
m_cbNotifier.exit();
// stop and deinit postprocessor
waitDeferredWork(mReprocJob);
// Close the JPEG session
waitDeferredWork(mJpegJob);
m_postprocessor.stop();
deinitJpegHandle();
m_postprocessor.deinit();
mInitPProcJob = 0; // reset job id, so pproc can be reinited later
m_thermalAdapter.deinit();
// delete all channels if not already deleted
for (i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
if (m_channels[i] != NULL) {
m_channels[i]->stop();
delete m_channels[i];
m_channels[i] = NULL;
}
}
//free all pending api results here
if(m_apiResultList != NULL) {
api_result_list *apiResultList = m_apiResultList;
api_result_list *apiResultListNext;
while (apiResultList != NULL) {
apiResultListNext = apiResultList->next;
free(apiResultList);
apiResultList = apiResultListNext;
}
}
rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
mCameraHandle = NULL;
//Notify display HAL that there is no active camera session
//but avoid calling the same during bootup. Refer to openCamera
//for more details.
property_get("service.bootanim.exit", value, "0");
if (atoi(value) == 1) {
pthread_mutex_lock(&gCamLock);
if (--gNumCameraSessions == 0) {
setCameraLaunchStatus(false);
}
pthread_mutex_unlock(&gCamLock);
}
if (mExifParams.debug_params) {
free(mExifParams.debug_params);
mExifParams.debug_params = NULL;
}
if (QCameraFlash::getInstance().releaseFlashFromCamera(mCameraId) != 0) {
LOGD("Failed to release flash for camera id: %d",
mCameraId);
}
LOGI("[KPI Perf]: X PROFILE_CLOSE_CAMERA camera id %d, rc: %d",
mCameraId, rc);
return rc;
}
#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
/*===========================================================================
* FUNCTION : initCapabilities
*
* DESCRIPTION: initialize camera capabilities in static data struct
*
* PARAMETERS :
* @cameraId : camera Id
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::initCapabilities(uint32_t cameraId,
mm_camera_vtbl_t *cameraHandle)
{
ATRACE_CALL();
int rc = NO_ERROR;
QCameraHeapMemory *capabilityHeap = NULL;
/* Allocate memory for capability buffer */
capabilityHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), NON_SECURE);
if(rc != OK) {
LOGE("No memory for cappability");
goto allocate_failed;
}
/* Map memory for capability buffer */
memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t));
cam_buf_map_type_list bufMapList;
rc = QCameraBufferMaps::makeSingletonBufMapList(
CAM_MAPPING_BUF_TYPE_CAPABILITY,
0 /*stream id*/, 0 /*buffer index*/, -1 /*plane index*/,
0 /*cookie*/, capabilityHeap->getFd(0), sizeof(cam_capability_t),
bufMapList);
if (rc == NO_ERROR) {
rc = cameraHandle->ops->map_bufs(cameraHandle->camera_handle,
&bufMapList);
}
if(rc < 0) {
LOGE("failed to map capability buffer");
goto map_failed;
}
/* Query Capability */
rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle);
if(rc < 0) {
LOGE("failed to query capability");
goto query_failed;
}
gCamCapability[cameraId] =
(cam_capability_t *)malloc(sizeof(cam_capability_t));
if (!gCamCapability[cameraId]) {
LOGE("out of memory");
goto query_failed;
}
memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0),
sizeof(cam_capability_t));
gCamCapability[cameraId]->analysis_padding_info.offset_info.offset_x = 0;
gCamCapability[cameraId]->analysis_padding_info.offset_info.offset_y = 0;
rc = NO_ERROR;
query_failed:
cameraHandle->ops->unmap_buf(cameraHandle->camera_handle,
CAM_MAPPING_BUF_TYPE_CAPABILITY);
map_failed:
capabilityHeap->deallocate();
delete capabilityHeap;
allocate_failed:
return rc;
}
/*===========================================================================
* FUNCTION : getCapabilities
*
* DESCRIPTION: query camera capabilities
*
* PARAMETERS :
* @cameraId : camera Id
* @info : camera info struct to be filled in with camera capabilities
*
* RETURN : int type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::getCapabilities(uint32_t cameraId,
struct camera_info *info, cam_sync_type_t *p_cam_type)
{
ATRACE_CALL();
int rc = NO_ERROR;
struct camera_info *p_info = NULL;
pthread_mutex_lock(&gCamLock);
p_info = get_cam_info(cameraId, p_cam_type);
p_info->device_version = CAMERA_DEVICE_API_VERSION_1_0;
p_info->static_camera_characteristics = NULL;
memcpy(info, p_info, sizeof (struct camera_info));
pthread_mutex_unlock(&gCamLock);
return rc;
}
/*===========================================================================
* FUNCTION : getCamHalCapabilities
*
* DESCRIPTION: get the HAL capabilities structure
*
* PARAMETERS :
* @cameraId : camera Id
*
* RETURN : capability structure of respective camera
*
*==========================================================================*/
cam_capability_t* QCamera2HardwareInterface::getCamHalCapabilities()
{
return gCamCapability[mCameraId];
}
/*===========================================================================
* FUNCTION : getBufNumRequired
*
* DESCRIPTION: return number of stream buffers needed for given stream type
*
* PARAMETERS :
* @stream_type : type of stream
*
* RETURN : number of buffers needed
*==========================================================================*/
uint8_t QCamera2HardwareInterface::getBufNumRequired(cam_stream_type_t stream_type)
{
int bufferCnt = 0;
int minCaptureBuffers = mParameters.getNumOfSnapshots();
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
int persist_cnt = 0;
int zslQBuffers = mParameters.getZSLQueueDepth();
int minCircularBufNum = mParameters.getMaxUnmatchedFramesInQueue() +
CAMERA_MIN_JPEG_ENCODING_BUFFERS;
int maxStreamBuf = minCaptureBuffers + mParameters.getMaxUnmatchedFramesInQueue() +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getNumOfExtraBuffersForImageProc() +
EXTRA_ZSL_PREVIEW_STREAM_BUF;
int minUndequeCount = 0;
if (!isNoDisplayMode()) {
if(mPreviewWindow != NULL) {
if (mPreviewWindow->get_min_undequeued_buffer_count(mPreviewWindow,&minUndequeCount)
!= 0) {
LOGW("get_min_undequeued_buffer_count failed");
//TODO: hardcoded because MIN_UNDEQUEUED_BUFFERS not defined
//minUndequeCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS;
minUndequeCount = MIN_UNDEQUEUED_BUFFERS;
}
} else {
//preview window might not be set at this point. So, query directly
//from BufferQueue implementation of gralloc buffers.
//minUndequeCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS;
//hardcoded because MIN_UNDEQUEUED_BUFFERS not defined. REVISIT
minUndequeCount = MIN_UNDEQUEUED_BUFFERS;
}
if (minUndequeCount != MIN_UNDEQUEUED_BUFFERS) {
// minUndequeCount from valid preview window != hardcoded MIN_UNDEQUEUED_BUFFERS
// and so change the MACRO as per minUndequeCount
LOGW("WARNING : minUndequeCount(%d) != hardcoded value(%d)",
minUndequeCount, MIN_UNDEQUEUED_BUFFERS);
}
}
LOGD("minCaptureBuffers = %d zslQBuffers = %d minCircularBufNum = %d"
"maxStreamBuf = %d minUndequeCount = %d",
minCaptureBuffers, zslQBuffers, minCircularBufNum,
maxStreamBuf, minUndequeCount);
// Get buffer count for the particular stream type
switch (stream_type) {
case CAM_STREAM_TYPE_PREVIEW:
{
if (mParameters.isZSLMode()) {
// We need to add two extra streming buffers to add
// flexibility in forming matched super buf in ZSL queue.
// with number being 'zslQBuffers + minCircularBufNum'
// we see preview buffers sometimes get dropped at CPP
// and super buf is not forming in ZSL Q for long time.
bufferCnt = zslQBuffers + minCircularBufNum +
mParameters.getNumOfExtraBuffersForImageProc() +
mParameters.getNumOfExtraBuffersForPreview() +
mParameters.getNumOfExtraHDRInBufsIfNeeded();
} else {
bufferCnt = CAMERA_MIN_STREAMING_BUFFERS +
mParameters.getMaxUnmatchedFramesInQueue() +
mParameters.getNumOfExtraBuffersForPreview();
}
// ISP allocates native preview buffers and so reducing same from HAL allocation
if (bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS )
bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
// Add the display minUndequeCount count on top of camera requirement
bufferCnt += minUndequeCount;
property_get("persist.camera.preview_yuv", value, "0");
persist_cnt = atoi(value);
if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
&& (bufferCnt < persist_cnt)) {
bufferCnt = persist_cnt;
}
}
break;
case CAM_STREAM_TYPE_POSTVIEW:
{
bufferCnt = minCaptureBuffers +
mParameters.getMaxUnmatchedFramesInQueue() +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getNumOfExtraBuffersForImageProc();
if (bufferCnt > maxStreamBuf) {
bufferCnt = maxStreamBuf;
}
bufferCnt += minUndequeCount;
}
break;
case CAM_STREAM_TYPE_SNAPSHOT:
{
if (mParameters.isZSLMode() || mLongshotEnabled) {
if ((minCaptureBuffers == 1 || mParameters.isUbiRefocus()) &&
!mLongshotEnabled) {
// Single ZSL snapshot case
bufferCnt = zslQBuffers + CAMERA_MIN_STREAMING_BUFFERS +
mParameters.getNumOfExtraBuffersForImageProc();
}
else {
// ZSL Burst or Longshot case
bufferCnt = zslQBuffers + minCircularBufNum +
mParameters.getNumOfExtraBuffersForImageProc();
}
if (getSensorType() == CAM_SENSOR_YUV && bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS) {
//ISP allocates native buffers in YUV case
bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
}
} else {
bufferCnt = minCaptureBuffers +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getNumOfExtraBuffersForImageProc();
if (bufferCnt > maxStreamBuf) {
bufferCnt = maxStreamBuf;
}
}
}
break;
case CAM_STREAM_TYPE_RAW:
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if (isRdiMode() || raw_yuv) {
bufferCnt = zslQBuffers + minCircularBufNum;
} else if (mParameters.isZSLMode()) {
bufferCnt = zslQBuffers + minCircularBufNum;
if (getSensorType() == CAM_SENSOR_YUV && bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS) {
//ISP allocates native buffers in YUV case
bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
}
} else {
bufferCnt = minCaptureBuffers +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getNumOfExtraBuffersForImageProc();
if (bufferCnt > maxStreamBuf) {
bufferCnt = maxStreamBuf;
}
}
property_get("persist.camera.preview_raw", value, "0");
persist_cnt = atoi(value);
if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
&& (bufferCnt < persist_cnt)) {
bufferCnt = persist_cnt;
}
property_get("persist.camera.video_raw", value, "0");
persist_cnt = atoi(value);
if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
&& (bufferCnt < persist_cnt)) {
bufferCnt = persist_cnt;
}
break;
case CAM_STREAM_TYPE_VIDEO:
{
if (mParameters.getBufBatchCount()) {
//Video Buffer in case of HFR or camera batching..
bufferCnt = CAMERA_MIN_CAMERA_BATCH_BUFFERS;
} else if (mParameters.getVideoBatchSize()) {
//Video Buffer count only for HAL to HAL batching.
bufferCnt = (CAMERA_MIN_VIDEO_BATCH_BUFFERS
* mParameters.getVideoBatchSize());
if (bufferCnt < CAMERA_MIN_VIDEO_BUFFERS) {
bufferCnt = CAMERA_MIN_VIDEO_BUFFERS;
}
} else {
// No batching enabled.
bufferCnt = CAMERA_MIN_VIDEO_BUFFERS;
}
bufferCnt += mParameters.getNumOfExtraBuffersForVideo();
//if its 4K encoding usecase, then add extra buffer
cam_dimension_t dim;
mParameters.getStreamDimension(CAM_STREAM_TYPE_VIDEO, dim);
if (is4k2kResolution(&dim)) {
//get additional buffer count
property_get("vidc.enc.dcvs.extra-buff-count", value, "0");
bufferCnt += atoi(value);
}
}
break;
case CAM_STREAM_TYPE_METADATA:
{
if (mParameters.isZSLMode()) {
// MetaData buffers should be >= (Preview buffers-minUndequeCount)
bufferCnt = zslQBuffers + minCircularBufNum +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getNumOfExtraBuffersForImageProc() +
EXTRA_ZSL_PREVIEW_STREAM_BUF;
} else {
bufferCnt = minCaptureBuffers +
mParameters.getNumOfExtraHDRInBufsIfNeeded() -
mParameters.getNumOfExtraHDROutBufsIfNeeded() +
mParameters.getMaxUnmatchedFramesInQueue() +
CAMERA_MIN_STREAMING_BUFFERS +
mParameters.getNumOfExtraBuffersForImageProc();
if (bufferCnt > zslQBuffers + minCircularBufNum) {
bufferCnt = zslQBuffers + minCircularBufNum;
}
}
if (CAMERA_MIN_METADATA_BUFFERS > bufferCnt) {
bufferCnt = CAMERA_MIN_METADATA_BUFFERS;
}
}
break;
case CAM_STREAM_TYPE_OFFLINE_PROC:
{
bufferCnt = minCaptureBuffers;
// One of the ubifocus buffers is miscellaneous buffer
if (mParameters.isUbiRefocus()) {
bufferCnt -= 1;
}
if (mLongshotEnabled) {
bufferCnt = mParameters.getLongshotStages();
}
}
break;
case CAM_STREAM_TYPE_CALLBACK:
bufferCnt = CAMERA_MIN_CALLBACK_BUFFERS;
break;
case CAM_STREAM_TYPE_ANALYSIS:
case CAM_STREAM_TYPE_DEFAULT:
case CAM_STREAM_TYPE_MAX:
default:
bufferCnt = 0;
break;
}
LOGH("Buffer count = %d for stream type = %d", bufferCnt, stream_type);
if (CAM_MAX_NUM_BUFS_PER_STREAM < bufferCnt) {
LOGW("Buffer count %d for stream type %d exceeds limit %d",
bufferCnt, stream_type, CAM_MAX_NUM_BUFS_PER_STREAM);
return CAM_MAX_NUM_BUFS_PER_STREAM;
}
return (uint8_t)bufferCnt;
}
/*===========================================================================
* FUNCTION : allocateStreamBuf
*
* DESCRIPTION: alocate stream buffers
*
* PARAMETERS :
* @stream_type : type of stream
* @size : size of buffer
* @stride : stride of buffer
* @scanline : scanline of buffer
* @bufferCnt : [IN/OUT] minimum num of buffers to be allocated.
* could be modified during allocation if more buffers needed
*
* RETURN : ptr to a memory obj that holds stream buffers.
* NULL if failed
*==========================================================================*/
QCameraMemory *QCamera2HardwareInterface::allocateStreamBuf(
cam_stream_type_t stream_type, size_t size, int stride, int scanline,
uint8_t &bufferCnt)
{
int rc = NO_ERROR;
QCameraMemory *mem = NULL;
bool bCachedMem = QCAMERA_ION_USE_CACHE;
bool bPoolMem = false;
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.mem.usepool", value, "1");
if (atoi(value) == 1) {
bPoolMem = true;
}
// Allocate stream buffer memory object
switch (stream_type) {
case CAM_STREAM_TYPE_PREVIEW:
{
if (isNoDisplayMode()) {
mem = new QCameraStreamMemory(mGetMemory,
bCachedMem,
(bPoolMem) ? &m_memoryPool : NULL,
stream_type);
} else {
cam_dimension_t dim;
int minFPS, maxFPS;
QCameraGrallocMemory *grallocMemory =
new QCameraGrallocMemory(mGetMemory);
mParameters.getStreamDimension(stream_type, dim);
/* we are interested only in maxfps here */
mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
int usage = 0;
if(mParameters.isUBWCEnabled()) {
cam_format_t fmt;
mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW,fmt);
if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
usage = GRALLOC_USAGE_PRIVATE_ALLOC_UBWC ;
}
}
if (grallocMemory) {
grallocMemory->setMappable(
CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS);
grallocMemory->setWindowInfo(mPreviewWindow,
dim.width,dim.height, stride, scanline,
mParameters.getPreviewHalPixelFormat(),
maxFPS, usage);
pthread_mutex_lock(&mGrallocLock);
if (bufferCnt > CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS) {
mEnqueuedBuffers = (bufferCnt -
CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS);
} else {
mEnqueuedBuffers = 0;
}
pthread_mutex_unlock(&mGrallocLock);
}
mem = grallocMemory;
}
}
break;
case CAM_STREAM_TYPE_POSTVIEW:
{
if (isNoDisplayMode() || isPreviewRestartEnabled()) {
mem = new QCameraStreamMemory(mGetMemory, bCachedMem);
} else {
cam_dimension_t dim;
int minFPS, maxFPS;
QCameraGrallocMemory *grallocMemory =
new QCameraGrallocMemory(mGetMemory);
mParameters.getStreamDimension(stream_type, dim);
/* we are interested only in maxfps here */
mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
if (grallocMemory) {
grallocMemory->setWindowInfo(mPreviewWindow, dim.width,
dim.height, stride, scanline,
mParameters.getPreviewHalPixelFormat(), maxFPS);
}
mem = grallocMemory;
}
}
break;
case CAM_STREAM_TYPE_ANALYSIS:
case CAM_STREAM_TYPE_SNAPSHOT:
case CAM_STREAM_TYPE_RAW:
case CAM_STREAM_TYPE_OFFLINE_PROC:
mem = new QCameraStreamMemory(mGetMemory,
bCachedMem,
(bPoolMem) ? &m_memoryPool : NULL,
stream_type);
break;
case CAM_STREAM_TYPE_METADATA:
{
if (mMetadataMem == NULL) {
mem = new QCameraMetadataStreamMemory(QCAMERA_ION_USE_CACHE);
} else {
mem = mMetadataMem;
mMetadataMem = NULL;
int32_t numAdditionalBuffers = bufferCnt - mem->getCnt();
if (numAdditionalBuffers > 0) {
rc = mem->allocateMore(numAdditionalBuffers, size);
if (rc != NO_ERROR) {
LOGE("Failed to allocate additional buffers, "
"but attempting to proceed.");
}
}
bufferCnt = mem->getCnt();
// The memory is already allocated and initialized, so
// simply return here.
return mem;
}
}
break;
case CAM_STREAM_TYPE_VIDEO:
{
//Use uncached allocation by default
if (mParameters.isVideoBuffersCached() || mParameters.isSeeMoreEnabled() ||
mParameters.isHighQualityNoiseReductionMode()) {
bCachedMem = QCAMERA_ION_USE_CACHE;
}
else {
bCachedMem = QCAMERA_ION_USE_NOCACHE;
}
QCameraVideoMemory *videoMemory = NULL;
if (mParameters.getVideoBatchSize()) {
videoMemory = new QCameraVideoMemory(
mGetMemory, FALSE, QCAMERA_MEM_TYPE_BATCH);
if (videoMemory == NULL) {
LOGE("Out of memory for video batching obj");
return NULL;
}
/*
* numFDs = BATCH size
* numInts = 5 // OFFSET, SIZE, USAGE, TIMESTAMP, FORMAT
*/
rc = videoMemory->allocateMeta(
CAMERA_MIN_VIDEO_BATCH_BUFFERS,
mParameters.getVideoBatchSize(),
VIDEO_METADATA_NUM_INTS);
if (rc < 0) {
delete videoMemory;
return NULL;
}
} else {
videoMemory =
new QCameraVideoMemory(mGetMemory, bCachedMem);
if (videoMemory == NULL) {
LOGE("Out of memory for video obj");
return NULL;
}
}
int usage = 0;
cam_format_t fmt;
mParameters.getStreamFormat(CAM_STREAM_TYPE_VIDEO,fmt);
if (mParameters.isUBWCEnabled() && (fmt == CAM_FORMAT_YUV_420_NV12_UBWC)) {
usage = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
}
videoMemory->setVideoInfo(usage, fmt);
mem = videoMemory;
}
break;
case CAM_STREAM_TYPE_CALLBACK:
mem = new QCameraStreamMemory(mGetMemory,
bCachedMem,
(bPoolMem) ? &m_memoryPool : NULL,
stream_type);
break;
case CAM_STREAM_TYPE_DEFAULT:
case CAM_STREAM_TYPE_MAX:
default:
break;
}
if (!mem) {
return NULL;
}
if (bufferCnt > 0) {
if (mParameters.isSecureMode() &&
(stream_type == CAM_STREAM_TYPE_RAW) &&
(mParameters.isRdiMode())) {
LOGD("Allocating %d secure buffers of size %d ", bufferCnt, size);
rc = mem->allocate(bufferCnt, size, SECURE);
} else {
rc = mem->allocate(bufferCnt, size, NON_SECURE);
}
if (rc < 0) {
delete mem;
return NULL;
}
bufferCnt = mem->getCnt();
}
LOGH("rc = %d type = %d count = %d size = %d cache = %d, pool = %d",
rc, stream_type, bufferCnt, size, bCachedMem, bPoolMem);
return mem;
}
/*===========================================================================
* FUNCTION : allocateMoreStreamBuf
*
* DESCRIPTION: alocate more stream buffers from the memory object
*
* PARAMETERS :
* @mem_obj : memory object ptr
* @size : size of buffer
* @bufferCnt : [IN/OUT] additional number of buffers to be allocated.
* output will be the number of total buffers
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::allocateMoreStreamBuf(
QCameraMemory *mem_obj, size_t size, uint8_t &bufferCnt)
{
int rc = NO_ERROR;
if (bufferCnt > 0) {
rc = mem_obj->allocateMore(bufferCnt, size);
bufferCnt = mem_obj->getCnt();
}
return rc;
}
/*===========================================================================
* FUNCTION : allocateMiscBuf
*
* DESCRIPTION: alocate miscellaneous buffer
*
* PARAMETERS :
* @streamInfo : stream info
*
* RETURN : ptr to a memory obj that holds stream info buffer.
* NULL if failed
*==========================================================================*/
QCameraHeapMemory *QCamera2HardwareInterface::allocateMiscBuf(
cam_stream_info_t *streamInfo)
{
int rc = NO_ERROR;
uint8_t bufNum = 0;
size_t bufSize = 0;
QCameraHeapMemory *miscBuf = NULL;
uint32_t feature_mask =
streamInfo->reprocess_config.pp_feature_config.feature_mask;
switch (streamInfo->stream_type) {
case CAM_STREAM_TYPE_OFFLINE_PROC:
if (CAM_QCOM_FEATURE_TRUEPORTRAIT & feature_mask) {
bufNum = 1;
bufSize = mParameters.getTPMaxMetaSize();
} else if (CAM_QCOM_FEATURE_REFOCUS & feature_mask) {
bufNum = 1;
bufSize = mParameters.getRefocusMaxMetaSize();
}
break;
default:
break;
}
if (bufNum && bufSize) {
miscBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
if (!miscBuf) {
LOGE("Unable to allocate miscBuf object");
return NULL;
}
rc = miscBuf->allocate(bufNum, bufSize, NON_SECURE);
if (rc < 0) {
LOGE("Failed to allocate misc buffer memory");
delete miscBuf;
return NULL;
}
}
return miscBuf;
}
/*===========================================================================
* FUNCTION : allocateStreamInfoBuf
*
* DESCRIPTION: alocate stream info buffer
*
* PARAMETERS :
* @stream_type : type of stream
*
* RETURN : ptr to a memory obj that holds stream info buffer.
* NULL if failed
*==========================================================================*/
QCameraHeapMemory *QCamera2HardwareInterface::allocateStreamInfoBuf(
cam_stream_type_t stream_type)
{
int rc = NO_ERROR;
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
QCameraHeapMemory *streamInfoBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
if (!streamInfoBuf) {
LOGE("allocateStreamInfoBuf: Unable to allocate streamInfo object");
return NULL;
}
rc = streamInfoBuf->allocate(1, sizeof(cam_stream_info_t), NON_SECURE);
if (rc < 0) {
LOGE("allocateStreamInfoBuf: Failed to allocate stream info memory");
delete streamInfoBuf;
return NULL;
}
cam_stream_info_t *streamInfo = (cam_stream_info_t *)streamInfoBuf->getPtr(0);
memset(streamInfo, 0, sizeof(cam_stream_info_t));
streamInfo->stream_type = stream_type;
rc = mParameters.getStreamFormat(stream_type, streamInfo->fmt);
rc = mParameters.getStreamDimension(stream_type, streamInfo->dim);
rc = mParameters.getStreamRotation(stream_type, streamInfo->pp_config, streamInfo->dim);
streamInfo->num_bufs = getBufNumRequired(stream_type);
streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
streamInfo->is_secure = NON_SECURE;
switch (stream_type) {
case CAM_STREAM_TYPE_SNAPSHOT:
if ((mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) ||
mLongshotEnabled) {
streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
} else {
streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
streamInfo->num_of_burst = (uint8_t)
(mParameters.getNumOfSnapshots()
+ mParameters.getNumOfExtraHDRInBufsIfNeeded()
- mParameters.getNumOfExtraHDROutBufsIfNeeded()
+ mParameters.getNumOfExtraBuffersForImageProc());
}
break;
case CAM_STREAM_TYPE_RAW:
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if ((mParameters.isZSLMode()) || (isRdiMode()) || (raw_yuv)) {
streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
} else {
streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
streamInfo->num_of_burst = mParameters.getNumOfSnapshots();
}
if (mParameters.isSecureMode() && mParameters.isRdiMode()) {
streamInfo->is_secure = SECURE;
} else {
streamInfo->is_secure = NON_SECURE;
}
break;
case CAM_STREAM_TYPE_POSTVIEW:
if (mLongshotEnabled) {
streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
} else {
streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
streamInfo->num_of_burst = (uint8_t)(mParameters.getNumOfSnapshots()
+ mParameters.getNumOfExtraHDRInBufsIfNeeded()
- mParameters.getNumOfExtraHDROutBufsIfNeeded()
+ mParameters.getNumOfExtraBuffersForImageProc());
}
break;
case CAM_STREAM_TYPE_VIDEO:
streamInfo->dis_enable = mParameters.isDISEnabled();
if (mParameters.getBufBatchCount()) {
//Update stream info structure with batch mode info
streamInfo->streaming_mode = CAM_STREAMING_MODE_BATCH;
streamInfo->user_buf_info.frame_buf_cnt = mParameters.getBufBatchCount();
streamInfo->user_buf_info.size =
(uint32_t)(sizeof(struct msm_camera_user_buf_cont_t));
cam_fps_range_t pFpsRange;
mParameters.getHfrFps(pFpsRange);
streamInfo->user_buf_info.frameInterval =
(long)((1000/pFpsRange.video_max_fps) * 1000);
LOGH("Video Batch Count = %d, interval = %d",
streamInfo->user_buf_info.frame_buf_cnt,
streamInfo->user_buf_info.frameInterval);
}
case CAM_STREAM_TYPE_PREVIEW:
if (mParameters.getRecordingHintValue()) {
if(mParameters.isDISEnabled()) {
streamInfo->is_type = mParameters.getISType();
} else {
streamInfo->is_type = IS_TYPE_NONE;
}
}
if (mParameters.isSecureMode()) {
streamInfo->is_secure = SECURE;
}
break;
case CAM_STREAM_TYPE_ANALYSIS:
streamInfo->noFrameExpected = 1;
break;
default:
break;
}
// Update feature mask
mParameters.updatePpFeatureMask(stream_type);
// Get feature mask
mParameters.getStreamPpMask(stream_type, streamInfo->pp_config.feature_mask);
// Update pp config
if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_FLIP) {
int flipMode = mParameters.getFlipMode(stream_type);
if (flipMode > 0) {
streamInfo->pp_config.flip = (uint32_t)flipMode;
}
}
if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_SHARPNESS) {
streamInfo->pp_config.sharpness = mParameters.getSharpness();
}
if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_EFFECT) {
streamInfo->pp_config.effect = mParameters.getEffectValue();
}
if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_DENOISE2D) {
streamInfo->pp_config.denoise2d.denoise_enable = 1;
streamInfo->pp_config.denoise2d.process_plates =
mParameters.getDenoiseProcessPlate(CAM_INTF_PARM_WAVELET_DENOISE);
}
if (!((needReprocess()) && (CAM_STREAM_TYPE_SNAPSHOT == stream_type ||
CAM_STREAM_TYPE_RAW == stream_type))) {
if (gCamCapability[mCameraId]->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_CROP)
streamInfo->pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
if (gCamCapability[mCameraId]->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_SCALE)
streamInfo->pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
}
LOGH("type %d, fmt %d, dim %dx%d, num_bufs %d mask = 0x%x\n",
stream_type, streamInfo->fmt, streamInfo->dim.width,
streamInfo->dim.height, streamInfo->num_bufs,
streamInfo->pp_config.feature_mask);
return streamInfoBuf;
}
/*===========================================================================
* FUNCTION : allocateStreamUserBuf
*
* DESCRIPTION: allocate user ptr for stream buffers
*
* PARAMETERS :
* @streamInfo : stream info structure
*
* RETURN : ptr to a memory obj that holds stream info buffer.
* NULL if failed
*==========================================================================*/
QCameraMemory *QCamera2HardwareInterface::allocateStreamUserBuf(
cam_stream_info_t *streamInfo)
{
int rc = NO_ERROR;
QCameraMemory *mem = NULL;
int bufferCnt = 0;
int size = 0;
if (streamInfo->streaming_mode != CAM_STREAMING_MODE_BATCH) {
LOGE("Stream is not in BATCH mode. Invalid Stream");
return NULL;
}
// Allocate stream user buffer memory object
switch (streamInfo->stream_type) {
case CAM_STREAM_TYPE_VIDEO: {
QCameraVideoMemory *video_mem = new QCameraVideoMemory(
mGetMemory, FALSE, QCAMERA_MEM_TYPE_BATCH);
if (video_mem == NULL) {
LOGE("Out of memory for video obj");
return NULL;
}
/*
* numFDs = BATCH size
* numInts = 5 // OFFSET, SIZE, USAGE, TIMESTAMP, FORMAT
*/
rc = video_mem->allocateMeta(streamInfo->num_bufs,
mParameters.getBufBatchCount(), VIDEO_METADATA_NUM_INTS);
if (rc < 0) {
LOGE("allocateMeta failed");
delete video_mem;
return NULL;
}
int usage = 0;
cam_format_t fmt;
mParameters.getStreamFormat(CAM_STREAM_TYPE_VIDEO, fmt);
if(mParameters.isUBWCEnabled() && (fmt == CAM_FORMAT_YUV_420_NV12_UBWC)) {
usage = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
}
video_mem->setVideoInfo(usage, fmt);
mem = static_cast<QCameraMemory *>(video_mem);
}
break;
case CAM_STREAM_TYPE_PREVIEW:
case CAM_STREAM_TYPE_POSTVIEW:
case CAM_STREAM_TYPE_ANALYSIS:
case CAM_STREAM_TYPE_SNAPSHOT:
case CAM_STREAM_TYPE_RAW:
case CAM_STREAM_TYPE_METADATA:
case CAM_STREAM_TYPE_OFFLINE_PROC:
case CAM_STREAM_TYPE_CALLBACK:
LOGE("Stream type Not supported.for BATCH processing");
break;
case CAM_STREAM_TYPE_DEFAULT:
case CAM_STREAM_TYPE_MAX:
default:
break;
}
if (!mem) {
LOGE("Failed to allocate mem");
return NULL;
}
/*Size of this buffer will be number of batch buffer */
size = PAD_TO_SIZE((streamInfo->num_bufs * streamInfo->user_buf_info.size),
CAM_PAD_TO_4K);
LOGH("Allocating BATCH Buffer count = %d", streamInfo->num_bufs);
if (size > 0) {
// Allocating one buffer for all batch buffers
rc = mem->allocate(1, size, NON_SECURE);
if (rc < 0) {
delete mem;
return NULL;
}
}
return mem;
}
/*===========================================================================
* FUNCTION : waitForDeferredAlloc
*
* DESCRIPTION: Wait for deferred allocation, if applicable
* (applicable only for metadata buffers so far)
*
* PARAMETERS :
* @stream_type : type of stream to (possibly) wait for
*
* RETURN : None
*==========================================================================*/
void QCamera2HardwareInterface::waitForDeferredAlloc(cam_stream_type_t stream_type)
{
if (stream_type == CAM_STREAM_TYPE_METADATA) {
waitDeferredWork(mMetadataAllocJob);
}
}
/*===========================================================================
* FUNCTION : setPreviewWindow
*
* DESCRIPTION: set preview window impl
*
* PARAMETERS :
* @window : ptr to window ops table struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::setPreviewWindow(
struct preview_stream_ops *window)
{
mPreviewWindow = window;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setCallBacks
*
* DESCRIPTION: set callbacks impl
*
* PARAMETERS :
* @notify_cb : notify cb
* @data_cb : data cb
* @data_cb_timestamp : data cb with time stamp
* @get_memory : request memory ops table
* @user : user data ptr
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::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)
{
mNotifyCb = notify_cb;
mDataCb = data_cb;
mDataCbTimestamp = data_cb_timestamp;
mGetMemory = get_memory;
mCallbackCookie = user;
m_cbNotifier.setCallbacks(notify_cb, data_cb, data_cb_timestamp, user);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setJpegCallBacks
*
* DESCRIPTION: set JPEG callbacks impl
*
* PARAMETERS :
* @jpegCb : Jpeg callback method
* @callbackCookie : callback cookie
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
void QCamera2HardwareInterface::setJpegCallBacks(jpeg_data_callback jpegCb,
void *callbackCookie)
{
LOGH("camera id %d", getCameraId());
mJpegCb = jpegCb;
mJpegCallbackCookie = callbackCookie;
m_cbNotifier.setJpegCallBacks(mJpegCb, mJpegCallbackCookie);
}
/*===========================================================================
* FUNCTION : enableMsgType
*
* DESCRIPTION: enable msg type impl
*
* PARAMETERS :
* @msg_type : msg type mask to be enabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::enableMsgType(int32_t msg_type)
{
int32_t rc = NO_ERROR;
if (mParameters.isUBWCEnabled()) {
/*Need Special CALLBACK stream incase application requesting for
Preview callback in UBWC case*/
if (!(msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) &&
(msg_type & CAMERA_MSG_PREVIEW_FRAME)) {
if (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL) {
rc = startChannel(QCAMERA_CH_TYPE_CALLBACK);
if (rc != NO_ERROR) {
LOGE("START Callback Channel failed");
}
}
}
}
mMsgEnabled |= msg_type;
LOGH("(0x%x) : mMsgEnabled = 0x%x rc = %d", msg_type , mMsgEnabled, rc);
return rc;
}
/*===========================================================================
* FUNCTION : disableMsgType
*
* DESCRIPTION: disable msg type impl
*
* PARAMETERS :
* @msg_type : msg type mask to be disabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::disableMsgType(int32_t msg_type)
{
int32_t rc = NO_ERROR;
if (mParameters.isUBWCEnabled()) {
/*STOP CALLBACK STREAM*/
if ((msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) &&
(msg_type & CAMERA_MSG_PREVIEW_FRAME)) {
if (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL) {
rc = stopChannel(QCAMERA_CH_TYPE_CALLBACK);
if (rc != NO_ERROR) {
LOGE("STOP Callback Channel failed");
}
}
}
}
mMsgEnabled &= ~msg_type;
LOGH("(0x%x) : mMsgEnabled = 0x%x rc = %d", msg_type , mMsgEnabled, rc);
return rc;
}
/*===========================================================================
* FUNCTION : msgTypeEnabled
*
* DESCRIPTION: impl to determine if certain msg_type is enabled
*
* PARAMETERS :
* @msg_type : msg type mask
*
* RETURN : 0 -- not enabled
* none 0 -- enabled
*==========================================================================*/
int QCamera2HardwareInterface::msgTypeEnabled(int32_t msg_type)
{
return (mMsgEnabled & msg_type);
}
/*===========================================================================
* FUNCTION : msgTypeEnabledWithLock
*
* DESCRIPTION: impl to determine if certain msg_type is enabled with lock
*
* PARAMETERS :
* @msg_type : msg type mask
*
* RETURN : 0 -- not enabled
* none 0 -- enabled
*==========================================================================*/
int QCamera2HardwareInterface::msgTypeEnabledWithLock(int32_t msg_type)
{
int enabled = 0;
lockAPI();
enabled = mMsgEnabled & msg_type;
unlockAPI();
return enabled;
}
/*===========================================================================
* FUNCTION : startPreview
*
* DESCRIPTION: start preview impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::startPreview()
{
KPI_ATRACE_CALL();
int32_t rc = NO_ERROR;
LOGI("E ZSL = %d Recording Hint = %d", mParameters.isZSLMode(),
mParameters.getRecordingHintValue());
m_perfLock.lock_acq();
updateThermalLevel((void *)&mThermalLevel);
mIgnoredPreviewCount = 0;
// start preview stream
if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) {
rc = startChannel(QCAMERA_CH_TYPE_ZSL);
} else {
rc = startChannel(QCAMERA_CH_TYPE_PREVIEW);
}
if (rc != NO_ERROR) {
LOGE("failed to start channels");
m_perfLock.lock_rel();
return rc;
}
if ((msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME))
&& (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL)) {
rc = startChannel(QCAMERA_CH_TYPE_CALLBACK);
if (rc != NO_ERROR) {
LOGE("failed to start callback stream");
stopChannel(QCAMERA_CH_TYPE_ZSL);
stopChannel(QCAMERA_CH_TYPE_PREVIEW);
m_perfLock.lock_rel();
return rc;
}
}
updatePostPreviewParameters();
m_stateMachine.setPreviewCallbackNeeded(true);
// if job id is non-zero, that means the postproc init job is already
// pending or complete
if (mInitPProcJob == 0) {
mInitPProcJob = deferPPInit();
if (mInitPProcJob == 0) {
LOGE("Unable to initialize postprocessor, mCameraHandle = %p",
mCameraHandle);
rc = -ENOMEM;
m_perfLock.lock_rel();
return rc;
}
}
m_perfLock.lock_rel();
if (rc == NO_ERROR) {
// Set power Hint for preview
m_perfLock.powerHint(POWER_HINT_CAM_PREVIEW, true);
}
LOGI("X rc = %d", rc);
return rc;
}
int32_t QCamera2HardwareInterface::updatePostPreviewParameters() {
// Enable OIS only in Camera mode and 4k2k camcoder mode
int32_t rc = NO_ERROR;
rc = mParameters.updateOisValue(1);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : stopPreview
*
* DESCRIPTION: stop preview impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::stopPreview()
{
KPI_ATRACE_CALL();
LOGI("E");
mNumPreviewFaces = -1;
mActiveAF = false;
// Disable power Hint for preview
m_perfLock.powerHint(POWER_HINT_CAM_PREVIEW, false);
m_perfLock.lock_acq();
// stop preview stream
stopChannel(QCAMERA_CH_TYPE_CALLBACK);
stopChannel(QCAMERA_CH_TYPE_ZSL);
stopChannel(QCAMERA_CH_TYPE_PREVIEW);
stopChannel(QCAMERA_CH_TYPE_RAW);
m_cbNotifier.flushPreviewNotifications();
//add for ts makeup
#ifdef TARGET_TS_MAKEUP
ts_makeup_finish();
#endif
// delete all channels from preparePreview
unpreparePreview();
m_perfLock.lock_rel();
LOGI("X");
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : storeMetaDataInBuffers
*
* DESCRIPTION: enable store meta data in buffers for video frames impl
*
* PARAMETERS :
* @enable : flag if need enable
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::storeMetaDataInBuffers(int enable)
{
mStoreMetaDataInFrame = enable;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : preStartRecording
*
* DESCRIPTION: Prepare start recording impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::preStartRecording()
{
int32_t rc = NO_ERROR;
LOGH("E");
if (mParameters.getRecordingHintValue() == false) {
// Give HWI control to restart preview only in single camera mode.
// In dual-cam mode, this control belongs to muxer.
if (getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
LOGH("start recording when hint is false, stop preview first");
stopPreview();
// Set recording hint to TRUE
mParameters.updateRecordingHintValue(TRUE);
rc = preparePreview();
if (rc == NO_ERROR) {
rc = startPreview();
}
}
else
{
// For dual cam mode, update the flag mPreviewRestartNeeded to true
// Restart control will be handled by muxer.
mPreviewRestartNeeded = true;
}
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : startRecording
*
* DESCRIPTION: start recording impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::startRecording()
{
int32_t rc = NO_ERROR;
LOGI("E");
//link meta stream with video channel if low power mode.
if (isLowPowerMode()) {
// Find and try to link a metadata stream from preview channel
QCameraChannel *pMetaChannel = NULL;
QCameraStream *pMetaStream = NULL;
QCameraChannel *pVideoChannel = m_channels[QCAMERA_CH_TYPE_VIDEO];
if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
uint32_t streamNum = pMetaChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < streamNum ; i++ ) {
pStream = pMetaChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_METADATA == pStream->getMyType())) {
pMetaStream = pStream;
break;
}
}
}
if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
rc = pVideoChannel->linkStream(pMetaChannel, pMetaStream);
if (NO_ERROR != rc) {
LOGW("Metadata stream link failed %d", rc);
}
}
}
if (rc == NO_ERROR) {
rc = startChannel(QCAMERA_CH_TYPE_VIDEO);
}
if (mParameters.isTNRSnapshotEnabled() && !isLowPowerMode()) {
QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
if (!mParameters.is4k2kVideoResolution()) {
// Find and try to link a metadata stream from preview channel
QCameraChannel *pMetaChannel = NULL;
QCameraStream *pMetaStream = NULL;
if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
uint32_t streamNum = pMetaChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < streamNum ; i++ ) {
pStream = pMetaChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_METADATA ==
pStream->getMyType())) {
pMetaStream = pStream;
break;
}
}
}
if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
rc = pChannel->linkStream(pMetaChannel, pMetaStream);
if (NO_ERROR != rc) {
LOGW("Metadata stream link failed %d", rc);
}
}
}
LOGH("START snapshot Channel for TNR processing");
rc = pChannel->start();
}
LOGI("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : stopRecording
*
* DESCRIPTION: stop recording impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::stopRecording()
{
LOGI("E");
// stop snapshot channel
if (mParameters.isTNRSnapshotEnabled()) {
LOGH("STOP snapshot Channel for TNR processing");
stopChannel(QCAMERA_CH_TYPE_SNAPSHOT);
}
int rc = stopChannel(QCAMERA_CH_TYPE_VIDEO);
LOGI("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : releaseRecordingFrame
*
* DESCRIPTION: return video frame impl
*
* PARAMETERS :
* @opaque : ptr to video frame to be returned
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::releaseRecordingFrame(const void * opaque)
{
int32_t rc = UNKNOWN_ERROR;
QCameraVideoChannel *pChannel =
(QCameraVideoChannel *)m_channels[QCAMERA_CH_TYPE_VIDEO];
LOGD("opaque data = %p",opaque);
if(pChannel != NULL) {
rc = pChannel->releaseFrame(opaque, mStoreMetaDataInFrame > 0);
}
return rc;
}
/*===========================================================================
* FUNCTION : autoFocus
*
* DESCRIPTION: start auto focus impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::autoFocus()
{
int rc = NO_ERROR;
cam_focus_mode_type focusMode = mParameters.getFocusMode();
LOGH("E");
m_currentFocusState = CAM_AF_STATE_INACTIVE;
switch (focusMode) {
case CAM_FOCUS_MODE_AUTO:
case CAM_FOCUS_MODE_MACRO:
case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
mActiveAF = true;
LOGI("Send AUTO FOCUS event. focusMode=%d, m_currentFocusState=%d",
focusMode, m_currentFocusState);
rc = mCameraHandle->ops->do_auto_focus(mCameraHandle->camera_handle);
break;
case CAM_FOCUS_MODE_INFINITY:
case CAM_FOCUS_MODE_FIXED:
case CAM_FOCUS_MODE_EDOF:
default:
LOGI("No ops in focusMode (%d)", focusMode);
rc = sendEvtNotify(CAMERA_MSG_FOCUS, true, 0);
break;
}
if (NO_ERROR != rc) {
mActiveAF = false;
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : cancelAutoFocus
*
* DESCRIPTION: cancel auto focus impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::cancelAutoFocus()
{
int rc = NO_ERROR;
cam_focus_mode_type focusMode = mParameters.getFocusMode();
switch (focusMode) {
case CAM_FOCUS_MODE_AUTO:
case CAM_FOCUS_MODE_MACRO:
case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
mActiveAF = false;
rc = mCameraHandle->ops->cancel_auto_focus(mCameraHandle->camera_handle);
break;
case CAM_FOCUS_MODE_INFINITY:
case CAM_FOCUS_MODE_FIXED:
case CAM_FOCUS_MODE_EDOF:
default:
LOGD("No ops in focusMode (%d)", focusMode);
break;
}
return rc;
}
/*===========================================================================
* FUNCTION : processUFDumps
*
* DESCRIPTION: process UF jpeg dumps for refocus support
*
* PARAMETERS :
* @evt : payload of jpeg event, including information about jpeg encoding
* status, jpeg size and so on.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*
* NOTE : none
*==========================================================================*/
bool QCamera2HardwareInterface::processUFDumps(qcamera_jpeg_evt_payload_t *evt)
{
bool ret = true;
if (mParameters.isUbiRefocus()) {
int index = (int)getOutputImageCount();
bool allFocusImage = (index == ((int)mParameters.getRefocusOutputCount() - 1));
char name[FILENAME_MAX];
camera_memory_t *jpeg_mem = NULL;
omx_jpeg_ouput_buf_t *jpeg_out = NULL;
size_t dataLen;
uint8_t *dataPtr;
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Init PProc Deferred work failed");
return false;
}
if (!m_postprocessor.getJpegMemOpt()) {
dataLen = evt->out_data.buf_filled_len;
dataPtr = evt->out_data.buf_vaddr;
} else {
jpeg_out = (omx_jpeg_ouput_buf_t*) evt->out_data.buf_vaddr;
if (!jpeg_out) {
LOGE("Null pointer detected");
return false;
}
jpeg_mem = (camera_memory_t *)jpeg_out->mem_hdl;
if (!jpeg_mem) {
LOGE("Null pointer detected");
return false;
}
dataPtr = (uint8_t *)jpeg_mem->data;
dataLen = jpeg_mem->size;
}
if (allFocusImage) {
snprintf(name, sizeof(name), "AllFocusImage");
index = -1;
} else {
snprintf(name, sizeof(name), "%d", 0);
}
CAM_DUMP_TO_FILE(QCAMERA_DUMP_FRM_LOCATION"ubifocus", name, index, "jpg",
dataPtr, dataLen);
LOGD("Dump the image %d %d allFocusImage %d",
getOutputImageCount(), index, allFocusImage);
setOutputImageCount(getOutputImageCount() + 1);
if (!allFocusImage) {
ret = false;
}
}
return ret;
}
/*===========================================================================
* FUNCTION : unconfigureAdvancedCapture
*
* DESCRIPTION: unconfigure Advanced Capture.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::unconfigureAdvancedCapture()
{
int32_t rc = NO_ERROR;
if (mAdvancedCaptureConfigured) {
mAdvancedCaptureConfigured = false;
if(mIs3ALocked) {
mParameters.set3ALock(false);
mIs3ALocked = false;
}
if (mParameters.isHDREnabled() || mParameters.isAEBracketEnabled()) {
rc = mParameters.setToneMapMode(true, true);
if (rc != NO_ERROR) {
LOGW("Failed to enable tone map during HDR/AEBracketing");
}
mHDRBracketingEnabled = false;
rc = mParameters.stopAEBracket();
} else if ((mParameters.isChromaFlashEnabled())
|| (mFlashNeeded && !mLongshotEnabled)
|| (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
|| (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
rc = mParameters.resetFrameCapture(TRUE);
} else if (mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
rc = configureAFBracketing(false);
} else if (mParameters.isOptiZoomEnabled()) {
rc = mParameters.setAndCommitZoom(mZoomLevel);
} else if (mParameters.isStillMoreEnabled()) {
cam_still_more_t stillmore_config = mParameters.getStillMoreSettings();
stillmore_config.burst_count = 0;
mParameters.setStillMoreSettings(stillmore_config);
/* If SeeMore is running, it will handle re-enabling tone map */
if (!mParameters.isSeeMoreEnabled() && !mParameters.isLTMForSeeMoreEnabled()) {
rc = mParameters.setToneMapMode(true, true);
if (rc != NO_ERROR) {
LOGW("Failed to enable tone map during StillMore");
}
}
/* Re-enable Tintless */
mParameters.setTintless(true);
} else {
LOGW("No Advanced Capture feature enabled!!");
rc = BAD_VALUE;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : configureAdvancedCapture
*
* DESCRIPTION: configure Advanced Capture.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureAdvancedCapture()
{
LOGH("E");
int32_t rc = NO_ERROR;
rc = mParameters.checkFeatureConcurrency();
if (rc != NO_ERROR) {
LOGE("Cannot support Advanced capture modes");
return rc;
}
setOutputImageCount(0);
mInputCount = 0;
mAdvancedCaptureConfigured = true;
/* Display should be disabled for advanced modes */
bool bDisplay = false;
if (getRelatedCamSyncInfo()->mode == CAM_MODE_SECONDARY) {
// no Advance capture settings for Aux camera
LOGH("X Secondary Camera, no need to process!! ");
return rc;
}
/* Do not stop display if in stillmore livesnapshot */
if (mParameters.isStillMoreEnabled() &&
mParameters.isSeeMoreEnabled()) {
bDisplay = true;
}
if (mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
rc = configureAFBracketing();
} else if (mParameters.isOptiZoomEnabled()) {
rc = configureOptiZoom();
} else if(mParameters.isHDREnabled()) {
rc = configureHDRBracketing();
if (mHDRBracketingEnabled) {
rc = mParameters.setToneMapMode(false, true);
if (rc != NO_ERROR) {
LOGW("Failed to disable tone map during HDR");
}
}
} else if (mParameters.isAEBracketEnabled()) {
rc = mParameters.setToneMapMode(false, true);
if (rc != NO_ERROR) {
LOGW("Failed to disable tone map during AEBracketing");
}
rc = configureAEBracketing();
} else if (mParameters.isStillMoreEnabled()) {
rc = configureStillMore();
} else if ((mParameters.isChromaFlashEnabled())
|| (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
|| (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
rc = mParameters.configFrameCapture(TRUE);
} else if (mFlashNeeded && !mLongshotEnabled) {
rc = mParameters.configFrameCapture(TRUE);
bDisplay = true;
} else {
LOGH("Advanced Capture feature not enabled!! ");
mAdvancedCaptureConfigured = false;
bDisplay = true;
}
LOGH("Stop preview temporarily for advanced captures");
m_stateMachine.setDisplayFrame(bDisplay);
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : configureAFBracketing
*
* DESCRIPTION: configure AF Bracketing.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureAFBracketing(bool enable)
{
LOGH("E");
int32_t rc = NO_ERROR;
cam_af_bracketing_t *af_bracketing_need;
if (mParameters.isUbiRefocus()) {
af_bracketing_need =
&gCamCapability[mCameraId]->refocus_af_bracketing_need;
} else {
af_bracketing_need =
&gCamCapability[mCameraId]->ubifocus_af_bracketing_need;
}
//Enable AF Bracketing.
cam_af_bracketing_t afBracket;
memset(&afBracket, 0, sizeof(cam_af_bracketing_t));
afBracket.enable = enable;
afBracket.burst_count = af_bracketing_need->burst_count;
for(int8_t i = 0; i < MAX_AF_BRACKETING_VALUES; i++) {
afBracket.focus_steps[i] = af_bracketing_need->focus_steps[i];
LOGH("focus_step[%d] = %d", i, afBracket.focus_steps[i]);
}
//Send cmd to backend to set AF Bracketing for Ubi Focus.
rc = mParameters.commitAFBracket(afBracket);
if ( NO_ERROR != rc ) {
LOGE("cannot configure AF bracketing");
return rc;
}
if (enable) {
mParameters.set3ALock(true);
mIs3ALocked = true;
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : configureHDRBracketing
*
* DESCRIPTION: configure HDR Bracketing.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureHDRBracketing()
{
LOGH("E");
int32_t rc = NO_ERROR;
cam_hdr_bracketing_info_t& hdrBracketingSetting =
gCamCapability[mCameraId]->hdr_bracketing_setting;
// 'values' should be in "idx1,idx2,idx3,..." format
uint32_t hdrFrameCount =
hdrBracketingSetting.num_frames;
LOGH("HDR values %d, %d frame count: %u",
(int8_t) hdrBracketingSetting.exp_val.values[0],
(int8_t) hdrBracketingSetting.exp_val.values[1],
hdrFrameCount);
// Enable AE Bracketing for HDR
cam_exp_bracketing_t aeBracket;
memset(&aeBracket, 0, sizeof(cam_exp_bracketing_t));
aeBracket.mode =
hdrBracketingSetting.exp_val.mode;
if (aeBracket.mode == CAM_EXP_BRACKETING_ON) {
mHDRBracketingEnabled = true;
}
String8 tmp;
for (uint32_t i = 0; i < hdrFrameCount; i++) {
tmp.appendFormat("%d",
(int8_t) hdrBracketingSetting.exp_val.values[i]);
tmp.append(",");
}
if (mParameters.isHDR1xFrameEnabled()
&& mParameters.isHDR1xExtraBufferNeeded()) {
tmp.appendFormat("%d", 0);
tmp.append(",");
}
if( !tmp.isEmpty() &&
( MAX_EXP_BRACKETING_LENGTH > tmp.length() ) ) {
//Trim last comma
memset(aeBracket.values, '\0', MAX_EXP_BRACKETING_LENGTH);
memcpy(aeBracket.values, tmp.string(), tmp.length() - 1);
}
LOGH("HDR config values %s",
aeBracket.values);
rc = mParameters.setHDRAEBracket(aeBracket);
if ( NO_ERROR != rc ) {
LOGE("cannot configure HDR bracketing");
return rc;
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : configureAEBracketing
*
* DESCRIPTION: configure AE Bracketing.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureAEBracketing()
{
LOGH("E");
int32_t rc = NO_ERROR;
rc = mParameters.setAEBracketing();
if ( NO_ERROR != rc ) {
LOGE("cannot configure AE bracketing");
return rc;
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : configureOptiZoom
*
* DESCRIPTION: configure Opti Zoom.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureOptiZoom()
{
int32_t rc = NO_ERROR;
//store current zoom level.
mZoomLevel = mParameters.getParmZoomLevel();
//set zoom level to 1x;
mParameters.setAndCommitZoom(0);
mParameters.set3ALock(true);
mIs3ALocked = true;
return rc;
}
/*===========================================================================
* FUNCTION : configureStillMore
*
* DESCRIPTION: configure StillMore.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureStillMore()
{
int32_t rc = NO_ERROR;
uint8_t burst_cnt = 0;
cam_still_more_t stillmore_config;
cam_still_more_t stillmore_cap;
/* Disable Tone Map. If seemore is enabled, it will handle disabling it. */
if (!mParameters.isSeeMoreEnabled() && !mParameters.isLTMForSeeMoreEnabled()) {
rc = mParameters.setToneMapMode(false, true);
if (rc != NO_ERROR) {
LOGW("Failed to disable tone map during StillMore");
}
}
/* Lock 3A */
mParameters.set3ALock(true);
mIs3ALocked = true;
/* Disable Tintless */
mParameters.setTintless(false);
/* Initialize burst count from capability */
stillmore_cap = mParameters.getStillMoreCapability();
burst_cnt = stillmore_cap.max_burst_count;
/* Reconfigure burst count from dynamic scene data */
cam_dyn_img_data_t dynamic_img_data = mParameters.getDynamicImgData();
if (dynamic_img_data.input_count >= stillmore_cap.min_burst_count &&
dynamic_img_data.input_count <= stillmore_cap.max_burst_count) {
burst_cnt = dynamic_img_data.input_count;
}
/* Reconfigure burst count in the case of liveshot */
if (mParameters.isSeeMoreEnabled()) {
burst_cnt = 1;
}
/* Reconfigure burst count from user input */
char prop[PROPERTY_VALUE_MAX];
property_get("persist.camera.imglib.stillmore", prop, "0");
uint8_t burst_setprop = (uint32_t)atoi(prop);
if (burst_setprop != 0) {
if ((burst_setprop < stillmore_cap.min_burst_count) ||
(burst_setprop > stillmore_cap.max_burst_count)) {
burst_cnt = stillmore_cap.max_burst_count;
} else {
burst_cnt = burst_setprop;
}
}
memset(&stillmore_config, 0, sizeof(cam_still_more_t));
stillmore_config.burst_count = burst_cnt;
mParameters.setStillMoreSettings(stillmore_config);
LOGH("Stillmore burst %d", burst_cnt);
return rc;
}
/*===========================================================================
* FUNCTION : stopAdvancedCapture
*
* DESCRIPTION: stops advanced capture based on capture type
*
* PARAMETERS :
* @pChannel : channel.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::stopAdvancedCapture(
QCameraPicChannel *pChannel)
{
LOGH("stop bracketig");
int32_t rc = NO_ERROR;
if(mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
rc = pChannel->stopAdvancedCapture(MM_CAMERA_AF_BRACKETING);
} else if (mParameters.isChromaFlashEnabled()
|| (mFlashNeeded && !mLongshotEnabled)
|| (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
|| (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
rc = pChannel->stopAdvancedCapture(MM_CAMERA_FRAME_CAPTURE);
} else if(mParameters.isHDREnabled()
|| mParameters.isAEBracketEnabled()) {
rc = pChannel->stopAdvancedCapture(MM_CAMERA_AE_BRACKETING);
} else if (mParameters.isOptiZoomEnabled()) {
rc = pChannel->stopAdvancedCapture(MM_CAMERA_ZOOM_1X);
} else if (mParameters.isStillMoreEnabled()) {
LOGH("stopAdvancedCapture not needed for StillMore");
} else {
LOGH("No Advanced Capture feature enabled!");
rc = BAD_VALUE;
}
return rc;
}
/*===========================================================================
* FUNCTION : startAdvancedCapture
*
* DESCRIPTION: starts advanced capture based on capture type
*
* PARAMETERS :
* @pChannel : channel.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::startAdvancedCapture(
QCameraPicChannel *pChannel)
{
LOGH("Start bracketing");
int32_t rc = NO_ERROR;
if(mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
rc = pChannel->startAdvancedCapture(MM_CAMERA_AF_BRACKETING);
} else if (mParameters.isOptiZoomEnabled()) {
rc = pChannel->startAdvancedCapture(MM_CAMERA_ZOOM_1X);
} else if (mParameters.isStillMoreEnabled()) {
LOGH("startAdvancedCapture not needed for StillMore");
} else if (mParameters.isHDREnabled()
|| mParameters.isAEBracketEnabled()) {
rc = pChannel->startAdvancedCapture(MM_CAMERA_AE_BRACKETING);
} else if (mParameters.isChromaFlashEnabled()
|| (mFlashNeeded && !mLongshotEnabled)
|| (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
|| (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
cam_capture_frame_config_t config = mParameters.getCaptureFrameConfig();
rc = pChannel->startAdvancedCapture(MM_CAMERA_FRAME_CAPTURE, &config);
} else {
LOGE("No Advanced Capture feature enabled!");
rc = BAD_VALUE;
}
return rc;
}
/*===========================================================================
* FUNCTION : preTakePicture
*
* DESCRIPTION: Prepare take picture impl, Restarts preview if necessary
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::preTakePicture()
{
int32_t rc = NO_ERROR;
LOGH("E");
if (mParameters.getRecordingHintValue() == true) {
// Give HWI control to restart preview only in single camera mode.
// In dual-cam mode, this control belongs to muxer.
if (getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
LOGH("restart preview if rec hint is true and preview is running");
stopPreview();
mParameters.updateRecordingHintValue(FALSE);
// start preview again
rc = preparePreview();
if (rc == NO_ERROR) {
rc = startPreview();
if (rc != NO_ERROR) {
unpreparePreview();
}
}
}
else
{
// For dual cam mode, update the flag mPreviewRestartNeeded to true
// Restart control will be handled by muxer.
mPreviewRestartNeeded = true;
}
}
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : takePicture
*
* DESCRIPTION: take picture impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::takePicture()
{
int rc = NO_ERROR;
// Get total number for snapshots (retro + regular)
uint8_t numSnapshots = mParameters.getNumOfSnapshots();
// Get number of retro-active snapshots
uint8_t numRetroSnapshots = mParameters.getNumOfRetroSnapshots();
LOGH("E");
//Set rotation value from user settings as Jpeg rotation
//to configure back-end modules.
mParameters.setJpegRotation(mParameters.getRotation());
// Check if retro-active snapshots are not enabled
if (!isRetroPicture() || !mParameters.isZSLMode()) {
numRetroSnapshots = 0;
LOGH("Reset retro snaphot count to zero");
}
//Do special configure for advanced capture modes.
rc = configureAdvancedCapture();
if (rc != NO_ERROR) {
LOGE("Unsupported capture call");
return rc;
}
if (mAdvancedCaptureConfigured) {
numSnapshots = mParameters.getBurstCountForAdvancedCapture();
}
LOGI("snap count = %d zsl = %d advanced = %d",
numSnapshots, mParameters.isZSLMode(), mAdvancedCaptureConfigured);
if (mParameters.isZSLMode()) {
QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
QCameraPicChannel *pPicChannel = (QCameraPicChannel *)pChannel;
if (NULL != pPicChannel) {
if (mParameters.getofflineRAW()) {
startRAWChannel(pPicChannel);
pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_RAW];
if (pPicChannel == NULL) {
LOGE("RAW Channel is NULL in Manual capture mode");
stopRAWChannel();
return UNKNOWN_ERROR;
}
}
rc = configureOnlineRotation(*pPicChannel);
if (rc != NO_ERROR) {
LOGE("online rotation failed");
return rc;
}
// start postprocessor
DeferWorkArgs args;
memset(&args, 0, sizeof(DeferWorkArgs));
args.pprocArgs = pPicChannel;
// No need to wait for mInitPProcJob here, because it was
// queued in startPreview, and will definitely be processed before
// mReprocJob can begin.
mReprocJob = queueDeferredWork(CMD_DEF_PPROC_START,
args);
if (mReprocJob == 0) {
LOGE("Failure: Unable to start pproc");
return -ENOMEM;
}
// Check if all preview buffers are mapped before creating
// a jpeg session as preview stream buffers are queried during the same
uint8_t numStreams = pChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
QCameraStream *pPreviewStream = NULL;
for (uint8_t i = 0 ; i < numStreams ; i++ ) {
pStream = pChannel->getStreamByIndex(i);
if (!pStream)
continue;
if (CAM_STREAM_TYPE_PREVIEW == pStream->getMyType()) {
pPreviewStream = pStream;
break;
}
}
if (pPreviewStream != NULL) {
Mutex::Autolock l(mMapLock);
QCameraMemory *pMemory = pStream->getStreamBufs();
if (!pMemory) {
LOGE("Error!! pMemory is NULL");
return -ENOMEM;
}
uint8_t waitCnt = 2;
while (!pMemory->checkIfAllBuffersMapped() && (waitCnt > 0)) {
LOGL(" Waiting for preview buffers to be mapped");
mMapCond.waitRelative(
mMapLock, CAMERA_DEFERRED_MAP_BUF_TIMEOUT);
LOGL("Wait completed!!");
waitCnt--;
}
// If all buffers are not mapped after retries, assert
assert(pMemory->checkIfAllBuffersMapped());
} else {
assert(pPreviewStream);
}
// Create JPEG session
mJpegJob = queueDeferredWork(CMD_DEF_CREATE_JPEG_SESSION,
args);
if (mJpegJob == 0) {
LOGE("Failure: Unable to create jpeg session");
return -ENOMEM;
}
if (mAdvancedCaptureConfigured) {
rc = startAdvancedCapture(pPicChannel);
if (rc != NO_ERROR) {
LOGE("cannot start zsl advanced capture");
return rc;
}
}
if (mLongshotEnabled && mPrepSnapRun) {
mCameraHandle->ops->start_zsl_snapshot(
mCameraHandle->camera_handle,
pPicChannel->getMyHandle());
}
// If frame sync is ON and it is a SECONDARY camera,
// we do not need to send the take picture command to interface
// It will be handled along with PRIMARY camera takePicture request
mm_camera_req_buf_t buf;
memset(&buf, 0x0, sizeof(buf));
if ((!mParameters.isAdvCamFeaturesEnabled() &&
!mFlashNeeded &&
!isLongshotEnabled() &&
getRelatedCamSyncInfo()->is_frame_sync_enabled) &&
(getRelatedCamSyncInfo()->sync_control ==
CAM_SYNC_RELATED_SENSORS_ON)) {
if (getRelatedCamSyncInfo()->mode == CAM_MODE_PRIMARY) {
buf.type = MM_CAMERA_REQ_FRAME_SYNC_BUF;
buf.num_buf_requested = numSnapshots;
rc = pPicChannel->takePicture(&buf);
if (rc != NO_ERROR) {
LOGE("FS_DBG cannot take ZSL picture, stop pproc");
if (NO_ERROR != waitDeferredWork(mReprocJob)) {
LOGE("Reprocess Deferred work failed");
return UNKNOWN_ERROR;
}
if (NO_ERROR != waitDeferredWork(mJpegJob)) {
LOGE("Jpeg Deferred work failed");
return UNKNOWN_ERROR;
}
m_postprocessor.stop();
return rc;
}
LOGI("PRIMARY camera: send frame sync takePicture!!");
}
} else {
buf.type = MM_CAMERA_REQ_SUPER_BUF;
buf.num_buf_requested = numSnapshots;
buf.num_retro_buf_requested = numRetroSnapshots;
rc = pPicChannel->takePicture(&buf);
if (rc != NO_ERROR) {
LOGE("cannot take ZSL picture, stop pproc");
if (NO_ERROR != waitDeferredWork(mReprocJob)) {
LOGE("Reprocess Deferred work failed");
return UNKNOWN_ERROR;
}
if (NO_ERROR != waitDeferredWork(mJpegJob)) {
LOGE("Jpeg Deferred work failed");
return UNKNOWN_ERROR;
}
m_postprocessor.stop();
return rc;
}
}
} else {
LOGE("ZSL channel is NULL");
return UNKNOWN_ERROR;
}
} else {
// start snapshot
if (mParameters.isJpegPictureFormat() ||
mParameters.isNV16PictureFormat() ||
mParameters.isNV21PictureFormat()) {
//STOP Preview for Non ZSL use case
stopPreview();
//Config CAPTURE channels
rc = declareSnapshotStreams();
if (NO_ERROR != rc) {
return rc;
}
rc = addCaptureChannel();
if ((rc == NO_ERROR) &&
(NULL != m_channels[QCAMERA_CH_TYPE_CAPTURE])) {
if (!mParameters.getofflineRAW()) {
rc = configureOnlineRotation(
*m_channels[QCAMERA_CH_TYPE_CAPTURE]);
if (rc != NO_ERROR) {
LOGE("online rotation failed");
delChannel(QCAMERA_CH_TYPE_CAPTURE);
return rc;
}
}
DeferWorkArgs args;
memset(&args, 0, sizeof(DeferWorkArgs));
args.pprocArgs = m_channels[QCAMERA_CH_TYPE_CAPTURE];
// No need to wait for mInitPProcJob here, because it was
// queued in startPreview, and will definitely be processed before
// mReprocJob can begin.
mReprocJob = queueDeferredWork(CMD_DEF_PPROC_START,
args);
if (mReprocJob == 0) {
LOGE("Failure: Unable to start pproc");
return -ENOMEM;
}
// Create JPEG session
mJpegJob = queueDeferredWork(CMD_DEF_CREATE_JPEG_SESSION,
args);
if (mJpegJob == 0) {
LOGE("Failed to queue CREATE_JPEG_SESSION");
return -ENOMEM;
}
// start catpure channel
rc = m_channels[QCAMERA_CH_TYPE_CAPTURE]->start();
if (rc != NO_ERROR) {
LOGE("cannot start capture channel");
if (NO_ERROR != waitDeferredWork(mReprocJob)) {
LOGE("Reprocess Deferred work failed");
return UNKNOWN_ERROR;
}
if (NO_ERROR != waitDeferredWork(mJpegJob)) {
LOGE("Jpeg Deferred work failed");
return UNKNOWN_ERROR;
}
delChannel(QCAMERA_CH_TYPE_CAPTURE);
return rc;
}
QCameraPicChannel *pCapChannel =
(QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_CAPTURE];
if (NULL != pCapChannel) {
if (mParameters.isUbiFocusEnabled() ||
mParameters.isUbiRefocus() ||
mParameters.isChromaFlashEnabled()) {
rc = startAdvancedCapture(pCapChannel);
if (rc != NO_ERROR) {
LOGE("cannot start advanced capture");
return rc;
}
}
}
if ( mLongshotEnabled ) {
rc = longShot();
if (NO_ERROR != rc) {
if (NO_ERROR != waitDeferredWork(mReprocJob)) {
LOGE("Reprocess Deferred work failed");
return UNKNOWN_ERROR;
}
if (NO_ERROR != waitDeferredWork(mJpegJob)) {
LOGE("Jpeg Deferred work failed");
return UNKNOWN_ERROR;
}
delChannel(QCAMERA_CH_TYPE_CAPTURE);
return rc;
}
}
} else {
LOGE("cannot add capture channel");
delChannel(QCAMERA_CH_TYPE_CAPTURE);
return rc;
}
} else {
// Stop Preview before taking NZSL snapshot
stopPreview();
rc = mParameters.updateRAW(gCamCapability[mCameraId]->raw_dim[0]);
if (NO_ERROR != rc) {
LOGE("Raw dimension update failed %d", rc);
return rc;
}
rc = declareSnapshotStreams();
if (NO_ERROR != rc) {
LOGE("RAW stream info configuration failed %d", rc);
return rc;
}
rc = addChannel(QCAMERA_CH_TYPE_RAW);
if (rc == NO_ERROR) {
// start postprocessor
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Reprocess Deferred work failed");
return UNKNOWN_ERROR;
}
rc = m_postprocessor.start(m_channels[QCAMERA_CH_TYPE_RAW]);
if (rc != NO_ERROR) {
LOGE("cannot start postprocessor");
delChannel(QCAMERA_CH_TYPE_RAW);
return rc;
}
rc = startChannel(QCAMERA_CH_TYPE_RAW);
if (rc != NO_ERROR) {
LOGE("cannot start raw channel");
m_postprocessor.stop();
delChannel(QCAMERA_CH_TYPE_RAW);
return rc;
}
} else {
LOGE("cannot add raw channel");
return rc;
}
}
}
//When take picture, stop sending preview callbacks to APP
m_stateMachine.setPreviewCallbackNeeded(false);
LOGI("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : configureOnlineRotation
*
* DESCRIPTION: Configure backend with expected rotation for snapshot stream
*
* PARAMETERS :
* @ch : Channel containing a snapshot stream
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::configureOnlineRotation(QCameraChannel &ch)
{
int rc = NO_ERROR;
uint32_t streamId = 0;
QCameraStream *pStream = NULL;
for (uint8_t i = 0; i < ch.getNumOfStreams(); i++) {
QCameraStream *stream = ch.getStreamByIndex(i);
if ((NULL != stream) &&
((CAM_STREAM_TYPE_SNAPSHOT == stream->getMyType())
|| (CAM_STREAM_TYPE_RAW == stream->getMyType()))) {
pStream = stream;
break;
}
}
if (NULL == pStream) {
LOGE("No snapshot stream found!");
return BAD_VALUE;
}
streamId = pStream->getMyServerID();
// Update online rotation configuration
rc = mParameters.addOnlineRotation(mParameters.getJpegRotation(), streamId,
mParameters.getDeviceRotation());
if (rc != NO_ERROR) {
LOGE("addOnlineRotation failed %d", rc);
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : declareSnapshotStreams
*
* DESCRIPTION: Configure backend with expected snapshot streams
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::declareSnapshotStreams()
{
int rc = NO_ERROR;
// Update stream info configuration
rc = mParameters.setStreamConfigure(true, mLongshotEnabled, false);
if (rc != NO_ERROR) {
LOGE("setStreamConfigure failed %d", rc);
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : longShot
*
* DESCRIPTION: Queue one more ZSL frame
* in the longshot pipe.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::longShot()
{
int32_t rc = NO_ERROR;
uint8_t numSnapshots = mParameters.getNumOfSnapshots();
QCameraPicChannel *pChannel = NULL;
if (mParameters.isZSLMode()) {
pChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
} else {
pChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_CAPTURE];
}
if (NULL != pChannel) {
mm_camera_req_buf_t buf;
memset(&buf, 0x0, sizeof(buf));
buf.type = MM_CAMERA_REQ_SUPER_BUF;
buf.num_buf_requested = numSnapshots;
rc = pChannel->takePicture(&buf);
} else {
LOGE("Capture channel not initialized!");
rc = NO_INIT;
goto end;
}
end:
return rc;
}
/*===========================================================================
* FUNCTION : stopCaptureChannel
*
* DESCRIPTION: Stops capture channel
*
* PARAMETERS :
* @destroy : Set to true to stop and delete camera channel.
* Set to false to only stop capture channel.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::stopCaptureChannel(bool destroy)
{
int rc = NO_ERROR;
if (mParameters.isJpegPictureFormat() ||
mParameters.isNV16PictureFormat() ||
mParameters.isNV21PictureFormat()) {
rc = stopChannel(QCAMERA_CH_TYPE_CAPTURE);
if (destroy && (NO_ERROR == rc)) {
// Destroy camera channel but dont release context
waitDeferredWork(mJpegJob);
rc = delChannel(QCAMERA_CH_TYPE_CAPTURE, false);
}
}
return rc;
}
/*===========================================================================
* FUNCTION : cancelPicture
*
* DESCRIPTION: cancel picture impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::cancelPicture()
{
waitDeferredWork(mReprocJob);
waitDeferredWork(mJpegJob);
//stop post processor
m_postprocessor.stop();
unconfigureAdvancedCapture();
LOGH("Enable display frames again");
m_stateMachine.setDisplayFrame(TRUE);
if (!mLongshotEnabled) {
m_perfLock.lock_rel();
}
if (mParameters.isZSLMode()) {
QCameraPicChannel *pPicChannel = NULL;
if (mParameters.getofflineRAW()) {
pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_RAW];
} else {
pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
}
if (NULL != pPicChannel) {
pPicChannel->cancelPicture();
stopRAWChannel();
stopAdvancedCapture(pPicChannel);
}
} else {
// normal capture case
if (mParameters.isJpegPictureFormat() ||
mParameters.isNV16PictureFormat() ||
mParameters.isNV21PictureFormat()) {
stopChannel(QCAMERA_CH_TYPE_CAPTURE);
delChannel(QCAMERA_CH_TYPE_CAPTURE);
} else {
stopChannel(QCAMERA_CH_TYPE_RAW);
delChannel(QCAMERA_CH_TYPE_RAW);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : captureDone
*
* DESCRIPTION: Function called when the capture is completed before encoding
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::captureDone()
{
qcamera_sm_internal_evt_payload_t *payload =
(qcamera_sm_internal_evt_payload_t *)
malloc(sizeof(qcamera_sm_internal_evt_payload_t));
if (NULL != payload) {
memset(payload, 0, sizeof(qcamera_sm_internal_evt_payload_t));
payload->evt_type = QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE;
int32_t rc = processEvt(QCAMERA_SM_EVT_EVT_INTERNAL, payload);
if (rc != NO_ERROR) {
LOGE("processEvt ZSL capture done failed");
free(payload);
payload = NULL;
}
} else {
LOGE("No memory for ZSL capture done event");
}
}
/*===========================================================================
* FUNCTION : Live_Snapshot_thread
*
* DESCRIPTION: Seperate thread for taking live snapshot during recording
*
* PARAMETERS : @data - pointer to QCamera2HardwareInterface class object
*
* RETURN : none
*==========================================================================*/
void* Live_Snapshot_thread (void* data)
{
QCamera2HardwareInterface *hw = reinterpret_cast<QCamera2HardwareInterface *>(data);
if (!hw) {
LOGE("take_picture_thread: NULL camera device");
return (void *)BAD_VALUE;
}
hw->takeLiveSnapshot_internal();
return (void* )NULL;
}
/*===========================================================================
* FUNCTION : Int_Pic_thread
*
* DESCRIPTION: Seperate thread for taking snapshot triggered by camera backend
*
* PARAMETERS : @data - pointer to QCamera2HardwareInterface class object
*
* RETURN : none
*==========================================================================*/
void* Int_Pic_thread (void* data)
{
int rc = NO_ERROR;
QCamera2HardwareInterface *hw = reinterpret_cast<QCamera2HardwareInterface *>(data);
if (!hw) {
LOGE("take_picture_thread: NULL camera device");
return (void *)BAD_VALUE;
}
bool JpegMemOpt = false;
char raw_format[PROPERTY_VALUE_MAX];
memset(raw_format, 0, sizeof(raw_format));
rc = hw->takeBackendPic_internal(&JpegMemOpt, &raw_format[0]);
if (rc == NO_ERROR) {
hw->checkIntPicPending(JpegMemOpt, &raw_format[0]);
} else {
//Snapshot attempt not successful, we need to do cleanup here
hw->clearIntPendingEvents();
}
return (void* )NULL;
}
/*===========================================================================
* FUNCTION : takeLiveSnapshot
*
* DESCRIPTION: take live snapshot during recording
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::takeLiveSnapshot()
{
int rc = NO_ERROR;
rc= pthread_create(&mLiveSnapshotThread, NULL, Live_Snapshot_thread, (void *) this);
if (!rc) {
pthread_setname_np(mLiveSnapshotThread, "CAM_liveSnap");
}
return rc;
}
/*===========================================================================
* FUNCTION : takePictureInternal
*
* DESCRIPTION: take snapshot triggered by backend
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::takePictureInternal()
{
int rc = NO_ERROR;
rc= pthread_create(&mIntPicThread, NULL, Int_Pic_thread, (void *) this);
if (!rc) {
pthread_setname_np(mIntPicThread, "CAM_IntPic");
}
return rc;
}
/*===========================================================================
* FUNCTION : checkIntPicPending
*
* DESCRIPTION: timed wait for jpeg completion event, and send
* back completion event to backend
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::checkIntPicPending(bool JpegMemOpt, char *raw_format)
{
bool bSendToBackend = true;
cam_int_evt_params_t params;
int rc = NO_ERROR;
struct timespec ts;
struct timeval tp;
gettimeofday(&tp, NULL);
ts.tv_sec = tp.tv_sec + 5;
ts.tv_nsec = tp.tv_usec * 1000;
if (true == m_bIntJpegEvtPending ||
(true == m_bIntRawEvtPending)) {
//Waiting in HAL for snapshot taken notification
pthread_mutex_lock(&m_int_lock);
rc = pthread_cond_timedwait(&m_int_cond, &m_int_lock, &ts);
if (ETIMEDOUT == rc || 0x0 == m_BackendFileName[0]) {
//Hit a timeout, or some spurious activity
bSendToBackend = false;
}
if (true == m_bIntJpegEvtPending) {
params.event_type = 0;
mParameters.getStreamFormat(CAM_STREAM_TYPE_SNAPSHOT, params.picture_format);
} else if (true == m_bIntRawEvtPending) {
params.event_type = 1;
mParameters.getStreamFormat(CAM_STREAM_TYPE_RAW, params.picture_format);
}
pthread_mutex_unlock(&m_int_lock);
if (true == m_bIntJpegEvtPending) {
//Attempting to restart preview after taking JPEG snapshot
lockAPI();
rc = processAPI(QCAMERA_SM_EVT_SNAPSHOT_DONE, NULL);
unlockAPI();
m_postprocessor.setJpegMemOpt(JpegMemOpt);
} else if (true == m_bIntRawEvtPending) {
//Attempting to restart preview after taking RAW snapshot
stopChannel(QCAMERA_CH_TYPE_RAW);
delChannel(QCAMERA_CH_TYPE_RAW);
//restoring the old raw format
property_set("persist.camera.raw.format", raw_format);
}
if (true == bSendToBackend) {
//send event back to server with the file path
params.dim = m_postprocessor.m_dst_dim;
memcpy(&params.path[0], &m_BackendFileName[0], QCAMERA_MAX_FILEPATH_LENGTH);
memset(&m_BackendFileName[0], 0x0, QCAMERA_MAX_FILEPATH_LENGTH);
params.size = mBackendFileSize;
rc = mParameters.setIntEvent(params);
}
clearIntPendingEvents();
}
return;
}
/*===========================================================================
* FUNCTION : takeBackendPic_internal
*
* DESCRIPTION: take snapshot triggered by backend
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::takeBackendPic_internal(bool *JpegMemOpt, char *raw_format)
{
int rc = NO_ERROR;
qcamera_api_result_t apiResult;
lockAPI();
//Set rotation value from user settings as Jpeg rotation
//to configure back-end modules.
mParameters.setJpegRotation(mParameters.getRotation());
setRetroPicture(0);
/* Prepare snapshot in case LED needs to be flashed */
if (mFlashNeeded == 1 || mParameters.isChromaFlashEnabled()) {
// Start Preparing for normal Frames
LOGH("Start Prepare Snapshot");
/* Prepare snapshot in case LED needs to be flashed */
rc = processAPI(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, NULL);
if (rc == NO_ERROR) {
waitAPIResult(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, &apiResult);
rc = apiResult.status;
}
LOGH("Prep Snapshot done rc = %d", rc);
mPrepSnapRun = true;
}
unlockAPI();
if (true == m_bIntJpegEvtPending) {
//Attempting to take JPEG snapshot
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Init PProc Deferred work failed");
return UNKNOWN_ERROR;
}
*JpegMemOpt = m_postprocessor.getJpegMemOpt();
m_postprocessor.setJpegMemOpt(false);
/* capture */
lockAPI();
LOGH("Capturing internal snapshot");
rc = processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
if (rc == NO_ERROR) {
waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
rc = apiResult.status;
}
unlockAPI();
} else if (true == m_bIntRawEvtPending) {
//Attempting to take RAW snapshot
(void)JpegMemOpt;
stopPreview();
//getting the existing raw format type
property_get("persist.camera.raw.format", raw_format, "17");
//setting it to a default know value for this task
property_set("persist.camera.raw.format", "18");
rc = addChannel(QCAMERA_CH_TYPE_RAW);
if (rc == NO_ERROR) {
// start postprocessor
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Init PProc Deferred work failed");
return UNKNOWN_ERROR;
}
rc = m_postprocessor.start(m_channels[QCAMERA_CH_TYPE_RAW]);
if (rc != NO_ERROR) {
LOGE("cannot start postprocessor");
delChannel(QCAMERA_CH_TYPE_RAW);
return rc;
}
rc = startChannel(QCAMERA_CH_TYPE_RAW);
if (rc != NO_ERROR) {
LOGE("cannot start raw channel");
m_postprocessor.stop();
delChannel(QCAMERA_CH_TYPE_RAW);
return rc;
}
} else {
LOGE("cannot add raw channel");
return rc;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : clearIntPendingEvents
*
* DESCRIPTION: clear internal pending events pertaining to backend
* snapshot requests
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
void QCamera2HardwareInterface::clearIntPendingEvents()
{
int rc = NO_ERROR;
if (true == m_bIntRawEvtPending) {
preparePreview();
startPreview();
}
if (true == m_bIntJpegEvtPending) {
if (false == mParameters.isZSLMode()) {
lockAPI();
rc = processAPI(QCAMERA_SM_EVT_START_PREVIEW, NULL);
unlockAPI();
}
}
pthread_mutex_lock(&m_int_lock);
if (true == m_bIntJpegEvtPending) {
m_bIntJpegEvtPending = false;
} else if (true == m_bIntRawEvtPending) {
m_bIntRawEvtPending = false;
}
pthread_mutex_unlock(&m_int_lock);
return;
}
/*===========================================================================
* FUNCTION : takeLiveSnapshot_internal
*
* DESCRIPTION: take live snapshot during recording
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::takeLiveSnapshot_internal()
{
int rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
//Set rotation value from user settings as Jpeg rotation
//to configure back-end modules.
mParameters.setJpegRotation(mParameters.getRotation());
// Configure advanced capture
rc = configureAdvancedCapture();
if (rc != NO_ERROR) {
LOGE("Unsupported capture call");
goto end;
}
if (isLowPowerMode()) {
pChannel = m_channels[QCAMERA_CH_TYPE_VIDEO];
} else {
pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
}
if (NULL == pChannel) {
LOGE("Snapshot/Video channel not initialized");
rc = NO_INIT;
goto end;
}
// start post processor
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Init PProc Deferred work failed");
return UNKNOWN_ERROR;
}
rc = m_postprocessor.start(pChannel);
if (NO_ERROR != rc) {
LOGE("Post-processor start failed %d", rc);
goto end;
}
if (isLowPowerMode()) {
mm_camera_req_buf_t buf;
memset(&buf, 0x0, sizeof(buf));
buf.type = MM_CAMERA_REQ_SUPER_BUF;
buf.num_buf_requested = 1;
rc = ((QCameraVideoChannel*)pChannel)->takePicture(&buf);
goto end;
}
//Disable reprocess for 4K liveshot case
if (!mParameters.is4k2kVideoResolution()) {
rc = configureOnlineRotation(*m_channels[QCAMERA_CH_TYPE_SNAPSHOT]);
if (rc != NO_ERROR) {
LOGE("online rotation failed");
m_postprocessor.stop();
return rc;
}
}
if ((NULL != pChannel) && (mParameters.isTNRSnapshotEnabled())) {
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < pChannel->getNumOfStreams(); i++ ) {
pStream = pChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_SNAPSHOT == pStream->getMyType())) {
break;
}
}
if (pStream != NULL) {
LOGD("REQUEST_FRAMES event for TNR snapshot");
cam_stream_parm_buffer_t param;
memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
param.type = CAM_STREAM_PARAM_TYPE_REQUEST_FRAMES;
param.frameRequest.enableStream = 1;
rc = pStream->setParameter(param);
if (rc != NO_ERROR) {
LOGE("Stream Event REQUEST_FRAMES failed");
}
goto end;
}
}
// start snapshot channel
if ((rc == NO_ERROR) && (NULL != pChannel)) {
// Do not link metadata stream for 4K2k resolution
// as CPP processing would be done on snapshot stream and not
// reprocess stream
if (!mParameters.is4k2kVideoResolution()) {
// Find and try to link a metadata stream from preview channel
QCameraChannel *pMetaChannel = NULL;
QCameraStream *pMetaStream = NULL;
if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
uint32_t streamNum = pMetaChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < streamNum ; i++ ) {
pStream = pMetaChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_METADATA == pStream->getMyType())) {
pMetaStream = pStream;
break;
}
}
}
if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
rc = pChannel->linkStream(pMetaChannel, pMetaStream);
if (NO_ERROR != rc) {
LOGE("Metadata stream link failed %d", rc);
}
}
}
rc = pChannel->start();
}
end:
if (rc != NO_ERROR) {
rc = processAPI(QCAMERA_SM_EVT_CANCEL_PICTURE, NULL);
rc = sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
}
return rc;
}
/*===========================================================================
* FUNCTION : cancelLiveSnapshot
*
* DESCRIPTION: cancel current live snapshot request
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::cancelLiveSnapshot()
{
int rc = NO_ERROR;
unconfigureAdvancedCapture();
LOGH("Enable display frames again");
m_stateMachine.setDisplayFrame(TRUE);
if (!mLongshotEnabled) {
m_perfLock.lock_rel();
}
if (mLiveSnapshotThread != 0) {
pthread_join(mLiveSnapshotThread,NULL);
mLiveSnapshotThread = 0;
}
//stop post processor
m_postprocessor.stop();
// stop snapshot channel
if (!mParameters.isTNRSnapshotEnabled()) {
rc = stopChannel(QCAMERA_CH_TYPE_SNAPSHOT);
} else {
QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
if (NULL != pChannel) {
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < pChannel->getNumOfStreams(); i++ ) {
pStream = pChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_SNAPSHOT ==
pStream->getMyType())) {
break;
}
}
if (pStream != NULL) {
LOGD("REQUEST_FRAMES event for TNR snapshot");
cam_stream_parm_buffer_t param;
memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
param.type = CAM_STREAM_PARAM_TYPE_REQUEST_FRAMES;
param.frameRequest.enableStream = 0;
rc = pStream->setParameter(param);
if (rc != NO_ERROR) {
LOGE("Stream Event REQUEST_FRAMES failed");
}
}
}
}
return rc;
}
/*===========================================================================
* FUNCTION : putParameters
*
* DESCRIPTION: put parameters string impl
*
* PARAMETERS :
* @parms : parameters string to be released
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::putParameters(char *parms)
{
free(parms);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : sendCommand
*
* DESCRIPTION: send command impl
*
* PARAMETERS :
* @command : command to be executed
* @arg1 : optional argument 1
* @arg2 : optional argument 2
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::sendCommand(int32_t command,
int32_t &arg1, int32_t &arg2)
{
int rc = NO_ERROR;
switch (command) {
#ifndef VANILLA_HAL
case CAMERA_CMD_LONGSHOT_ON:
m_perfLock.lock_acq();
arg1 = arg2 = 0;
// Longshot can only be enabled when image capture
// is not active.
if ( !m_stateMachine.isCaptureRunning() ) {
LOGI("Longshot Enabled");
mLongshotEnabled = true;
rc = mParameters.setLongshotEnable(mLongshotEnabled);
// Due to recent buffer count optimizations
// ZSL might run with considerably less buffers
// when not in longshot mode. Preview needs to
// restart in this case.
if (isZSLMode() && m_stateMachine.isPreviewRunning()) {
QCameraChannel *pChannel = NULL;
QCameraStream *pSnapStream = NULL;
pChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
if (NULL != pChannel) {
QCameraStream *pStream = NULL;
for (uint32_t i = 0; i < pChannel->getNumOfStreams(); i++) {
pStream = pChannel->getStreamByIndex(i);
if (pStream != NULL) {
if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
pSnapStream = pStream;
break;
}
}
}
if (NULL != pSnapStream) {
uint8_t required = 0;
required = getBufNumRequired(CAM_STREAM_TYPE_SNAPSHOT);
if (pSnapStream->getBufferCount() < required) {
// We restart here, to reset the FPS and no
// of buffers as per the requirement of longshot usecase.
arg1 = QCAMERA_SM_EVT_RESTART_PERVIEW;
if (getRelatedCamSyncInfo()->sync_control ==
CAM_SYNC_RELATED_SENSORS_ON) {
arg2 = QCAMERA_SM_EVT_DELAYED_RESTART;
}
}
}
}
}
//
mPrepSnapRun = false;
mCACDoneReceived = FALSE;
} else {
rc = NO_INIT;
}
break;
case CAMERA_CMD_LONGSHOT_OFF:
m_perfLock.lock_rel();
if ( mLongshotEnabled && m_stateMachine.isCaptureRunning() ) {
cancelPicture();
processEvt(QCAMERA_SM_EVT_SNAPSHOT_DONE, NULL);
QCameraChannel *pZSLChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
if (isZSLMode() && (NULL != pZSLChannel) && mPrepSnapRun) {
mCameraHandle->ops->stop_zsl_snapshot(
mCameraHandle->camera_handle,
pZSLChannel->getMyHandle());
}
}
mPrepSnapRun = false;
LOGI("Longshot Disabled");
mLongshotEnabled = false;
rc = mParameters.setLongshotEnable(mLongshotEnabled);
mCACDoneReceived = FALSE;
break;
case CAMERA_CMD_HISTOGRAM_ON:
case CAMERA_CMD_HISTOGRAM_OFF:
rc = setHistogram(command == CAMERA_CMD_HISTOGRAM_ON? true : false);
LOGH("Histogram -> %s",
mParameters.isHistogramEnabled() ? "Enabled" : "Disabled");
break;
#endif
case CAMERA_CMD_START_FACE_DETECTION:
case CAMERA_CMD_STOP_FACE_DETECTION:
mParameters.setFaceDetectionOption(command == CAMERA_CMD_START_FACE_DETECTION? true : false);
rc = setFaceDetection(command == CAMERA_CMD_START_FACE_DETECTION? true : false);
LOGH("FaceDetection -> %s",
mParameters.isFaceDetectionEnabled() ? "Enabled" : "Disabled");
break;
#ifndef VANILLA_HAL
case CAMERA_CMD_HISTOGRAM_SEND_DATA:
#endif
default:
rc = NO_ERROR;
break;
}
return rc;
}
/*===========================================================================
* FUNCTION : registerFaceImage
*
* DESCRIPTION: register face image impl
*
* PARAMETERS :
* @img_ptr : ptr to image buffer
* @config : ptr to config struct about input image info
* @faceID : [OUT] face ID to uniquely identifiy the registered face image
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::registerFaceImage(void *img_ptr,
cam_pp_offline_src_config_t *config,
int32_t &faceID)
{
int rc = NO_ERROR;
faceID = -1;
if (img_ptr == NULL || config == NULL) {
LOGE("img_ptr or config is NULL");
return BAD_VALUE;
}
// allocate ion memory for source image
QCameraHeapMemory *imgBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
if (imgBuf == NULL) {
LOGE("Unable to new heap memory obj for image buf");
return NO_MEMORY;
}
rc = imgBuf->allocate(1, config->input_buf_planes.plane_info.frame_len, NON_SECURE);
if (rc < 0) {
LOGE("Unable to allocate heap memory for image buf");
delete imgBuf;
return NO_MEMORY;
}
void *pBufPtr = imgBuf->getPtr(0);
if (pBufPtr == NULL) {
LOGE("image buf is NULL");
imgBuf->deallocate();
delete imgBuf;
return NO_MEMORY;
}
memcpy(pBufPtr, img_ptr, config->input_buf_planes.plane_info.frame_len);
cam_pp_feature_config_t pp_feature;
memset(&pp_feature, 0, sizeof(cam_pp_feature_config_t));
pp_feature.feature_mask = CAM_QCOM_FEATURE_REGISTER_FACE;
QCameraReprocessChannel *pChannel =
addOfflineReprocChannel(*config, pp_feature, NULL, NULL);
if (pChannel == NULL) {
LOGE("fail to add offline reprocess channel");
imgBuf->deallocate();
delete imgBuf;
return UNKNOWN_ERROR;
}
rc = pChannel->start();
if (rc != NO_ERROR) {
LOGE("Cannot start reprocess channel");
imgBuf->deallocate();
delete imgBuf;
delete pChannel;
return rc;
}
ssize_t bufSize = imgBuf->getSize(0);
if (BAD_INDEX != bufSize) {
rc = pChannel->doReprocess(imgBuf->getFd(0), (size_t)bufSize, faceID);
} else {
LOGE("Failed to retrieve buffer size (bad index)");
return UNKNOWN_ERROR;
}
// done with register face image, free imgbuf and delete reprocess channel
imgBuf->deallocate();
delete imgBuf;
imgBuf = NULL;
pChannel->stop();
delete pChannel;
pChannel = NULL;
return rc;
}
/*===========================================================================
* FUNCTION : release
*
* DESCRIPTION: release camera resource impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::release()
{
// stop and delete all channels
for (int i = 0; i <QCAMERA_CH_TYPE_MAX ; i++) {
if (m_channels[i] != NULL) {
stopChannel((qcamera_ch_type_enum_t)i);
delChannel((qcamera_ch_type_enum_t)i);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : dump
*
* DESCRIPTION: camera status dump impl
*
* PARAMETERS :
* @fd : fd for the buffer to be dumped with camera status
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::dump(int fd)
{
dprintf(fd, "\n Camera HAL information Begin \n");
dprintf(fd, "Camera ID: %d \n", mCameraId);
dprintf(fd, "StoreMetaDataInFrame: %d \n", mStoreMetaDataInFrame);
dprintf(fd, "\n Configuration: %s", mParameters.dump().string());
dprintf(fd, "\n State Information: %s", m_stateMachine.dump().string());
dprintf(fd, "\n Camera HAL information End \n");
/* send UPDATE_DEBUG_LEVEL to the backend so that they can read the
debug level property */
mParameters.updateDebugLevel();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : processAPI
*
* DESCRIPTION: process API calls from upper layer
*
* PARAMETERS :
* @api : API to be processed
* @api_payload : ptr to API payload if any
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::processAPI(qcamera_sm_evt_enum_t api, void *api_payload)
{
int ret = DEAD_OBJECT;
if (m_smThreadActive) {
ret = m_stateMachine.procAPI(api, api_payload);
}
return ret;
}
/*===========================================================================
* FUNCTION : processEvt
*
* DESCRIPTION: process Evt from backend via mm-camera-interface
*
* PARAMETERS :
* @evt : event type to be processed
* @evt_payload : ptr to event payload if any
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::processEvt(qcamera_sm_evt_enum_t evt, void *evt_payload)
{
return m_stateMachine.procEvt(evt, evt_payload);
}
/*===========================================================================
* FUNCTION : processSyncEvt
*
* DESCRIPTION: process synchronous Evt from backend
*
* PARAMETERS :
* @evt : event type to be processed
* @evt_payload : ptr to event payload if any
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::processSyncEvt(qcamera_sm_evt_enum_t evt, void *evt_payload)
{
int rc = NO_ERROR;
pthread_mutex_lock(&m_evtLock);
rc = processEvt(evt, evt_payload);
if (rc == NO_ERROR) {
memset(&m_evtResult, 0, sizeof(qcamera_api_result_t));
while (m_evtResult.request_api != evt) {
pthread_cond_wait(&m_evtCond, &m_evtLock);
}
rc = m_evtResult.status;
}
pthread_mutex_unlock(&m_evtLock);
return rc;
}
/*===========================================================================
* FUNCTION : evtHandle
*
* DESCRIPTION: Function registerd to mm-camera-interface to handle backend events
*
* PARAMETERS :
* @camera_handle : event type to be processed
* @evt : ptr to event
* @user_data : user data ptr
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::camEvtHandle(uint32_t /*camera_handle*/,
mm_camera_event_t *evt,
void *user_data)
{
QCamera2HardwareInterface *obj = (QCamera2HardwareInterface *)user_data;
if (obj && evt) {
mm_camera_event_t *payload =
(mm_camera_event_t *)malloc(sizeof(mm_camera_event_t));
if (NULL != payload) {
*payload = *evt;
//peek into the event, if this is an eztune event from server,
//then we don't need to post it to the SM Qs, we shud directly
//spawn a thread and get the job done (jpeg or raw snapshot)
switch (payload->server_event_type) {
case CAM_EVENT_TYPE_INT_TAKE_JPEG:
//Received JPEG trigger from eztune
if (false == obj->m_bIntJpegEvtPending) {
pthread_mutex_lock(&obj->m_int_lock);
obj->m_bIntJpegEvtPending = true;
pthread_mutex_unlock(&obj->m_int_lock);
obj->takePictureInternal();
}
free(payload);
break;
case CAM_EVENT_TYPE_INT_TAKE_RAW:
//Received RAW trigger from eztune
if (false == obj->m_bIntRawEvtPending) {
pthread_mutex_lock(&obj->m_int_lock);
obj->m_bIntRawEvtPending = true;
pthread_mutex_unlock(&obj->m_int_lock);
obj->takePictureInternal();
}
free(payload);
break;
case CAM_EVENT_TYPE_DAEMON_DIED:
{
Mutex::Autolock l(obj->mDefLock);
obj->mDefCond.broadcast();
LOGH("broadcast mDefCond signal\n");
}
default:
obj->processEvt(QCAMERA_SM_EVT_EVT_NOTIFY, payload);
break;
}
}
} else {
LOGE("NULL user_data");
}
}
/*===========================================================================
* FUNCTION : jpegEvtHandle
*
* DESCRIPTION: Function registerd to mm-jpeg-interface to handle jpeg events
*
* PARAMETERS :
* @status : status of jpeg job
* @client_hdl: jpeg client handle
* @jobId : jpeg job Id
* @p_ouput : ptr to jpeg output result struct
* @userdata : user data ptr
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::jpegEvtHandle(jpeg_job_status_t status,
uint32_t /*client_hdl*/,
uint32_t jobId,
mm_jpeg_output_t *p_output,
void *userdata)
{
QCamera2HardwareInterface *obj = (QCamera2HardwareInterface *)userdata;
if (obj) {
qcamera_jpeg_evt_payload_t *payload =
(qcamera_jpeg_evt_payload_t *)malloc(sizeof(qcamera_jpeg_evt_payload_t));
if (NULL != payload) {
memset(payload, 0, sizeof(qcamera_jpeg_evt_payload_t));
payload->status = status;
payload->jobId = jobId;
if (p_output != NULL) {
payload->out_data = *p_output;
}
obj->processEvt(QCAMERA_SM_EVT_JPEG_EVT_NOTIFY, payload);
}
} else {
LOGE("NULL user_data");
}
}
/*===========================================================================
* FUNCTION : thermalEvtHandle
*
* DESCRIPTION: routine to handle thermal event notification
*
* PARAMETERS :
* @level : thermal level
* @userdata : userdata passed in during registration
* @data : opaque data from thermal client
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::thermalEvtHandle(
qcamera_thermal_level_enum_t *level, void *userdata, void *data)
{
if (!mCameraOpened) {
LOGH("Camera is not opened, no need to handle thermal evt");
return NO_ERROR;
}
// Make sure thermal events are logged
LOGH("level = %d, userdata = %p, data = %p",
*level, userdata, data);
//We don't need to lockAPI, waitAPI here. QCAMERA_SM_EVT_THERMAL_NOTIFY
// becomes an aync call. This also means we can only pass payload
// by value, not by address.
return processAPI(QCAMERA_SM_EVT_THERMAL_NOTIFY, (void *)level);
}
/*===========================================================================
* FUNCTION : sendEvtNotify
*
* DESCRIPTION: send event notify to notify thread
*
* PARAMETERS :
* @msg_type: msg type to be sent
* @ext1 : optional extension1
* @ext2 : optional extension2
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::sendEvtNotify(int32_t msg_type,
int32_t ext1,
int32_t ext2)
{
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
cbArg.msg_type = msg_type;
cbArg.ext1 = ext1;
cbArg.ext2 = ext2;
return m_cbNotifier.notifyCallback(cbArg);
}
/*===========================================================================
* FUNCTION : processAEInfo
*
* DESCRIPTION: process AE updates
*
* PARAMETERS :
* @ae_params: current AE parameters
*
* RETURN : None
*==========================================================================*/
int32_t QCamera2HardwareInterface::processAEInfo(cam_3a_params_t &ae_params)
{
mParameters.updateAEInfo(ae_params);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : processFocusPositionInfo
*
* DESCRIPTION: process AF updates
*
* PARAMETERS :
* @cur_pos_info: current lens position
*
* RETURN : None
*==========================================================================*/
int32_t QCamera2HardwareInterface::processFocusPositionInfo(cam_focus_pos_info_t &cur_pos_info)
{
mParameters.updateCurrentFocusPosition(cur_pos_info);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : processAutoFocusEvent
*
* DESCRIPTION: process auto focus event
*
* PARAMETERS :
* @focus_data: struct containing auto focus result info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processAutoFocusEvent(cam_auto_focus_data_t &focus_data)
{
int32_t ret = NO_ERROR;
LOGH("E");
if (getRelatedCamSyncInfo()->mode == CAM_MODE_SECONDARY) {
// Ignore focus updates
LOGH("X Secondary Camera, no need to process!! ");
return ret;
}
cam_focus_mode_type focusMode = mParameters.getFocusMode();
LOGH("[AF_DBG] focusMode=%d, focusState=%d",
focusMode, focus_data.focus_state);
switch (focusMode) {
case CAM_FOCUS_MODE_AUTO:
case CAM_FOCUS_MODE_MACRO:
// ignore AF event if AF was already cancelled meanwhile
if (!mActiveAF) {
break;
}
// If the HAL focus mode is different from AF INFINITY focus mode, send event to app
if ((focus_data.focus_mode == CAM_FOCUS_MODE_INFINITY) &&
(focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
ret = sendEvtNotify(CAMERA_MSG_FOCUS, true, 0);
mActiveAF = false; // reset the mActiveAF in this special case
break;
}
//while transitioning from CAF->Auto/Macro, we might receive CAF related
//events (PASSIVE_*) due to timing. Ignore such events if any.
if ((focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN) ||
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED)) {
break;
}
//This is just an intermediate update to HAL indicating focus is in progress. No need
//to send this event to app. Same applies to INACTIVE state as well.
if ((focus_data.focus_state == CAM_AF_STATE_ACTIVE_SCAN) ||
(focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
break;
}
// update focus distance
mParameters.updateFocusDistances(&focus_data.focus_dist);
//flush any old snapshot frames in ZSL Q which are not focused.
if ((CAM_AF_STATE_FOCUSED_LOCKED == focus_data.focus_state) &&
mParameters.isZSLMode()) {
QCameraPicChannel *pZSLChannel =
(QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
if (NULL != pZSLChannel) {
//flush the zsl-buffer
uint32_t flush_frame_idx = focus_data.focused_frame_idx;
LOGD("flush the zsl-buffer before frame = %u.", flush_frame_idx);
pZSLChannel->flushSuperbuffer(flush_frame_idx);
}
}
//send event to app finally
LOGI("Send AF DOne event to app");
ret = sendEvtNotify(CAMERA_MSG_FOCUS,
(focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED), 0);
break;
case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
// If the HAL focus mode is different from AF INFINITY focus mode, send event to app
if ((focus_data.focus_mode == CAM_FOCUS_MODE_INFINITY) &&
(focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
ret = sendEvtNotify(CAMERA_MSG_FOCUS, false, 0);
mActiveAF = false; // reset the mActiveAF in this special case
break;
}
//If AutoFocus() is triggered while in CAF mode, ignore all CAF events (PASSIVE_*) and
//process/wait for only ACTIVE_* events.
if (((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN)) && mActiveAF) {
break;
}
//These are the AF states for which we need to send notification to app in CAF mode.
//This includes both regular CAF (PASSIVE) events as well as ACTIVE events ( in case
//AF is triggered while in CAF mode)
if ((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED) ||
(focus_data.focus_state == CAM_AF_STATE_NOT_FOCUSED_LOCKED)) {
// update focus distance
mParameters.updateFocusDistances(&focus_data.focus_dist);
if ((focusMode == CAM_FOCUS_MODE_CONTINOUS_PICTURE) &&
(CAM_AF_STATE_FOCUSED_LOCKED == focus_data.focus_state) &&
mParameters.isZSLMode()) {
QCameraPicChannel *pZSLChannel =
(QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
if (NULL != pZSLChannel) {
//flush the zsl-buffer
uint32_t flush_frame_idx = focus_data.focused_frame_idx;
LOGD("flush the zsl-buffer before frame = %u.", flush_frame_idx);
pZSLChannel->flushSuperbuffer(flush_frame_idx);
}
}
if (mActiveAF) {
LOGI("Send AF Done event to app");
}
ret = sendEvtNotify(CAMERA_MSG_FOCUS,
((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
(focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED)), 0);
}
ret = sendEvtNotify(CAMERA_MSG_FOCUS_MOVE,
(focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN), 0);
break;
case CAM_FOCUS_MODE_INFINITY:
case CAM_FOCUS_MODE_FIXED:
case CAM_FOCUS_MODE_EDOF:
default:
LOGH("no ops for autofocus event in focusmode %d", focusMode);
break;
}
//Reset mActiveAF once we receive focus done event
if ((focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED) ||
(focus_data.focus_state == CAM_AF_STATE_NOT_FOCUSED_LOCKED)) {
mActiveAF = false;
}
LOGH("X");
return ret;
}
/*===========================================================================
* FUNCTION : processZoomEvent
*
* DESCRIPTION: process zoom event
*
* PARAMETERS :
* @crop_info : crop info as a result of zoom operation
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processZoomEvent(cam_crop_data_t &crop_info)
{
int32_t ret = NO_ERROR;
for (int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
if (m_channels[i] != NULL) {
ret = m_channels[i]->processZoomDone(mPreviewWindow, crop_info);
}
}
return ret;
}
/*===========================================================================
* FUNCTION : processZSLCaptureDone
*
* DESCRIPTION: process ZSL capture done events
*
* PARAMETERS : None
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processZSLCaptureDone()
{
int rc = NO_ERROR;
if (++mInputCount >= mParameters.getBurstCountForAdvancedCapture()) {
rc = unconfigureAdvancedCapture();
}
return rc;
}
/*===========================================================================
* FUNCTION : processRetroAECUnlock
*
* DESCRIPTION: process retro burst AEC unlock events
*
* PARAMETERS : None
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processRetroAECUnlock()
{
int rc = NO_ERROR;
LOGH("LED assisted AF Release AEC Lock");
rc = mParameters.setAecLock("false");
if (NO_ERROR != rc) {
LOGE("Error setting AEC lock");
return rc;
}
rc = mParameters.commitParameters();
if (NO_ERROR != rc) {
LOGE("Error during camera parameter commit");
} else {
m_bLedAfAecLock = FALSE;
}
return rc;
}
/*===========================================================================
* FUNCTION : processHDRData
*
* DESCRIPTION: process HDR scene events
*
* PARAMETERS :
* @hdr_scene : HDR scene event data
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processHDRData(cam_asd_hdr_scene_data_t hdr_scene)
{
int rc = NO_ERROR;
#ifndef VANILLA_HAL
if (hdr_scene.is_hdr_scene &&
(hdr_scene.hdr_confidence > HDR_CONFIDENCE_THRESHOLD) &&
mParameters.isAutoHDREnabled()) {
m_HDRSceneEnabled = true;
} else {
m_HDRSceneEnabled = false;
}
mParameters.setHDRSceneEnable(m_HDRSceneEnabled);
if ( msgTypeEnabled(CAMERA_MSG_META_DATA) ) {
size_t data_len = sizeof(int);
size_t buffer_len = 1 *sizeof(int) //meta type
+ 1 *sizeof(int) //data len
+ 1 *sizeof(int); //data
camera_memory_t *hdrBuffer = mGetMemory(-1,
buffer_len,
1,
mCallbackCookie);
if ( NULL == hdrBuffer ) {
LOGE("Not enough memory for auto HDR data");
return NO_MEMORY;
}
int *pHDRData = (int *)hdrBuffer->data;
if (pHDRData == NULL) {
LOGE("memory data ptr is NULL");
return UNKNOWN_ERROR;
}
pHDRData[0] = CAMERA_META_DATA_HDR;
pHDRData[1] = (int)data_len;
pHDRData[2] = m_HDRSceneEnabled;
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
cbArg.msg_type = CAMERA_MSG_META_DATA;
cbArg.data = hdrBuffer;
cbArg.user_data = hdrBuffer;
cbArg.cookie = this;
cbArg.release_cb = releaseCameraMemory;
rc = m_cbNotifier.notifyCallback(cbArg);
if (rc != NO_ERROR) {
LOGE("fail sending auto HDR notification");
hdrBuffer->release(hdrBuffer);
}
}
LOGH("hdr_scene_data: processHDRData: %d %f",
hdr_scene.is_hdr_scene,
hdr_scene.hdr_confidence);
#endif
return rc;
}
/*===========================================================================
* FUNCTION : transAwbMetaToParams
*
* DESCRIPTION: translate awb params from metadata callback to QCameraParametersIntf
*
* PARAMETERS :
* @awb_params : awb params from metadata callback
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::transAwbMetaToParams(cam_awb_params_t &awb_params)
{
mParameters.updateAWBParams(awb_params);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : processPrepSnapshotDone
*
* DESCRIPTION: process prep snapshot done event
*
* PARAMETERS :
* @prep_snapshot_state : state of prepare snapshot done. In other words,
* i.e. whether need future frames for capture.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processPrepSnapshotDoneEvent(
cam_prep_snapshot_state_t prep_snapshot_state)
{
int32_t ret = NO_ERROR;
LOGI("[KPI Perf]: Received PREPARE SANSPHOT Done event state = %d",
prep_snapshot_state);
if (m_channels[QCAMERA_CH_TYPE_ZSL] &&
prep_snapshot_state == NEED_FUTURE_FRAME) {
LOGH("already handled in mm-camera-intf, no ops here");
if (isRetroPicture()) {
mParameters.setAecLock("true");
mParameters.commitParameters();
m_bLedAfAecLock = TRUE;
}
}
return ret;
}
/*===========================================================================
* FUNCTION : processASDUpdate
*
* DESCRIPTION: process ASD update event
*
* PARAMETERS :
* @scene: selected scene mode
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processASDUpdate(cam_auto_scene_t scene)
{
size_t data_len = sizeof(cam_auto_scene_t);
size_t buffer_len = 1 *sizeof(int) //meta type
+ 1 *sizeof(int) //data len
+ data_len; //data
camera_memory_t *asdBuffer = mGetMemory(-1,
buffer_len,
1,
mCallbackCookie);
if ( NULL == asdBuffer ) {
LOGE("Not enough memory for histogram data");
return NO_MEMORY;
}
int *pASDData = (int *)asdBuffer->data;
if (pASDData == NULL) {
LOGE("memory data ptr is NULL");
return UNKNOWN_ERROR;
}
#ifndef VANILLA_HAL
pASDData[0] = CAMERA_META_DATA_ASD;
pASDData[1] = (int)data_len;
pASDData[2] = scene;
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
cbArg.msg_type = CAMERA_MSG_META_DATA;
cbArg.data = asdBuffer;
cbArg.user_data = asdBuffer;
cbArg.cookie = this;
cbArg.release_cb = releaseCameraMemory;
int32_t rc = m_cbNotifier.notifyCallback(cbArg);
if (rc != NO_ERROR) {
LOGE("fail sending notification");
asdBuffer->release(asdBuffer);
}
#endif
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : processJpegNotify
*
* DESCRIPTION: process jpeg event
*
* PARAMETERS :
* @jpeg_evt: ptr to jpeg event payload
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processJpegNotify(qcamera_jpeg_evt_payload_t *jpeg_evt)
{
return m_postprocessor.processJpegEvt(jpeg_evt);
}
/*===========================================================================
* FUNCTION : lockAPI
*
* DESCRIPTION: lock to process API
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::lockAPI()
{
pthread_mutex_lock(&m_lock);
}
/*===========================================================================
* FUNCTION : waitAPIResult
*
* DESCRIPTION: wait for API result coming back. This is a blocking call, it will
* return only cerntain API event type arrives
*
* PARAMETERS :
* @api_evt : API event type
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::waitAPIResult(qcamera_sm_evt_enum_t api_evt,
qcamera_api_result_t *apiResult)
{
LOGD("wait for API result of evt (%d)", api_evt);
int resultReceived = 0;
while (!resultReceived) {
pthread_cond_wait(&m_cond, &m_lock);
if (m_apiResultList != NULL) {
api_result_list *apiResultList = m_apiResultList;
api_result_list *apiResultListPrevious = m_apiResultList;
while (apiResultList != NULL) {
if (apiResultList->result.request_api == api_evt) {
resultReceived = 1;
*apiResult = apiResultList->result;
apiResultListPrevious->next = apiResultList->next;
if (apiResultList == m_apiResultList) {
m_apiResultList = apiResultList->next;
}
free(apiResultList);
break;
}
else {
apiResultListPrevious = apiResultList;
apiResultList = apiResultList->next;
}
}
}
}
LOGD("return (%d) from API result wait for evt (%d)",
apiResult->status, api_evt);
}
/*===========================================================================
* FUNCTION : unlockAPI
*
* DESCRIPTION: API processing is done, unlock
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::unlockAPI()
{
pthread_mutex_unlock(&m_lock);
}
/*===========================================================================
* FUNCTION : signalAPIResult
*
* DESCRIPTION: signal condition viarable that cerntain API event type arrives
*
* PARAMETERS :
* @result : API result
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::signalAPIResult(qcamera_api_result_t *result)
{
pthread_mutex_lock(&m_lock);
api_result_list *apiResult = (api_result_list *)malloc(sizeof(api_result_list));
if (apiResult == NULL) {
LOGE("ERROR: malloc for api result failed, Result will not be sent");
goto malloc_failed;
}
apiResult->result = *result;
apiResult->next = NULL;
if (m_apiResultList == NULL) m_apiResultList = apiResult;
else {
api_result_list *apiResultList = m_apiResultList;
while(apiResultList->next != NULL) apiResultList = apiResultList->next;
apiResultList->next = apiResult;
}
malloc_failed:
pthread_cond_broadcast(&m_cond);
pthread_mutex_unlock(&m_lock);
}
/*===========================================================================
* FUNCTION : signalEvtResult
*
* DESCRIPTION: signal condition variable that certain event was processed
*
* PARAMETERS :
* @result : Event result
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::signalEvtResult(qcamera_api_result_t *result)
{
pthread_mutex_lock(&m_evtLock);
m_evtResult = *result;
pthread_cond_signal(&m_evtCond);
pthread_mutex_unlock(&m_evtLock);
}
int32_t QCamera2HardwareInterface::prepareRawStream(QCameraChannel *curChannel)
{
int32_t rc = NO_ERROR;
cam_dimension_t str_dim,max_dim;
QCameraChannel *pChannel;
max_dim.width = 0;
max_dim.height = 0;
for (int j = 0; j < QCAMERA_CH_TYPE_MAX; j++) {
if (m_channels[j] != NULL) {
pChannel = m_channels[j];
for (uint8_t i = 0; i < pChannel->getNumOfStreams(); i++) {
QCameraStream *pStream = pChannel->getStreamByIndex(i);
if (pStream != NULL) {
if ((pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
|| (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
continue;
}
pStream->getFrameDimension(str_dim);
if (str_dim.width > max_dim.width) {
max_dim.width = str_dim.width;
}
if (str_dim.height > max_dim.height) {
max_dim.height = str_dim.height;
}
}
}
}
}
for (uint8_t i = 0; i < curChannel->getNumOfStreams(); i++) {
QCameraStream *pStream = curChannel->getStreamByIndex(i);
if (pStream != NULL) {
if ((pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
|| (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
continue;
}
pStream->getFrameDimension(str_dim);
if (str_dim.width > max_dim.width) {
max_dim.width = str_dim.width;
}
if (str_dim.height > max_dim.height) {
max_dim.height = str_dim.height;
}
}
}
rc = mParameters.updateRAW(max_dim);
return rc;
}
/*===========================================================================
* FUNCTION : addStreamToChannel
*
* DESCRIPTION: add a stream into a channel
*
* PARAMETERS :
* @pChannel : ptr to channel obj
* @streamType : type of stream to be added
* @streamCB : callback of stream
* @userData : user data ptr to callback
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addStreamToChannel(QCameraChannel *pChannel,
cam_stream_type_t streamType,
stream_cb_routine streamCB,
void *userData)
{
int32_t rc = NO_ERROR;
if (streamType == CAM_STREAM_TYPE_RAW) {
prepareRawStream(pChannel);
}
QCameraHeapMemory *pStreamInfo = allocateStreamInfoBuf(streamType);
if (pStreamInfo == NULL) {
LOGE("no mem for stream info buf");
return NO_MEMORY;
}
uint8_t minStreamBufNum = getBufNumRequired(streamType);
bool bDynAllocBuf = false;
if (isZSLMode() && streamType == CAM_STREAM_TYPE_SNAPSHOT) {
bDynAllocBuf = true;
}
cam_padding_info_t padding_info;
if (streamType == CAM_STREAM_TYPE_ANALYSIS) {
padding_info =
gCamCapability[mCameraId]->analysis_padding_info;
} else {
padding_info =
gCamCapability[mCameraId]->padding_info;
if (streamType == CAM_STREAM_TYPE_PREVIEW) {
padding_info.width_padding = mSurfaceStridePadding;
padding_info.height_padding = CAM_PAD_TO_2;
}
if((!needReprocess())
|| (streamType != CAM_STREAM_TYPE_SNAPSHOT)
|| (!mParameters.isLLNoiseEnabled())) {
padding_info.offset_info.offset_x = 0;
padding_info.offset_info.offset_y = 0;
}
}
bool deferAllocation = needDeferred(streamType);
LOGD("deferAllocation = %d bDynAllocBuf = %d, stream type = %d",
deferAllocation, bDynAllocBuf, streamType);
rc = pChannel->addStream(*this,
pStreamInfo,
NULL,
minStreamBufNum,
&padding_info,
streamCB, userData,
bDynAllocBuf,
deferAllocation);
if (rc != NO_ERROR) {
LOGE("add stream type (%d) failed, ret = %d",
streamType, rc);
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : addPreviewChannel
*
* DESCRIPTION: add a preview channel that contains a preview stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addPreviewChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
// if we had preview channel before, delete it first
delete m_channels[QCAMERA_CH_TYPE_PREVIEW];
m_channels[QCAMERA_CH_TYPE_PREVIEW] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for preview channel");
return NO_MEMORY;
}
// preview only channel, don't need bundle attr and cb
rc = pChannel->init(NULL, NULL, NULL);
if (rc != NO_ERROR) {
LOGE("init preview channel failed, ret = %d", rc);
return rc;
}
// meta data stream always coexists with preview if applicable
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
metadata_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add metadata stream failed, ret = %d", rc);
return rc;
}
if (isRdiMode()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
rdi_mode_stream_cb_routine, this);
} else {
if (isNoDisplayMode()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
nodisplay_preview_stream_cb_routine, this);
} else {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
preview_stream_cb_routine, this);
pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
synchronous_stream_cb_routine);
}
}
if (((mParameters.isFDInVideoEnabled())
|| (mParameters.getDcrf() == true)
|| (mParameters.getRecordingHintValue() != true))
&& (!mParameters.isSecureMode())) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add Analysis stream failed, ret = %d", rc);
return rc;
}
}
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if ( raw_yuv ) {
rc = addStreamToChannel(pChannel,CAM_STREAM_TYPE_RAW,
preview_raw_stream_cb_routine,this);
if ( rc != NO_ERROR ) {
LOGE("add raw stream failed, ret = %d", __FUNCTION__, rc);
delete pChannel;
return rc;
}
}
if (rc != NO_ERROR) {
LOGE("add preview stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_PREVIEW] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addVideoChannel
*
* DESCRIPTION: add a video channel that contains a video stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addVideoChannel()
{
int32_t rc = NO_ERROR;
QCameraVideoChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_VIDEO] != NULL) {
// if we had video channel before, delete it first
delete m_channels[QCAMERA_CH_TYPE_VIDEO];
m_channels[QCAMERA_CH_TYPE_VIDEO] = NULL;
}
pChannel = new QCameraVideoChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for video channel");
return NO_MEMORY;
}
if (isLowPowerMode()) {
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
attr.look_back = 0; //wait for future frame for liveshot
attr.post_frame_skip = mParameters.getZSLBurstInterval();
attr.water_mark = 1; //hold min buffers possible in Q
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
rc = pChannel->init(&attr, snapshot_channel_cb_routine, this);
} else {
// preview only channel, don't need bundle attr and cb
rc = pChannel->init(NULL, NULL, NULL);
}
if (rc != 0) {
LOGE("init video channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_VIDEO,
video_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add video stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_VIDEO] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addSnapshotChannel
*
* DESCRIPTION: add a snapshot channel that contains a snapshot stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
* NOTE : Add this channel for live snapshot usecase. Regular capture will
* use addCaptureChannel.
*==========================================================================*/
int32_t QCamera2HardwareInterface::addSnapshotChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_SNAPSHOT] != NULL) {
// if we had ZSL channel before, delete it first
delete m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
m_channels[QCAMERA_CH_TYPE_SNAPSHOT] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for snapshot channel");
return NO_MEMORY;
}
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
attr.look_back = mParameters.getZSLBackLookCount();
attr.post_frame_skip = mParameters.getZSLBurstInterval();
attr.water_mark = mParameters.getZSLQueueDepth();
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
attr.priority = MM_CAMERA_SUPER_BUF_PRIORITY_LOW;
rc = pChannel->init(&attr, snapshot_channel_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("init snapshot channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
NULL, NULL);
if (rc != NO_ERROR) {
LOGE("add snapshot stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_SNAPSHOT] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addRawChannel
*
* DESCRIPTION: add a raw channel that contains a raw image stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addRawChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_RAW] != NULL) {
// if we had raw channel before, delete it first
delete m_channels[QCAMERA_CH_TYPE_RAW];
m_channels[QCAMERA_CH_TYPE_RAW] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for raw channel");
return NO_MEMORY;
}
if (mParameters.getofflineRAW()) {
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
attr.look_back = mParameters.getZSLBackLookCount();
attr.post_frame_skip = mParameters.getZSLBurstInterval();
attr.water_mark = 1;
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
rc = pChannel->init(&attr, raw_channel_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("init RAW channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
} else {
rc = pChannel->init(NULL, NULL, NULL);
if (rc != NO_ERROR) {
LOGE("init raw channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
}
if (!mParameters.isZSLMode()) {
// meta data stream always coexists with snapshot in regular RAW capture case
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
metadata_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add metadata stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
}
if (mParameters.getofflineRAW()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
NULL, this);
} else {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
raw_stream_cb_routine, this);
}
if (rc != NO_ERROR) {
LOGE("add snapshot stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_RAW] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addZSLChannel
*
* DESCRIPTION: add a ZSL channel that contains a preview stream and
* a snapshot stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addZSLChannel()
{
int32_t rc = NO_ERROR;
QCameraPicChannel *pChannel = NULL;
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
if (m_channels[QCAMERA_CH_TYPE_ZSL] != NULL) {
// if we had ZSL channel before, delete it first
delete m_channels[QCAMERA_CH_TYPE_ZSL];
m_channels[QCAMERA_CH_TYPE_ZSL] = NULL;
}
pChannel = new QCameraPicChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for ZSL channel");
return NO_MEMORY;
}
// ZSL channel, init with bundle attr and cb
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
if (mParameters.isSceneSelectionEnabled()) {
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
} else {
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
}
attr.look_back = mParameters.getZSLBackLookCount();
attr.post_frame_skip = mParameters.getZSLBurstInterval();
if (mParameters.isOEMFeatEnabled()) {
attr.post_frame_skip++;
}
attr.water_mark = mParameters.getZSLQueueDepth();
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
//Enabled matched queue
if (getRelatedCamSyncInfo()->is_frame_sync_enabled) {
LOGH("Enabling frame sync for dual camera, camera Id: %d",
mCameraId);
attr.enable_frame_sync = 1;
}
rc = pChannel->init(&attr,
zsl_channel_cb,
this);
if (rc != 0) {
LOGE("init ZSL channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
// meta data stream always coexists with preview if applicable
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
metadata_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add metadata stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
if (isNoDisplayMode()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
nodisplay_preview_stream_cb_routine, this);
} else {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
preview_stream_cb_routine, this);
pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
synchronous_stream_cb_routine);
}
if (rc != NO_ERROR) {
LOGE("add preview stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add snapshot stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
if (!mParameters.isSecureMode()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add Analysis stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
}
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if (raw_yuv) {
rc = addStreamToChannel(pChannel,
CAM_STREAM_TYPE_RAW,
NULL,
this);
if (rc != NO_ERROR) {
LOGE("add raw stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
}
m_channels[QCAMERA_CH_TYPE_ZSL] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addCaptureChannel
*
* DESCRIPTION: add a capture channel that contains a snapshot stream
* and a postview stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
* NOTE : Add this channel for regular capture usecase.
* For Live snapshot usecase, use addSnapshotChannel.
*==========================================================================*/
int32_t QCamera2HardwareInterface::addCaptureChannel()
{
int32_t rc = NO_ERROR;
QCameraPicChannel *pChannel = NULL;
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
if (m_channels[QCAMERA_CH_TYPE_CAPTURE] != NULL) {
delete m_channels[QCAMERA_CH_TYPE_CAPTURE];
m_channels[QCAMERA_CH_TYPE_CAPTURE] = NULL;
}
pChannel = new QCameraPicChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for capture channel");
return NO_MEMORY;
}
// Capture channel, only need snapshot and postview streams start together
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
if ( mLongshotEnabled ) {
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
attr.look_back = mParameters.getZSLBackLookCount();
attr.water_mark = mParameters.getZSLQueueDepth();
} else {
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
}
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
rc = pChannel->init(&attr,
capture_channel_cb_routine,
this);
if (rc != NO_ERROR) {
LOGE("init capture channel failed, ret = %d", rc);
return rc;
}
// meta data stream always coexists with snapshot in regular capture case
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
metadata_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add metadata stream failed, ret = %d", rc);
return rc;
}
if (!mLongshotEnabled) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_POSTVIEW,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add postview stream failed, ret = %d", rc);
return rc;
}
} else {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
preview_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add preview stream failed, ret = %d", rc);
return rc;
}
pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
synchronous_stream_cb_routine);
}
if (!mParameters.getofflineRAW()) {
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add snapshot stream failed, ret = %d", rc);
return rc;
}
}
stream_cb_routine stream_cb = NULL;
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if (raw_yuv) {
stream_cb = snapshot_raw_stream_cb_routine;
}
if ((raw_yuv) || (mParameters.getofflineRAW())) {
rc = addStreamToChannel(pChannel,
CAM_STREAM_TYPE_RAW, stream_cb, this);
if (rc != NO_ERROR) {
LOGE("add raw stream failed, ret = %d", rc);
return rc;
}
}
m_channels[QCAMERA_CH_TYPE_CAPTURE] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addMetaDataChannel
*
* DESCRIPTION: add a meta data channel that contains a metadata stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addMetaDataChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_METADATA] != NULL) {
delete m_channels[QCAMERA_CH_TYPE_METADATA];
m_channels[QCAMERA_CH_TYPE_METADATA] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for metadata channel");
return NO_MEMORY;
}
rc = pChannel->init(NULL,
NULL,
NULL);
if (rc != NO_ERROR) {
LOGE("init metadata channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
metadata_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add metadata stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_METADATA] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addCallbackChannel
*
* DESCRIPTION: add a callback channel that contains a callback stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addCallbackChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL) {
delete m_channels[QCAMERA_CH_TYPE_CALLBACK];
m_channels[QCAMERA_CH_TYPE_CALLBACK] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for callback channel");
return NO_MEMORY;
}
rc = pChannel->init(NULL, NULL, this);
if (rc != NO_ERROR) {
LOGE("init callback channel failed, ret = %d",
rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_CALLBACK,
callback_stream_cb_routine, this);
if (rc != NO_ERROR) {
LOGE("add callback stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_CALLBACK] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : addAnalysisChannel
*
* DESCRIPTION: add a analysis channel that contains a analysis stream
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addAnalysisChannel()
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = NULL;
if (m_channels[QCAMERA_CH_TYPE_ANALYSIS] != NULL) {
delete m_channels[QCAMERA_CH_TYPE_ANALYSIS];
m_channels[QCAMERA_CH_TYPE_ANALYSIS] = NULL;
}
pChannel = new QCameraChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for metadata channel");
return NO_MEMORY;
}
rc = pChannel->init(NULL, NULL, this);
if (rc != NO_ERROR) {
LOGE("init Analysis channel failed, ret = %d", rc);
delete pChannel;
return rc;
}
rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
NULL, this);
if (rc != NO_ERROR) {
LOGE("add Analysis stream failed, ret = %d", rc);
delete pChannel;
return rc;
}
m_channels[QCAMERA_CH_TYPE_ANALYSIS] = pChannel;
return rc;
}
/*===========================================================================
* FUNCTION : getPPConfig
*
* DESCRIPTION: get Post processing configaration data
*
* PARAMETERS :
* @pp config: pp config structure pointer,
* @curIndex: current pp channel index
* @multipass: Flag if multipass prcessing enabled.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::getPPConfig(cam_pp_feature_config_t &pp_config,
int8_t curIndex, bool multipass)
{
int32_t rc = NO_ERROR;
if (multipass) {
LOGW("Multi pass enabled. Total Pass = %d, cur index = %d",
mParameters.getReprocCount(), curIndex);
}
LOGH("Supported pproc feature mask = %x",
gCamCapability[mCameraId]->qcom_supported_feature_mask);
uint32_t feature_mask = gCamCapability[mCameraId]->qcom_supported_feature_mask;
int32_t zoomLevel = mParameters.getParmZoomLevel();
uint32_t rotation = mParameters.getJpegRotation();
int32_t effect = mParameters.getEffectValue();
pp_config.cur_reproc_count = curIndex + 1;
pp_config.total_reproc_count = mParameters.getReprocCount();
switch(curIndex) {
case 0:
//Configure feature mask for first pass of reprocessing
//check if any effects are enabled
if ((CAM_EFFECT_MODE_OFF != effect) &&
(feature_mask & CAM_QCOM_FEATURE_EFFECT)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_EFFECT;
pp_config.effect = effect;
}
//check for features that need to be enabled by default like sharpness
//(if supported by hw).
if ((feature_mask & CAM_QCOM_FEATURE_SHARPNESS) &&
!mParameters.isOptiZoomEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_SHARPNESS;
pp_config.sharpness = mParameters.getSharpness();
}
//check if zoom is enabled
if ((zoomLevel > 0) && (feature_mask & CAM_QCOM_FEATURE_CROP)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
}
if (mParameters.isWNREnabled() &&
(feature_mask & CAM_QCOM_FEATURE_DENOISE2D)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_DENOISE2D;
pp_config.denoise2d.denoise_enable = 1;
pp_config.denoise2d.process_plates =
mParameters.getDenoiseProcessPlate(CAM_INTF_PARM_WAVELET_DENOISE);
}
if (isCACEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CAC;
}
//check if rotation is required
if ((feature_mask & CAM_QCOM_FEATURE_ROTATION) && (rotation > 0)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
if (rotation == 0) {
pp_config.rotation = ROTATE_0;
} else if (rotation == 90) {
pp_config.rotation = ROTATE_90;
} else if (rotation == 180) {
pp_config.rotation = ROTATE_180;
} else if (rotation == 270) {
pp_config.rotation = ROTATE_270;
}
}
if (mParameters.isHDREnabled()){
pp_config.feature_mask |= CAM_QCOM_FEATURE_HDR;
pp_config.hdr_param.hdr_enable = 1;
pp_config.hdr_param.hdr_need_1x = mParameters.isHDR1xFrameEnabled();
pp_config.hdr_param.hdr_mode = CAM_HDR_MODE_MULTIFRAME;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_HDR;
pp_config.hdr_param.hdr_enable = 0;
}
//check if scaling is enabled
if ((feature_mask & CAM_QCOM_FEATURE_SCALE) &&
mParameters.isReprocScaleEnabled() &&
mParameters.isUnderReprocScaling()){
pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
mParameters.getPicSizeFromAPK(
pp_config.scale_param.output_width,
pp_config.scale_param.output_height);
}
if(mParameters.isUbiFocusEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_UBIFOCUS;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_UBIFOCUS;
}
if(mParameters.isUbiRefocus()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_REFOCUS;
pp_config.misc_buf_param.misc_buffer_index = 0;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_REFOCUS;
}
if(mParameters.isChromaFlashEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CHROMA_FLASH;
pp_config.flash_value = CAM_FLASH_ON;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_CHROMA_FLASH;
}
if(mParameters.isOptiZoomEnabled() && (0 <= zoomLevel)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_OPTIZOOM;
pp_config.zoom_level = (uint8_t) zoomLevel;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_OPTIZOOM;
}
if (mParameters.getofflineRAW()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_RAW_PROCESSING;
}
if (mParameters.isTruePortraitEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_TRUEPORTRAIT;
pp_config.misc_buf_param.misc_buffer_index = 0;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_TRUEPORTRAIT;
}
if(mParameters.isStillMoreEnabled()) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_STILLMORE;
} else {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_STILLMORE;
}
if (mParameters.isOEMFeatEnabled()) {
pp_config.feature_mask |= CAM_OEM_FEATURE_1;
}
if (mParameters.getCDSMode() != CAM_CDS_MODE_OFF) {
if (feature_mask & CAM_QCOM_FEATURE_DSDN) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_DSDN;
} else {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CDS;
}
}
if ((multipass) &&
(m_postprocessor.getPPChannelCount() > 1)) {
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_PP_PASS_2;
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_ROTATION;
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_CDS;
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_DSDN;
pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
} else {
pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
}
cam_dimension_t thumb_src_dim;
cam_dimension_t thumb_dst_dim;
mParameters.getThumbnailSize(&(thumb_dst_dim.width), &(thumb_dst_dim.height));
mParameters.getStreamDimension(CAM_STREAM_TYPE_POSTVIEW,thumb_src_dim);
if ((thumb_dst_dim.width != thumb_src_dim.width) ||
(thumb_dst_dim.height != thumb_src_dim.height)) {
if (thumb_dst_dim.width != 0 && thumb_dst_dim.height != 0) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
}
}
break;
case 1:
//Configure feature mask for second pass of reprocessing
pp_config.feature_mask |= CAM_QCOM_FEATURE_PP_PASS_2;
if ((feature_mask & CAM_QCOM_FEATURE_ROTATION) && (rotation > 0)) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
if (rotation == 0) {
pp_config.rotation = ROTATE_0;
} else if (rotation == 90) {
pp_config.rotation = ROTATE_90;
} else if (rotation == 180) {
pp_config.rotation = ROTATE_180;
} else if (rotation == 270) {
pp_config.rotation = ROTATE_270;
}
}
if (mParameters.getCDSMode() != CAM_CDS_MODE_OFF) {
if (feature_mask & CAM_QCOM_FEATURE_DSDN) {
pp_config.feature_mask |= CAM_QCOM_FEATURE_DSDN;
} else {
pp_config.feature_mask |= CAM_QCOM_FEATURE_CDS;
}
}
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_RAW_PROCESSING;
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_METADATA_PROCESSING;
break;
}
LOGH("pproc feature mask set = %x pass count = %d",
pp_config.feature_mask, curIndex);
return rc;
}
/*===========================================================================
* FUNCTION : addReprocChannel
*
* DESCRIPTION: add a reprocess channel that will do reprocess on frames
* coming from input channel
*
* PARAMETERS :
* @pInputChannel : ptr to input channel whose frames will be post-processed
* @cur_channel_index : Current channel index in multipass
*
* RETURN : Ptr to the newly created channel obj. NULL if failed.
*==========================================================================*/
QCameraReprocessChannel *QCamera2HardwareInterface::addReprocChannel(
QCameraChannel *pInputChannel, int8_t cur_channel_index)
{
int32_t rc = NO_ERROR;
QCameraReprocessChannel *pChannel = NULL;
uint32_t burst_cnt = mParameters.getNumOfSnapshots();
if (pInputChannel == NULL) {
LOGE("input channel obj is NULL");
return NULL;
}
pChannel = new QCameraReprocessChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for reprocess channel");
return NULL;
}
// Capture channel, only need snapshot and postview streams start together
mm_camera_channel_attr_t attr;
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
rc = pChannel->init(&attr,
postproc_channel_cb_routine,
this);
if (rc != NO_ERROR) {
LOGE("init reprocess channel failed, ret = %d", rc);
delete pChannel;
return NULL;
}
// pp feature config
cam_pp_feature_config_t pp_config;
memset(&pp_config, 0, sizeof(cam_pp_feature_config_t));
rc = getPPConfig(pp_config, cur_channel_index,
((mParameters.getReprocCount() > 1) ? TRUE : FALSE));
if (rc != NO_ERROR){
LOGE("Error while creating PP config");
delete pChannel;
return NULL;
}
uint8_t minStreamBufNum = getBufNumRequired(CAM_STREAM_TYPE_OFFLINE_PROC);
//WNR and HDR happen inline. No extra buffers needed.
uint32_t temp_feature_mask = pp_config.feature_mask;
temp_feature_mask &= ~CAM_QCOM_FEATURE_HDR;
if (temp_feature_mask && mParameters.isHDREnabled()) {
minStreamBufNum = (uint8_t)(1 + mParameters.getNumOfExtraHDRInBufsIfNeeded());
}
if (mParameters.isStillMoreEnabled()) {
cam_still_more_t stillmore_config = mParameters.getStillMoreSettings();
pp_config.burst_cnt = stillmore_config.burst_count;
LOGH("Stillmore burst %d", pp_config.burst_cnt);
// getNumOfExtraBuffersForImageProc returns 1 less buffer assuming
// number of capture is already added. In the case of liveshot,
// stillmore burst is 1. This is to account for the premature decrement
if (mParameters.getNumOfExtraBuffersForImageProc() == 0) {
minStreamBufNum += 1;
}
}
if (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_3) {
minStreamBufNum += mParameters.getReprocCount() - 1;
burst_cnt = mParameters.getReprocCount();
if (cur_channel_index == 0) {
pChannel->setReprocCount(2);
} else {
pChannel->setReprocCount(1);
}
} else {
pChannel->setReprocCount(1);
}
// Add non inplace image lib buffers only when ppproc is present,
// becuase pproc is non inplace and input buffers for img lib
// are output for pproc and this number of extra buffers is required
// If pproc is not there, input buffers for imglib are from snapshot stream
uint8_t imglib_extra_bufs = mParameters.getNumOfExtraBuffersForImageProc();
if (temp_feature_mask && imglib_extra_bufs) {
// 1 is added because getNumOfExtraBuffersForImageProc returns extra
// buffers assuming number of capture is already added
minStreamBufNum = (uint8_t)(minStreamBufNum + imglib_extra_bufs + 1);
}
//Mask out features that are already processed in snapshot stream.
uint32_t snapshot_feature_mask = 0;
mParameters.getStreamPpMask(CAM_STREAM_TYPE_SNAPSHOT, snapshot_feature_mask);
pp_config.feature_mask &= ~snapshot_feature_mask;
LOGH("Snapshot feature mask: 0x%x, reproc feature mask: 0x%x",
snapshot_feature_mask, pp_config.feature_mask);
bool offlineReproc = isRegularCapture();
if (m_postprocessor.mOfflineDataBufs != NULL) {
offlineReproc = TRUE;
}
cam_padding_info_t paddingInfo = gCamCapability[mCameraId]->padding_info;
paddingInfo.offset_info.offset_x = 0;
paddingInfo.offset_info.offset_y = 0;
rc = pChannel->addReprocStreamsFromSource(*this,
pp_config,
pInputChannel,
minStreamBufNum,
burst_cnt,
&paddingInfo,
mParameters,
mLongshotEnabled,
offlineReproc);
if (rc != NO_ERROR) {
delete pChannel;
return NULL;
}
return pChannel;
}
/*===========================================================================
* FUNCTION : addOfflineReprocChannel
*
* DESCRIPTION: add a offline reprocess channel contains one reproc stream,
* that will do reprocess on frames coming from external images
*
* PARAMETERS :
* @img_config : offline reporcess image info
* @pp_feature : pp feature config
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
QCameraReprocessChannel *QCamera2HardwareInterface::addOfflineReprocChannel(
cam_pp_offline_src_config_t &img_config,
cam_pp_feature_config_t &pp_feature,
stream_cb_routine stream_cb,
void *userdata)
{
int32_t rc = NO_ERROR;
QCameraReprocessChannel *pChannel = NULL;
pChannel = new QCameraReprocessChannel(mCameraHandle->camera_handle,
mCameraHandle->ops);
if (NULL == pChannel) {
LOGE("no mem for reprocess channel");
return NULL;
}
rc = pChannel->init(NULL, NULL, NULL);
if (rc != NO_ERROR) {
LOGE("init reprocess channel failed, ret = %d", rc);
delete pChannel;
return NULL;
}
QCameraHeapMemory *pStreamInfo = allocateStreamInfoBuf(CAM_STREAM_TYPE_OFFLINE_PROC);
if (pStreamInfo == NULL) {
LOGE("no mem for stream info buf");
delete pChannel;
return NULL;
}
cam_stream_info_t *streamInfoBuf = (cam_stream_info_t *)pStreamInfo->getPtr(0);
memset(streamInfoBuf, 0, sizeof(cam_stream_info_t));
streamInfoBuf->stream_type = CAM_STREAM_TYPE_OFFLINE_PROC;
streamInfoBuf->fmt = img_config.input_fmt;
streamInfoBuf->dim = img_config.input_dim;
streamInfoBuf->buf_planes = img_config.input_buf_planes;
streamInfoBuf->streaming_mode = CAM_STREAMING_MODE_BURST;
streamInfoBuf->num_of_burst = img_config.num_of_bufs;
streamInfoBuf->reprocess_config.pp_type = CAM_OFFLINE_REPROCESS_TYPE;
streamInfoBuf->reprocess_config.offline = img_config;
streamInfoBuf->reprocess_config.pp_feature_config = pp_feature;
rc = pChannel->addStream(*this,
pStreamInfo, NULL, img_config.num_of_bufs,
&gCamCapability[mCameraId]->padding_info,
stream_cb, userdata, false);
if (rc != NO_ERROR) {
LOGE("add reprocess stream failed, ret = %d", rc);
delete pChannel;
return NULL;
}
return pChannel;
}
/*===========================================================================
* FUNCTION : addChannel
*
* DESCRIPTION: add a channel by its type
*
* PARAMETERS :
* @ch_type : channel type
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::addChannel(qcamera_ch_type_enum_t ch_type)
{
int32_t rc = UNKNOWN_ERROR;
switch (ch_type) {
case QCAMERA_CH_TYPE_ZSL:
rc = addZSLChannel();
break;
case QCAMERA_CH_TYPE_CAPTURE:
rc = addCaptureChannel();
break;
case QCAMERA_CH_TYPE_PREVIEW:
rc = addPreviewChannel();
break;
case QCAMERA_CH_TYPE_VIDEO:
rc = addVideoChannel();
break;
case QCAMERA_CH_TYPE_SNAPSHOT:
rc = addSnapshotChannel();
break;
case QCAMERA_CH_TYPE_RAW:
rc = addRawChannel();
break;
case QCAMERA_CH_TYPE_METADATA:
rc = addMetaDataChannel();
break;
case QCAMERA_CH_TYPE_CALLBACK:
rc = addCallbackChannel();
break;
case QCAMERA_CH_TYPE_ANALYSIS:
rc = addAnalysisChannel();
break;
default:
break;
}
return rc;
}
/*===========================================================================
* FUNCTION : delChannel
*
* DESCRIPTION: delete a channel by its type
*
* PARAMETERS :
* @ch_type : channel type
* @destroy : delete context as well
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::delChannel(qcamera_ch_type_enum_t ch_type,
bool destroy)
{
if (m_channels[ch_type] != NULL) {
if (destroy) {
delete m_channels[ch_type];
m_channels[ch_type] = NULL;
} else {
m_channels[ch_type]->deleteChannel();
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : startChannel
*
* DESCRIPTION: start a channel by its type
*
* PARAMETERS :
* @ch_type : channel type
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::startChannel(qcamera_ch_type_enum_t ch_type)
{
int32_t rc = UNKNOWN_ERROR;
if (m_channels[ch_type] != NULL) {
rc = m_channels[ch_type]->start();
}
return rc;
}
/*===========================================================================
* FUNCTION : stopChannel
*
* DESCRIPTION: stop a channel by its type
*
* PARAMETERS :
* @ch_type : channel type
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::stopChannel(qcamera_ch_type_enum_t ch_type)
{
int32_t rc = UNKNOWN_ERROR;
if (m_channels[ch_type] != NULL) {
rc = m_channels[ch_type]->stop();
}
return rc;
}
/*===========================================================================
* FUNCTION : preparePreview
*
* DESCRIPTION: add channels needed for preview
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::preparePreview()
{
ATRACE_CALL();
int32_t rc = NO_ERROR;
LOGI("E");
rc = mParameters.setStreamConfigure(false, false, false);
if (rc != NO_ERROR) {
LOGE("setStreamConfigure failed %d", rc);
return rc;
}
if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) {
rc = addChannel(QCAMERA_CH_TYPE_ZSL);
if (rc != NO_ERROR) {
LOGE("failed!! rc = %d", rc);
return rc;
}
if (mParameters.isUBWCEnabled()) {
cam_format_t fmt;
mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW, fmt);
if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
rc = addChannel(QCAMERA_CH_TYPE_CALLBACK);
if (rc != NO_ERROR) {
delChannel(QCAMERA_CH_TYPE_ZSL);
LOGE("failed!! rc = %d", rc);
return rc;
}
}
}
if (mParameters.getofflineRAW()) {
addChannel(QCAMERA_CH_TYPE_RAW);
}
} else {
bool recordingHint = mParameters.getRecordingHintValue();
if(!isRdiMode() && recordingHint) {
//stop face detection,longshot,etc if turned ON in Camera mode
int32_t arg; //dummy arg
#ifndef VANILLA_HAL
if (isLongshotEnabled()) {
sendCommand(CAMERA_CMD_LONGSHOT_OFF, arg, arg);
}
if (mParameters.isFaceDetectionEnabled()
&& (!mParameters.isFDInVideoEnabled())) {
sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, arg, arg);
}
if (mParameters.isHistogramEnabled()) {
sendCommand(CAMERA_CMD_HISTOGRAM_OFF, arg, arg);
}
#endif
//Don't create snapshot channel for liveshot, if low power mode is set.
//Use video stream instead.
if (!isLowPowerMode()) {
rc = addChannel(QCAMERA_CH_TYPE_SNAPSHOT);
if (rc != NO_ERROR) {
return rc;
}
}
rc = addChannel(QCAMERA_CH_TYPE_VIDEO);
if (rc != NO_ERROR) {
delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
LOGE("failed!! rc = %d", rc);
return rc;
}
}
rc = addChannel(QCAMERA_CH_TYPE_PREVIEW);
if (!isRdiMode() && (rc != NO_ERROR)) {
if (recordingHint) {
delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
delChannel(QCAMERA_CH_TYPE_VIDEO);
}
}
if (mParameters.isUBWCEnabled() && !recordingHint) {
cam_format_t fmt;
mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW, fmt);
if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
rc = addChannel(QCAMERA_CH_TYPE_CALLBACK);
if (rc != NO_ERROR) {
delChannel(QCAMERA_CH_TYPE_PREVIEW);
if (!isRdiMode()) {
delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
delChannel(QCAMERA_CH_TYPE_VIDEO);
}
LOGE("failed!! rc = %d", rc);
return rc;
}
}
}
if (NO_ERROR != rc) {
delChannel(QCAMERA_CH_TYPE_PREVIEW);
LOGE("failed!! rc = %d", rc);
}
}
LOGI("E rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : unpreparePreview
*
* DESCRIPTION: delete channels for preview
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::unpreparePreview()
{
delChannel(QCAMERA_CH_TYPE_ZSL);
delChannel(QCAMERA_CH_TYPE_PREVIEW);
delChannel(QCAMERA_CH_TYPE_VIDEO);
delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
delChannel(QCAMERA_CH_TYPE_CALLBACK);
delChannel(QCAMERA_CH_TYPE_RAW);
}
/*===========================================================================
* FUNCTION : playShutter
*
* DESCRIPTION: send request to play shutter sound
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::playShutter(){
if (mNotifyCb == NULL ||
msgTypeEnabledWithLock(CAMERA_MSG_SHUTTER) == 0){
LOGD("shutter msg not enabled or NULL cb");
return;
}
LOGH("CAMERA_MSG_SHUTTER ");
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
cbArg.msg_type = CAMERA_MSG_SHUTTER;
cbArg.ext1 = 0;
cbArg.ext2 = false;
m_cbNotifier.notifyCallback(cbArg);
}
/*===========================================================================
* FUNCTION : getChannelByHandle
*
* DESCRIPTION: return a channel by its handle
*
* PARAMETERS :
* @channelHandle : channel handle
*
* RETURN : a channel obj if found, NULL if not found
*==========================================================================*/
QCameraChannel *QCamera2HardwareInterface::getChannelByHandle(uint32_t channelHandle)
{
for(int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
if (m_channels[i] != NULL &&
m_channels[i]->getMyHandle() == channelHandle) {
return m_channels[i];
}
}
return NULL;
}
/*===========================================================================
* FUNCTION : needPreviewFDCallback
*
* DESCRIPTION: decides if needPreviewFDCallback
*
* PARAMETERS :
* @num_faces : number of faces
*
* RETURN : bool type of status
* true -- success
* fale -- failure code
*==========================================================================*/
bool QCamera2HardwareInterface::needPreviewFDCallback(uint8_t num_faces)
{
if (num_faces == 0 && mNumPreviewFaces == 0) {
return false;
}
return true;
}
/*===========================================================================
* FUNCTION : processFaceDetectionReuslt
*
* DESCRIPTION: process face detection reuslt
*
* PARAMETERS :
* @faces_data : ptr to face processing result struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processFaceDetectionResult(cam_faces_data_t *faces_data)
{
if (!mParameters.isFaceDetectionEnabled()) {
LOGH("FaceDetection not enabled, no ops here");
return NO_ERROR;
}
qcamera_face_detect_type_t fd_type = faces_data->detection_data.fd_type;
cam_face_detection_data_t *detect_data = &(faces_data->detection_data);
if ((NULL == mDataCb) ||
(fd_type == QCAMERA_FD_PREVIEW && !msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA)) ||
(!needPreviewFDCallback(detect_data->num_faces_detected))
#ifndef VANILLA_HAL
|| (fd_type == QCAMERA_FD_SNAPSHOT && !msgTypeEnabled(CAMERA_MSG_META_DATA))
#endif
) {
LOGH("metadata msgtype not enabled, no ops here");
return NO_ERROR;
}
if ((fd_type == QCAMERA_FD_PREVIEW) && (detect_data->update_flag == FALSE)) {
// Don't send callback to app if this is skipped by fd at backend
return NO_ERROR;
}
cam_dimension_t display_dim;
mParameters.getStreamDimension(CAM_STREAM_TYPE_PREVIEW, display_dim);
if (display_dim.width <= 0 || display_dim.height <= 0) {
LOGE("Invalid preview width or height (%d x %d)",
display_dim.width, display_dim.height);
return UNKNOWN_ERROR;
}
// process face detection result
// need separate face detection in preview or snapshot type
size_t faceResultSize = 0;
size_t data_len = 0;
if(fd_type == QCAMERA_FD_PREVIEW){
//fd for preview frames
faceResultSize = sizeof(camera_frame_metadata_t);
faceResultSize += sizeof(camera_face_t) * MAX_ROI;
}else if(fd_type == QCAMERA_FD_SNAPSHOT){
#ifndef VANILLA_HAL
// fd for snapshot frames
//check if face is detected in this frame
if(detect_data->num_faces_detected > 0){
data_len = sizeof(camera_frame_metadata_t) +
sizeof(camera_face_t) * detect_data->num_faces_detected;
}else{
//no face
data_len = 0;
}
#endif
faceResultSize = 1 *sizeof(int) //meta data type
+ 1 *sizeof(int) // meta data len
+ data_len; //data
}
camera_memory_t *faceResultBuffer = mGetMemory(-1,
faceResultSize,
1,
mCallbackCookie);
if ( NULL == faceResultBuffer ) {
LOGE("Not enough memory for face result data");
return NO_MEMORY;
}
unsigned char *pFaceResult = ( unsigned char * ) faceResultBuffer->data;
memset(pFaceResult, 0, faceResultSize);
unsigned char *faceData = NULL;
if(fd_type == QCAMERA_FD_PREVIEW){
faceData = pFaceResult;
mNumPreviewFaces = detect_data->num_faces_detected;
}else if(fd_type == QCAMERA_FD_SNAPSHOT){
#ifndef VANILLA_HAL
//need fill meta type and meta data len first
int *data_header = (int* )pFaceResult;
data_header[0] = CAMERA_META_DATA_FD;
data_header[1] = (int)data_len;
if(data_len <= 0){
//if face is not valid or do not have face, return
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
cbArg.msg_type = CAMERA_MSG_META_DATA;
cbArg.data = faceResultBuffer;
cbArg.user_data = faceResultBuffer;
cbArg.cookie = this;
cbArg.release_cb = releaseCameraMemory;
int32_t rc = m_cbNotifier.notifyCallback(cbArg);
if (rc != NO_ERROR) {
LOGE("fail sending notification");
faceResultBuffer->release(faceResultBuffer);
}
return rc;
}
#endif
faceData = pFaceResult + 2 *sizeof(int); //skip two int length
}
camera_frame_metadata_t *roiData = (camera_frame_metadata_t * ) faceData;
camera_face_t *faces = (camera_face_t *) ( faceData + sizeof(camera_frame_metadata_t) );
roiData->number_of_faces = detect_data->num_faces_detected;
roiData->faces = faces;
if (roiData->number_of_faces > 0) {
for (int i = 0; i < roiData->number_of_faces; i++) {
faces[i].id = detect_data->faces[i].face_id;
faces[i].score = detect_data->faces[i].score;
// left
faces[i].rect[0] = MAP_TO_DRIVER_COORDINATE(
detect_data->faces[i].face_boundary.left,
display_dim.width, 2000, -1000);
// top
faces[i].rect[1] = MAP_TO_DRIVER_COORDINATE(
detect_data->faces[i].face_boundary.top,
display_dim.height, 2000, -1000);
// right
faces[i].rect[2] = faces[i].rect[0] +
MAP_TO_DRIVER_COORDINATE(
detect_data->faces[i].face_boundary.width,
display_dim.width, 2000, 0);
// bottom
faces[i].rect[3] = faces[i].rect[1] +
MAP_TO_DRIVER_COORDINATE(
detect_data->faces[i].face_boundary.height,
display_dim.height, 2000, 0);
if (faces_data->landmark_valid) {
// Center of left eye
faces[i].left_eye[0] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].left_eye_center.x,
display_dim.width, 2000, -1000);
faces[i].left_eye[1] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].left_eye_center.y,
display_dim.height, 2000, -1000);
// Center of right eye
faces[i].right_eye[0] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].right_eye_center.x,
display_dim.width, 2000, -1000);
faces[i].right_eye[1] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].right_eye_center.y,
display_dim.height, 2000, -1000);
// Center of mouth
faces[i].mouth[0] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].mouth_center.x,
display_dim.width, 2000, -1000);
faces[i].mouth[1] = MAP_TO_DRIVER_COORDINATE(
faces_data->landmark_data.face_landmarks[i].mouth_center.y,
display_dim.height, 2000, -1000);
} else {
// return -2000 if invalid
faces[i].left_eye[0] = -2000;
faces[i].left_eye[1] = -2000;
faces[i].right_eye[0] = -2000;
faces[i].right_eye[1] = -2000;
faces[i].mouth[0] = -2000;
faces[i].mouth[1] = -2000;
}
#ifndef VANILLA_HAL
#ifdef TARGET_TS_MAKEUP
mFaceRect.left = detect_data->faces[i].face_boundary.left;
mFaceRect.top = detect_data->faces[i].face_boundary.top;
mFaceRect.right = detect_data->faces[i].face_boundary.width+mFaceRect.left;
mFaceRect.bottom = detect_data->faces[i].face_boundary.height+mFaceRect.top;
#endif
if (faces_data->smile_valid) {
faces[i].smile_degree = faces_data->smile_data.smile[i].smile_degree;
faces[i].smile_score = faces_data->smile_data.smile[i].smile_confidence;
}
if (faces_data->blink_valid) {
faces[i].blink_detected = faces_data->blink_data.blink[i].blink_detected;
faces[i].leye_blink = faces_data->blink_data.blink[i].left_blink;
faces[i].reye_blink = faces_data->blink_data.blink[i].right_blink;
}
if (faces_data->recog_valid) {
faces[i].face_recognised = faces_data->recog_data.face_rec[i].face_recognised;
}
if (faces_data->gaze_valid) {
faces[i].gaze_angle = faces_data->gaze_data.gaze[i].gaze_angle;
faces[i].updown_dir = faces_data->gaze_data.gaze[i].updown_dir;
faces[i].leftright_dir = faces_data->gaze_data.gaze[i].leftright_dir;
faces[i].roll_dir = faces_data->gaze_data.gaze[i].roll_dir;
faces[i].left_right_gaze = faces_data->gaze_data.gaze[i].left_right_gaze;
faces[i].top_bottom_gaze = faces_data->gaze_data.gaze[i].top_bottom_gaze;
}
#endif
}
}
else{
#ifdef TARGET_TS_MAKEUP
memset(&mFaceRect,-1,sizeof(mFaceRect));
#endif
}
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
if(fd_type == QCAMERA_FD_PREVIEW){
cbArg.msg_type = CAMERA_MSG_PREVIEW_METADATA;
}
#ifndef VANILLA_HAL
else if(fd_type == QCAMERA_FD_SNAPSHOT){
cbArg.msg_type = CAMERA_MSG_META_DATA;
}
#endif
cbArg.data = faceResultBuffer;
cbArg.metadata = roiData;
cbArg.user_data = faceResultBuffer;
cbArg.cookie = this;
cbArg.release_cb = releaseCameraMemory;
int32_t rc = m_cbNotifier.notifyCallback(cbArg);
if (rc != NO_ERROR) {
LOGE("fail sending notification");
faceResultBuffer->release(faceResultBuffer);
}
return rc;
}
/*===========================================================================
* FUNCTION : releaseCameraMemory
*
* DESCRIPTION: releases camera memory objects
*
* PARAMETERS :
* @data : buffer to be released
* @cookie : context data
* @cbStatus: callback status
*
* RETURN : None
*==========================================================================*/
void QCamera2HardwareInterface::releaseCameraMemory(void *data,
void */*cookie*/,
int32_t /*cbStatus*/)
{
camera_memory_t *mem = ( camera_memory_t * ) data;
if ( NULL != mem ) {
mem->release(mem);
}
}
/*===========================================================================
* FUNCTION : returnStreamBuffer
*
* DESCRIPTION: returns back a stream buffer
*
* PARAMETERS :
* @data : buffer to be released
* @cookie : context data
* @cbStatus: callback status
*
* RETURN : None
*==========================================================================*/
void QCamera2HardwareInterface::returnStreamBuffer(void *data,
void *cookie,
int32_t /*cbStatus*/)
{
QCameraStream *stream = ( QCameraStream * ) cookie;
int idx = *((int *)data);
if ((NULL != stream) && (0 <= idx)) {
stream->bufDone((uint32_t)idx);
} else {
LOGE("Cannot return buffer %d %p", idx, cookie);
}
}
/*===========================================================================
* FUNCTION : processHistogramStats
*
* DESCRIPTION: process histogram stats
*
* PARAMETERS :
* @hist_data : ptr to histogram stats struct
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::processHistogramStats(cam_hist_stats_t &stats_data)
{
#ifndef VANILLA_HAL
if (!mParameters.isHistogramEnabled()) {
LOGH("Histogram not enabled, no ops here");
return NO_ERROR;
}
camera_memory_t *histBuffer = mGetMemory(-1,
sizeof(cam_histogram_data_t),
1,
mCallbackCookie);
if ( NULL == histBuffer ) {
LOGE("Not enough memory for histogram data");
return NO_MEMORY;
}
cam_histogram_data_t *pHistData = (cam_histogram_data_t *)histBuffer->data;
if (pHistData == NULL) {
LOGE("memory data ptr is NULL");
return UNKNOWN_ERROR;
}
switch (stats_data.type) {
case CAM_HISTOGRAM_TYPE_BAYER:
*pHistData = stats_data.bayer_stats.gb_stats;
break;
case CAM_HISTOGRAM_TYPE_YUV:
*pHistData = stats_data.yuv_stats;
break;
}
qcamera_callback_argm_t cbArg;
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
cbArg.msg_type = CAMERA_MSG_STATS_DATA;
cbArg.data = histBuffer;
cbArg.user_data = histBuffer;
cbArg.cookie = this;
cbArg.release_cb = releaseCameraMemory;
int32_t rc = m_cbNotifier.notifyCallback(cbArg);
if (rc != NO_ERROR) {
LOGE("fail sending notification");
histBuffer->release(histBuffer);
}
#endif
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : calcThermalLevel
*
* DESCRIPTION: Calculates the target fps range depending on
* the thermal level.
* Note that this function can be called from QCameraParametersIntf
* while mutex is held. So it should not call back into
* QCameraParametersIntf causing deadlock.
*
* PARAMETERS :
* @level : received thermal level
* @minFPS : minimum configured fps range
* @maxFPS : maximum configured fps range
* @minVideoFps: minimum configured fps range
* @maxVideoFps: maximum configured fps range
* @adjustedRange : target fps range
* @skipPattern : target skip pattern
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::calcThermalLevel(
qcamera_thermal_level_enum_t level,
const int minFPSi,
const int maxFPSi,
const float &minVideoFps,
const float &maxVideoFps,
cam_fps_range_t &adjustedRange,
enum msm_vfe_frame_skip_pattern &skipPattern)
{
const float minFPS = (float)minFPSi;
const float maxFPS = (float)maxFPSi;
LOGH("level: %d, preview minfps %f, preview maxfpS %f, "
"video minfps %f, video maxfpS %f",
level, minFPS, maxFPS, minVideoFps, maxVideoFps);
switch(level) {
case QCAMERA_THERMAL_NO_ADJUSTMENT:
{
adjustedRange.min_fps = minFPS / 1000.0f;
adjustedRange.max_fps = maxFPS / 1000.0f;
adjustedRange.video_min_fps = minVideoFps / 1000.0f;
adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
skipPattern = NO_SKIP;
}
break;
case QCAMERA_THERMAL_SLIGHT_ADJUSTMENT:
{
adjustedRange.min_fps = minFPS / 1000.0f;
adjustedRange.max_fps = maxFPS / 1000.0f;
adjustedRange.min_fps -= 0.1f * adjustedRange.min_fps;
adjustedRange.max_fps -= 0.1f * adjustedRange.max_fps;
adjustedRange.video_min_fps = minVideoFps / 1000.0f;
adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
adjustedRange.video_min_fps -= 0.1f * adjustedRange.video_min_fps;
adjustedRange.video_max_fps -= 0.1f * adjustedRange.video_max_fps;
if ( adjustedRange.min_fps < 1 ) {
adjustedRange.min_fps = 1;
}
if ( adjustedRange.max_fps < 1 ) {
adjustedRange.max_fps = 1;
}
if ( adjustedRange.video_min_fps < 1 ) {
adjustedRange.video_min_fps = 1;
}
if ( adjustedRange.video_max_fps < 1 ) {
adjustedRange.video_max_fps = 1;
}
skipPattern = EVERY_2FRAME;
}
break;
case QCAMERA_THERMAL_BIG_ADJUSTMENT:
{
adjustedRange.min_fps = minFPS / 1000.0f;
adjustedRange.max_fps = maxFPS / 1000.0f;
adjustedRange.min_fps -= 0.2f * adjustedRange.min_fps;
adjustedRange.max_fps -= 0.2f * adjustedRange.max_fps;
adjustedRange.video_min_fps = minVideoFps / 1000.0f;
adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
adjustedRange.video_min_fps -= 0.2f * adjustedRange.video_min_fps;
adjustedRange.video_max_fps -= 0.2f * adjustedRange.video_max_fps;
if ( adjustedRange.min_fps < 1 ) {
adjustedRange.min_fps = 1;
}
if ( adjustedRange.max_fps < 1 ) {
adjustedRange.max_fps = 1;
}
if ( adjustedRange.video_min_fps < 1 ) {
adjustedRange.video_min_fps = 1;
}
if ( adjustedRange.video_max_fps < 1 ) {
adjustedRange.video_max_fps = 1;
}
skipPattern = EVERY_4FRAME;
}
break;
case QCAMERA_THERMAL_MAX_ADJUSTMENT:
{
// Stop Preview?
// Set lowest min FPS for now
adjustedRange.min_fps = minFPS/1000.0f;
adjustedRange.max_fps = minFPS/1000.0f;
cam_capability_t *capability = gCamCapability[mCameraId];
for (size_t i = 0;
i < capability->fps_ranges_tbl_cnt;
i++) {
if (capability->fps_ranges_tbl[i].min_fps <
adjustedRange.min_fps) {
adjustedRange.min_fps =
capability->fps_ranges_tbl[i].min_fps;
adjustedRange.max_fps = adjustedRange.min_fps;
}
}
skipPattern = MAX_SKIP;
adjustedRange.video_min_fps = adjustedRange.min_fps;
adjustedRange.video_max_fps = adjustedRange.max_fps;
}
break;
case QCAMERA_THERMAL_SHUTDOWN:
{
// send error notify
LOGE("Received shutdown thermal level. Closing camera");
sendEvtNotify(CAMERA_MSG_ERROR, CAMERA_ERROR_SERVER_DIED, 0);
}
break;
default:
{
LOGW("Invalid thermal level %d", level);
return BAD_VALUE;
}
break;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : recalcFPSRange
*
* DESCRIPTION: adjust the configured fps range regarding
* the last thermal level.
*
* PARAMETERS :
* @minFPS : minimum configured fps range
* @maxFPS : maximum configured fps range
* @minVideoFPS : minimum configured video fps
* @maxVideoFPS : maximum configured video fps
* @adjustedRange : target fps range
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::recalcFPSRange(int &minFPS, int &maxFPS,
const float &minVideoFPS, const float &maxVideoFPS,
cam_fps_range_t &adjustedRange)
{
enum msm_vfe_frame_skip_pattern skipPattern;
calcThermalLevel(mThermalLevel,
minFPS,
maxFPS,
minVideoFPS,
maxVideoFPS,
adjustedRange,
skipPattern);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : updateThermalLevel
*
* DESCRIPTION: update thermal level depending on thermal events
*
* PARAMETERS :
* @level : thermal level
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::updateThermalLevel(void *thermal_level)
{
int ret = NO_ERROR;
cam_fps_range_t adjustedRange;
int minFPS, maxFPS;
float minVideoFPS, maxVideoFPS;
enum msm_vfe_frame_skip_pattern skipPattern;
qcamera_thermal_level_enum_t level = *(qcamera_thermal_level_enum_t *)thermal_level;
if (!mCameraOpened) {
LOGH("Camera is not opened, no need to update camera parameters");
return NO_ERROR;
}
if (mParameters.getRecordingHintValue()) {
LOGH("Thermal mitigation isn't enabled in camcorder mode");
return NO_ERROR;
}
mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
qcamera_thermal_mode thermalMode = mParameters.getThermalMode();
if (mParameters.isHfrMode()) {
cam_fps_range_t hfrFpsRange;
mParameters.getHfrFps(hfrFpsRange);
minVideoFPS = hfrFpsRange.video_min_fps;
maxVideoFPS = hfrFpsRange.video_max_fps;
} else {
minVideoFPS = minFPS;
maxVideoFPS = maxFPS;
}
calcThermalLevel(level, minFPS, maxFPS, minVideoFPS, maxVideoFPS,
adjustedRange, skipPattern);
mThermalLevel = level;
if (thermalMode == QCAMERA_THERMAL_ADJUST_FPS)
ret = mParameters.adjustPreviewFpsRange(&adjustedRange);
else if (thermalMode == QCAMERA_THERMAL_ADJUST_FRAMESKIP)
ret = mParameters.setFrameSkip(skipPattern);
else
LOGW("Incorrect thermal mode %d", thermalMode);
return ret;
}
/*===========================================================================
* FUNCTION : updateParameters
*
* DESCRIPTION: update parameters
*
* PARAMETERS :
* @parms : input parameters string
* @needRestart : output, flag to indicate if preview restart is needed
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCamera2HardwareInterface::updateParameters(const char *parms, bool &needRestart)
{
int rc = NO_ERROR;
String8 str = String8(parms);
rc = mParameters.updateParameters(str, needRestart);
setNeedRestart(needRestart);
// update stream based parameter settings
for (int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
if (m_channels[i] != NULL) {
m_channels[i]->UpdateStreamBasedParameters(mParameters);
}
}
return rc;
}
/*===========================================================================
* FUNCTION : commitParameterChanges
*
* DESCRIPTION: commit parameter changes to the backend to take effect
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
* NOTE : This function must be called after updateParameters.
* Otherwise, no change will be passed to backend to take effect.
*==========================================================================*/
int QCamera2HardwareInterface::commitParameterChanges()
{
int rc = NO_ERROR;
rc = mParameters.commitParameters();
if (rc == NO_ERROR) {
// update number of snapshot based on committed parameters setting
rc = mParameters.setNumOfSnapshot();
}
return rc;
}
/*===========================================================================
* FUNCTION : needDebugFps
*
* DESCRIPTION: if fps log info need to be printed out
*
* PARAMETERS : none
*
* RETURN : true: need print out fps log
* false: no need to print out fps log
*==========================================================================*/
bool QCamera2HardwareInterface::needDebugFps()
{
bool needFps = false;
needFps = mParameters.isFpsDebugEnabled();
return needFps;
}
/*===========================================================================
* FUNCTION : isCACEnabled
*
* DESCRIPTION: if CAC is enabled
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::isCACEnabled()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.feature.cac", prop, "0");
int enableCAC = atoi(prop);
return enableCAC == 1;
}
/*===========================================================================
* FUNCTION : is4k2kResolution
*
* DESCRIPTION: if resolution is 4k x 2k or true 4k x 2k
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::is4k2kResolution(cam_dimension_t* resolution)
{
bool enabled = false;
if ((resolution->width == 4096 && resolution->height == 2160) ||
(resolution->width == 3840 && resolution->height == 2160) ) {
enabled = true;
}
return enabled;
}
/*===========================================================================
* FUNCTION : isPreviewRestartEnabled
*
* DESCRIPTION: Check whether preview should be restarted automatically
* during image capture.
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::isPreviewRestartEnabled()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.feature.restart", prop, "0");
int earlyRestart = atoi(prop);
return earlyRestart == 1;
}
/*===========================================================================
* FUNCTION : needReprocess
*
* DESCRIPTION: if reprocess is needed
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::needReprocess()
{
bool needReprocess = false;
if (!mParameters.isJpegPictureFormat() &&
!mParameters.isNV21PictureFormat()) {
// RAW image, no need to reprocess
return false;
}
//Disable reprocess for 4K liveshot case but enable if lowpower mode
if (mParameters.is4k2kVideoResolution() && mParameters.getRecordingHintValue()
&& !isLowPowerMode()) {
return false;
}
// pp feature config
cam_pp_feature_config_t pp_config;
memset(&pp_config, 0, sizeof(cam_pp_feature_config_t));
//Decide whether to do reprocess or not based on
//ppconfig obtained in the first pass.
getPPConfig(pp_config);
if (pp_config.feature_mask > 0) {
needReprocess = true;
}
LOGH("needReprocess %s", needReprocess ? "true" : "false");
return needReprocess;
}
/*===========================================================================
* FUNCTION : needRotationReprocess
*
* DESCRIPTION: if rotation needs to be done by reprocess in pp
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::needRotationReprocess()
{
if (!mParameters.isJpegPictureFormat() &&
!mParameters.isNV21PictureFormat()) {
// RAW image, no need to reprocess
return false;
}
//Disable reprocess for 4K liveshot case
if (mParameters.is4k2kVideoResolution() && mParameters.getRecordingHintValue()
&& !isLowPowerMode()) {
//Disable reprocess for 4K liveshot case
return false;
}
if ((gCamCapability[mCameraId]->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_ROTATION) > 0 &&
(mParameters.getJpegRotation() > 0)) {
// current rotation is not zero, and pp has the capability to process rotation
LOGH("need to do reprocess for rotation=%d",
mParameters.getJpegRotation());
return true;
}
return false;
}
/*===========================================================================
* FUNCTION : getThumbnailSize
*
* DESCRIPTION: get user set thumbnail size
*
* PARAMETERS :
* @dim : output of thumbnail dimension
*
* RETURN : none
*==========================================================================*/
void QCamera2HardwareInterface::getThumbnailSize(cam_dimension_t &dim)
{
mParameters.getThumbnailSize(&dim.width, &dim.height);
}
/*===========================================================================
* FUNCTION : getJpegQuality
*
* DESCRIPTION: get user set jpeg quality
*
* PARAMETERS : none
*
* RETURN : jpeg quality setting
*==========================================================================*/
uint32_t QCamera2HardwareInterface::getJpegQuality()
{
uint32_t quality = 0;
quality = mParameters.getJpegQuality();
return quality;
}
/*===========================================================================
* FUNCTION : getExifData
*
* DESCRIPTION: get exif data to be passed into jpeg encoding
*
* PARAMETERS : none
*
* RETURN : exif data from user setting and GPS
*==========================================================================*/
QCameraExif *QCamera2HardwareInterface::getExifData()
{
QCameraExif *exif = new QCameraExif();
if (exif == NULL) {
LOGE("No memory for QCameraExif");
return NULL;
}
int32_t rc = NO_ERROR;
// add exif entries
String8 dateTime, subSecTime;
rc = mParameters.getExifDateTime(dateTime, subSecTime);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_DATE_TIME, EXIF_ASCII,
(uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
exif->addEntry(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII,
(uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
exif->addEntry(EXIFTAGID_EXIF_DATE_TIME_DIGITIZED, EXIF_ASCII,
(uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
exif->addEntry(EXIFTAGID_SUBSEC_TIME, EXIF_ASCII,
(uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
exif->addEntry(EXIFTAGID_SUBSEC_TIME_ORIGINAL, EXIF_ASCII,
(uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
exif->addEntry(EXIFTAGID_SUBSEC_TIME_DIGITIZED, EXIF_ASCII,
(uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
} else {
LOGW("getExifDateTime failed");
}
rat_t focalLength;
rc = mParameters.getExifFocalLength(&focalLength);
if (rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_FOCAL_LENGTH,
EXIF_RATIONAL,
1,
(void *)&(focalLength));
} else {
LOGW("getExifFocalLength failed");
}
uint16_t isoSpeed = mParameters.getExifIsoSpeed();
if (getSensorType() != CAM_SENSOR_YUV) {
exif->addEntry(EXIFTAGID_ISO_SPEED_RATING,
EXIF_SHORT,
1,
(void *)&(isoSpeed));
}
char gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE];
uint32_t count = 0;
/*gps data might not be available */
rc = mParameters.getExifGpsProcessingMethod(gpsProcessingMethod, count);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_GPS_PROCESSINGMETHOD,
EXIF_ASCII,
count,
(void *)gpsProcessingMethod);
} else {
LOGW("getExifGpsProcessingMethod failed");
}
rat_t latitude[3];
char latRef[2];
rc = mParameters.getExifLatitude(latitude, latRef);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_GPS_LATITUDE,
EXIF_RATIONAL,
3,
(void *)latitude);
exif->addEntry(EXIFTAGID_GPS_LATITUDE_REF,
EXIF_ASCII,
2,
(void *)latRef);
} else {
LOGW("getExifLatitude failed");
}
rat_t longitude[3];
char lonRef[2];
rc = mParameters.getExifLongitude(longitude, lonRef);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_GPS_LONGITUDE,
EXIF_RATIONAL,
3,
(void *)longitude);
exif->addEntry(EXIFTAGID_GPS_LONGITUDE_REF,
EXIF_ASCII,
2,
(void *)lonRef);
} else {
LOGW("getExifLongitude failed");
}
rat_t altitude;
char altRef;
rc = mParameters.getExifAltitude(&altitude, &altRef);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_GPS_ALTITUDE,
EXIF_RATIONAL,
1,
(void *)&(altitude));
exif->addEntry(EXIFTAGID_GPS_ALTITUDE_REF,
EXIF_BYTE,
1,
(void *)&altRef);
} else {
LOGW("getExifAltitude failed");
}
char gpsDateStamp[20];
rat_t gpsTimeStamp[3];
rc = mParameters.getExifGpsDateTimeStamp(gpsDateStamp, 20, gpsTimeStamp);
if(rc == NO_ERROR) {
exif->addEntry(EXIFTAGID_GPS_DATESTAMP,
EXIF_ASCII,
(uint32_t)(strlen(gpsDateStamp) + 1),
(void *)gpsDateStamp);
exif->addEntry(EXIFTAGID_GPS_TIMESTAMP,
EXIF_RATIONAL,
3,
(void *)gpsTimeStamp);
} else {
LOGW("getExifGpsDataTimeStamp failed");
}
#ifdef ENABLE_MODEL_INFO_EXIF
char value[PROPERTY_VALUE_MAX];
if (property_get("persist.sys.exif.make", value, "") > 0 ||
property_get("ro.product.manufacturer", value, "QCOM-AA") > 0) {
exif->addEntry(EXIFTAGID_MAKE,
EXIF_ASCII, strlen(value) + 1, (void *)value);
} else {
LOGW("getExifMaker failed");
}
if (property_get("persist.sys.exif.model", value, "") > 0 ||
property_get("ro.product.model", value, "QCAM-AA") > 0) {
exif->addEntry(EXIFTAGID_MODEL,
EXIF_ASCII, strlen(value) + 1, (void *)value);
} else {
LOGW("getExifModel failed");
}
if (property_get("ro.build.description", value, "QCAM-AA") > 0) {
exif->addEntry(EXIFTAGID_SOFTWARE, EXIF_ASCII,
(uint32_t)(strlen(value) + 1), (void *)value);
} else {
LOGW("getExifSoftware failed");
}
#endif
if (mParameters.useJpegExifRotation()) {
int16_t orientation;
switch (mParameters.getJpegExifRotation()) {
case 0:
orientation = 1;
break;
case 90:
orientation = 6;
break;
case 180:
orientation = 3;
break;
case 270:
orientation = 8;
break;
default:
orientation = 1;
break;
}
exif->addEntry(EXIFTAGID_ORIENTATION,
EXIF_SHORT,
1,
(void *)&orientation);
exif->addEntry(EXIFTAGID_TN_ORIENTATION,
EXIF_SHORT,
1,
(void *)&orientation);
}
return exif;
}
/*===========================================================================
* FUNCTION : setHistogram
*
* DESCRIPTION: set if histogram should be enabled
*
* PARAMETERS :
* @histogram_en : bool flag if histogram should be enabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setHistogram(bool histogram_en)
{
return mParameters.setHistogram(histogram_en);
}
/*===========================================================================
* FUNCTION : setFaceDetection
*
* DESCRIPTION: set if face detection should be enabled
*
* PARAMETERS :
* @enabled : bool flag if face detection should be enabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setFaceDetection(bool enabled)
{
return mParameters.setFaceDetection(enabled, true);
}
/*===========================================================================
* FUNCTION : isCaptureShutterEnabled
*
* DESCRIPTION: Check whether shutter should be triggered immediately after
* capture
*
* PARAMETERS :
*
* RETURN : true - regular capture
* false - other type of capture
*==========================================================================*/
bool QCamera2HardwareInterface::isCaptureShutterEnabled()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.feature.shutter", prop, "0");
int enableShutter = atoi(prop);
return enableShutter == 1;
}
/*===========================================================================
* FUNCTION : needProcessPreviewFrame
*
* DESCRIPTION: returns whether preview frame need to be displayed
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
bool QCamera2HardwareInterface::needProcessPreviewFrame()
{
return m_stateMachine.isPreviewRunning()
&& m_stateMachine.isDisplayFrameNeeded();
};
/*===========================================================================
* FUNCTION : needSendPreviewCallback
*
* DESCRIPTION: returns whether preview frame need to callback to APP
*
* PARAMETERS :
*
* RETURN : true - need preview frame callbck
* false - not send preview frame callback
*==========================================================================*/
bool QCamera2HardwareInterface::needSendPreviewCallback()
{
return m_stateMachine.isPreviewRunning()
&& (mDataCb != NULL)
&& (msgTypeEnabledWithLock(CAMERA_MSG_PREVIEW_FRAME) > 0)
&& m_stateMachine.isPreviewCallbackNeeded();
};
/*===========================================================================
* FUNCTION : prepareHardwareForSnapshot
*
* DESCRIPTION: prepare hardware for snapshot, such as LED
*
* PARAMETERS :
* @afNeeded: flag indicating if Auto Focus needs to be done during preparation
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::prepareHardwareForSnapshot(int32_t afNeeded)
{
ATRACE_CALL();
LOGI("[KPI Perf]: Send PREPARE SANSPHOT event");
return mCameraHandle->ops->prepare_snapshot(mCameraHandle->camera_handle,
afNeeded);
}
/*===========================================================================
* FUNCTION : needFDMetadata
*
* DESCRIPTION: check whether we need process Face Detection metadata in this chanel
*
* PARAMETERS :
* @channel_type: channel type
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCamera2HardwareInterface::needFDMetadata(qcamera_ch_type_enum_t channel_type)
{
//Note: Currently we only process ZSL channel
bool value = false;
if(channel_type == QCAMERA_CH_TYPE_ZSL){
//check if FD requirement is enabled
if(mParameters.isSnapshotFDNeeded() &&
mParameters.isFaceDetectionEnabled()){
value = true;
LOGH("Face Detection metadata is required in ZSL mode.");
}
}
return value;
}
/*===========================================================================
* FUNCTION : deferredWorkRoutine
*
* DESCRIPTION: data process routine that executes deferred tasks
*
* PARAMETERS :
* @data : user data ptr (QCamera2HardwareInterface)
*
* RETURN : None
*==========================================================================*/
void *QCamera2HardwareInterface::deferredWorkRoutine(void *obj)
{
int running = 1;
int ret;
uint8_t is_active = FALSE;
int32_t job_status = 0;
QCamera2HardwareInterface *pme = (QCamera2HardwareInterface *)obj;
QCameraCmdThread *cmdThread = &pme->mDeferredWorkThread;
cmdThread->setName("CAM_defrdWrk");
do {
do {
ret = cam_sem_wait(&cmdThread->cmd_sem);
if (ret != 0 && errno != EINVAL) {
LOGE("cam_sem_wait error (%s)",
strerror(errno));
return NULL;
}
} while (ret != 0);
// we got notified about new cmd avail in cmd queue
camera_cmd_type_t cmd = cmdThread->getCmd();
LOGD("cmd: %d", cmd);
switch (cmd) {
case CAMERA_CMD_TYPE_START_DATA_PROC:
LOGH("start data proc");
is_active = TRUE;
break;
case CAMERA_CMD_TYPE_STOP_DATA_PROC:
LOGH("stop data proc");
is_active = FALSE;
// signal cmd is completed
cam_sem_post(&cmdThread->sync_sem);
break;
case CAMERA_CMD_TYPE_DO_NEXT_JOB:
{
DefWork *dw =
reinterpret_cast<DefWork *>(pme->mCmdQueue.dequeue());
if ( NULL == dw ) {
LOGE("Invalid deferred work");
break;
}
switch( dw->cmd ) {
case CMD_DEF_ALLOCATE_BUFF:
{
QCameraChannel * pChannel = dw->args.allocArgs.ch;
if ( NULL == pChannel ) {
LOGE("Invalid deferred work channel");
job_status = BAD_VALUE;
break;
}
cam_stream_type_t streamType = dw->args.allocArgs.type;
LOGH("Deferred buffer allocation started for stream type: %d",
streamType);
uint32_t iNumOfStreams = pChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
for ( uint32_t i = 0; i < iNumOfStreams; ++i) {
pStream = pChannel->getStreamByIndex(i);
if ( NULL == pStream ) {
job_status = BAD_VALUE;
break;
}
if ( pStream->isTypeOf(streamType)) {
if ( pStream->allocateBuffers() ) {
LOGE("Error allocating buffers !!!");
job_status = NO_MEMORY;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
}
break;
}
}
}
break;
case CMD_DEF_PPROC_START:
{
int32_t ret = pme->getDefJobStatus(pme->mInitPProcJob);
if (ret != NO_ERROR) {
job_status = ret;
LOGE("PPROC Start failed");
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
QCameraChannel * pChannel = dw->args.pprocArgs;
assert(pChannel);
if (pme->m_postprocessor.start(pChannel) != NO_ERROR) {
LOGE("cannot start postprocessor");
job_status = BAD_VALUE;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
}
}
break;
case CMD_DEF_METADATA_ALLOC:
{
int32_t ret = pme->getDefJobStatus(pme->mParamAllocJob);
if (ret != NO_ERROR) {
job_status = ret;
LOGE("Metadata alloc failed");
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
pme->mMetadataMem = new QCameraMetadataStreamMemory(
QCAMERA_ION_USE_CACHE);
if (pme->mMetadataMem == NULL) {
LOGE("Unable to allocate metadata buffers");
job_status = BAD_VALUE;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
} else {
int32_t rc = pme->mMetadataMem->allocate(
dw->args.metadataAllocArgs.bufferCnt,
dw->args.metadataAllocArgs.size,
NON_SECURE);
if (rc < 0) {
delete pme->mMetadataMem;
pme->mMetadataMem = NULL;
}
}
}
break;
case CMD_DEF_CREATE_JPEG_SESSION:
{
QCameraChannel * pChannel = dw->args.pprocArgs;
assert(pChannel);
if (pme->m_postprocessor.createJpegSession(pChannel)
!= NO_ERROR) {
LOGE("cannot create JPEG session");
job_status = UNKNOWN_ERROR;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
}
}
break;
case CMD_DEF_PPROC_INIT:
{
int32_t rc = NO_ERROR;
jpeg_encode_callback_t jpegEvtHandle =
dw->args.pprocInitArgs.jpeg_cb;
void* user_data = dw->args.pprocInitArgs.user_data;
QCameraPostProcessor *postProcessor =
&(pme->m_postprocessor);
uint32_t cameraId = pme->mCameraId;
cam_capability_t *capability =
gCamCapability[cameraId];
cam_padding_info_t padding_info;
cam_padding_info_t& cam_capability_padding_info =
capability->padding_info;
if(!pme->mJpegClientHandle) {
rc = pme->initJpegHandle();
if (rc != NO_ERROR) {
LOGE("Error!! creating JPEG handle failed");
job_status = UNKNOWN_ERROR;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
}
LOGH("mJpegClientHandle : %d", pme->mJpegClientHandle);
rc = postProcessor->setJpegHandle(&pme->mJpegHandle,
&pme->mJpegMpoHandle,
pme->mJpegClientHandle);
if (rc != 0) {
LOGE("Error!! set JPEG handle failed");
job_status = UNKNOWN_ERROR;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
/* get max pic size for jpeg work buf calculation*/
rc = postProcessor->init(jpegEvtHandle, user_data);
if (rc != NO_ERROR) {
LOGE("cannot init postprocessor");
job_status = UNKNOWN_ERROR;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
// update padding info from jpeg
postProcessor->getJpegPaddingReq(padding_info);
if (cam_capability_padding_info.width_padding <
padding_info.width_padding) {
cam_capability_padding_info.width_padding =
padding_info.width_padding;
}
if (cam_capability_padding_info.height_padding <
padding_info.height_padding) {
cam_capability_padding_info.height_padding =
padding_info.height_padding;
}
if (cam_capability_padding_info.plane_padding !=
padding_info.plane_padding) {
cam_capability_padding_info.plane_padding =
mm_stream_calc_lcm(
cam_capability_padding_info.plane_padding,
padding_info.plane_padding);
}
if (cam_capability_padding_info.offset_info.offset_x
!= padding_info.offset_info.offset_x) {
cam_capability_padding_info.offset_info.offset_x =
mm_stream_calc_lcm (
cam_capability_padding_info.offset_info.offset_x,
padding_info.offset_info.offset_x);
}
if (cam_capability_padding_info.offset_info.offset_y
!= padding_info.offset_info.offset_y) {
cam_capability_padding_info.offset_info.offset_y =
mm_stream_calc_lcm (
cam_capability_padding_info.offset_info.offset_y,
padding_info.offset_info.offset_y);
}
}
break;
case CMD_DEF_PARAM_ALLOC:
{
int32_t rc = pme->mParameters.allocate();
// notify routine would not be initialized by this time.
// So, just update error job status
if (rc != NO_ERROR) {
job_status = rc;
LOGE("Param allocation failed");
break;
}
}
break;
case CMD_DEF_PARAM_INIT:
{
int32_t rc = pme->getDefJobStatus(pme->mParamAllocJob);
if (rc != NO_ERROR) {
job_status = rc;
LOGE("Param init failed");
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
uint32_t camId = pme->mCameraId;
cam_capability_t * cap = gCamCapability[camId];
if (pme->mCameraHandle == NULL) {
LOGE("Camera handle is null");
job_status = BAD_VALUE;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
// Now PostProc need calibration data as initialization
// time for jpeg_open and calibration data is a
// get param for now, so params needs to be initialized
// before postproc init
rc = pme->mParameters.init(cap,
pme->mCameraHandle,
pme);
if (rc != 0) {
job_status = UNKNOWN_ERROR;
LOGE("Parameter Initialization failed");
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
// Get related cam calibration only in
// dual camera mode
if (pme->getRelatedCamSyncInfo()->sync_control ==
CAM_SYNC_RELATED_SENSORS_ON) {
rc = pme->mParameters.getRelatedCamCalibration(
&(pme->mJpegMetadata.otp_calibration_data));
LOGD("Dumping Calibration Data Version Id %f rc %d",
pme->mJpegMetadata.otp_calibration_data.calibration_format_version,
rc);
if (rc != 0) {
job_status = UNKNOWN_ERROR;
LOGE("getRelatedCamCalibration failed");
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
pme->m_bRelCamCalibValid = true;
}
pme->mJpegMetadata.sensor_mount_angle =
cap->sensor_mount_angle;
pme->mJpegMetadata.default_sensor_flip = FLIP_NONE;
pme->mParameters.setMinPpMask(
cap->qcom_supported_feature_mask);
pme->mExifParams.debug_params =
(mm_jpeg_debug_exif_params_t *)
malloc(sizeof(mm_jpeg_debug_exif_params_t));
if (!pme->mExifParams.debug_params) {
LOGE("Out of Memory. Allocation failed for "
"3A debug exif params");
job_status = NO_MEMORY;
pme->sendEvtNotify(CAMERA_MSG_ERROR,
CAMERA_ERROR_UNKNOWN, 0);
break;
}
memset(pme->mExifParams.debug_params, 0,
sizeof(mm_jpeg_debug_exif_params_t));
}
break;
case CMD_DEF_GENERIC:
{
BackgroundTask *bgTask = dw->args.genericArgs;
job_status = bgTask->bgFunction(bgTask->bgArgs);
}
break;
default:
LOGE("Incorrect command : %d", dw->cmd);
}
pme->dequeueDeferredWork(dw, job_status);
}
break;
case CAMERA_CMD_TYPE_EXIT:
running = 0;
break;
default:
break;
}
} while (running);
return NULL;
}
/*===========================================================================
* FUNCTION : queueDeferredWork
*
* DESCRIPTION: function which queues deferred tasks
*
* PARAMETERS :
* @cmd : deferred task
* @args : deferred task arguments
*
* RETURN : job id of deferred job
* : 0 in case of error
*==========================================================================*/
uint32_t QCamera2HardwareInterface::queueDeferredWork(DeferredWorkCmd cmd,
DeferWorkArgs args)
{
Mutex::Autolock l(mDefLock);
for (int32_t i = 0; i < MAX_ONGOING_JOBS; ++i) {
if (mDefOngoingJobs[i].mDefJobId == 0) {
DefWork *dw = new DefWork(cmd, sNextJobId, args);
if (!dw) {
LOGE("out of memory.");
return 0;
}
if (mCmdQueue.enqueue(dw)) {
mDefOngoingJobs[i].mDefJobId = sNextJobId++;
mDefOngoingJobs[i].mDefJobStatus = 0;
if (sNextJobId == 0) { // handle overflow
sNextJobId = 1;
}
mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB,
FALSE,
FALSE);
return mDefOngoingJobs[i].mDefJobId;
} else {
LOGD("Command queue not active! cmd = %d", cmd);
delete dw;
return 0;
}
}
}
return 0;
}
/*===========================================================================
* FUNCTION : initJpegHandle
*
* DESCRIPTION: Opens JPEG client and gets a handle.
* Sends Dual cam calibration info if present
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::initJpegHandle() {
// Check if JPEG client handle is present
LOGH("E");
if(!mJpegClientHandle) {
mm_dimension max_size = {0, 0};
cam_dimension_t size;
mParameters.getMaxPicSize(size);
max_size.w = size.width;
max_size.h = size.height;
if (getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
if (m_bRelCamCalibValid) {
mJpegClientHandle = jpeg_open(&mJpegHandle, &mJpegMpoHandle,
max_size, &mJpegMetadata);
} else {
mJpegClientHandle = jpeg_open(&mJpegHandle, &mJpegMpoHandle,
max_size, NULL);
}
} else {
mJpegClientHandle = jpeg_open(&mJpegHandle, NULL, max_size, NULL);
}
if (!mJpegClientHandle) {
LOGE("Error !! jpeg_open failed!! ");
return UNKNOWN_ERROR;
}
// Set JPEG initialized as true to signify that this camera
// has initialized the handle
mJpegHandleOwner = true;
}
LOGH("X mJpegHandleOwner: %d, mJpegClientHandle: %d camera id: %d",
mJpegHandleOwner, mJpegClientHandle, mCameraId);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : deinitJpegHandle
*
* DESCRIPTION: Closes JPEG client using handle
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::deinitJpegHandle() {
int32_t rc = NO_ERROR;
LOGH("E");
// Check if JPEG client handle is present and inited by this camera
if(mJpegHandleOwner && mJpegClientHandle) {
rc = mJpegHandle.close(mJpegClientHandle);
if (rc != NO_ERROR) {
LOGE("Error!! Closing mJpegClientHandle: %d failed",
mJpegClientHandle);
}
memset(&mJpegHandle, 0, sizeof(mJpegHandle));
memset(&mJpegMpoHandle, 0, sizeof(mJpegMpoHandle));
mJpegHandleOwner = false;
}
mJpegClientHandle = 0;
LOGH("X rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : setJpegHandleInfo
*
* DESCRIPTION: sets JPEG client handle info
*
* PARAMETERS:
* @ops : JPEG ops
* @mpo_ops : Jpeg MPO ops
* @pJpegClientHandle : o/p Jpeg Client Handle
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::setJpegHandleInfo(mm_jpeg_ops_t *ops,
mm_jpeg_mpo_ops_t *mpo_ops, uint32_t pJpegClientHandle) {
if (pJpegClientHandle && ops && mpo_ops) {
LOGH("Setting JPEG client handle %d",
pJpegClientHandle);
memcpy(&mJpegHandle, ops, sizeof(mm_jpeg_ops_t));
memcpy(&mJpegMpoHandle, mpo_ops, sizeof(mm_jpeg_mpo_ops_t));
mJpegClientHandle = pJpegClientHandle;
return NO_ERROR;
}
else {
LOGE("Error!! No Handle found: %d",
pJpegClientHandle);
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : getJpegHandleInfo
*
* DESCRIPTION: gets JPEG client handle info
*
* PARAMETERS:
* @ops : JPEG ops
* @mpo_ops : Jpeg MPO ops
* @pJpegClientHandle : o/p Jpeg Client Handle
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::getJpegHandleInfo(mm_jpeg_ops_t *ops,
mm_jpeg_mpo_ops_t *mpo_ops, uint32_t *pJpegClientHandle) {
if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
LOGE("Init PProc Deferred work failed");
return UNKNOWN_ERROR;
}
// Copy JPEG ops if present
if (ops && mpo_ops && pJpegClientHandle) {
memcpy(ops, &mJpegHandle, sizeof(mm_jpeg_ops_t));
memcpy(mpo_ops, &mJpegMpoHandle, sizeof(mm_jpeg_mpo_ops_t));
*pJpegClientHandle = mJpegClientHandle;
LOGH("Getting JPEG client handle %d",
pJpegClientHandle);
return NO_ERROR;
} else {
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : dequeueDeferredWork
*
* DESCRIPTION: function which dequeues deferred tasks
*
* PARAMETERS :
* @dw : deferred work
* @jobStatus: deferred task job status
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
uint32_t QCamera2HardwareInterface::dequeueDeferredWork(DefWork* dw, int32_t jobStatus)
{
Mutex::Autolock l(mDefLock);
for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
if (mDefOngoingJobs[i].mDefJobId == dw->id) {
if (jobStatus != NO_ERROR) {
mDefOngoingJobs[i].mDefJobStatus = jobStatus;
LOGH("updating job status %d for id %d",
jobStatus, dw->id);
} else {
mDefOngoingJobs[i].mDefJobId = 0;
mDefOngoingJobs[i].mDefJobStatus = 0;
}
delete dw;
mDefCond.broadcast();
return NO_ERROR;
}
}
return UNKNOWN_ERROR;
}
/*===========================================================================
* FUNCTION : getDefJobStatus
*
* DESCRIPTION: Gets if a deferred task is success/fail
*
* PARAMETERS :
* @job_id : deferred task id
*
* RETURN : NO_ERROR if the job success, otherwise false
*
* PRECONDITION : mDefLock is held by current thread
*==========================================================================*/
int32_t QCamera2HardwareInterface::getDefJobStatus(uint32_t &job_id)
{
for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
if (mDefOngoingJobs[i].mDefJobId == job_id) {
if ( NO_ERROR != mDefOngoingJobs[i].mDefJobStatus ) {
LOGE("job_id (%d) was failed", job_id);
return mDefOngoingJobs[i].mDefJobStatus;
}
else
return NO_ERROR;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : checkDeferredWork
*
* DESCRIPTION: checks if a deferred task is in progress
*
* PARAMETERS :
* @job_id : deferred task id
*
* RETURN : true if the task exists, otherwise false
*
* PRECONDITION : mDefLock is held by current thread
*==========================================================================*/
bool QCamera2HardwareInterface::checkDeferredWork(uint32_t &job_id)
{
for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
if (mDefOngoingJobs[i].mDefJobId == job_id) {
return (NO_ERROR == mDefOngoingJobs[i].mDefJobStatus);
}
}
return false;
}
/*===========================================================================
* FUNCTION : waitDeferredWork
*
* DESCRIPTION: waits for a deferred task to finish
*
* PARAMETERS :
* @job_id : deferred task id
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::waitDeferredWork(uint32_t &job_id)
{
Mutex::Autolock l(mDefLock);
if (job_id == 0) {
LOGD("Invalid job id %d", job_id);
return NO_ERROR;
}
while (checkDeferredWork(job_id) == true ) {
mDefCond.waitRelative(mDefLock, CAMERA_DEFERRED_THREAD_TIMEOUT);
}
return getDefJobStatus(job_id);
}
/*===========================================================================
* FUNCTION : scheduleBackgroundTask
*
* DESCRIPTION: Run a requested task in the deferred thread
*
* PARAMETERS :
* @bgTask : Task to perform in the background
*
* RETURN : job id of deferred job
* : 0 in case of error
*==========================================================================*/
uint32_t QCamera2HardwareInterface::scheduleBackgroundTask(BackgroundTask* bgTask)
{
DeferWorkArgs args;
memset(&args, 0, sizeof(DeferWorkArgs));
args.genericArgs = bgTask;
return queueDeferredWork(CMD_DEF_GENERIC, args);
}
/*===========================================================================
* FUNCTION : waitForBackgroundTask
*
* DESCRIPTION: Wait for a background task to complete
*
* PARAMETERS :
* @taskId : Task id to wait for
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::waitForBackgroundTask(uint32_t& taskId)
{
return waitDeferredWork(taskId);
}
/*===========================================================================
* FUNCTION : needDeferedAllocation
*
* DESCRIPTION: Function to decide background task for streams
*
* PARAMETERS :
* @stream_type : stream type
*
* RETURN : true - if background task is needed
* false - if background task is NOT needed
*==========================================================================*/
bool QCamera2HardwareInterface::needDeferred(cam_stream_type_t stream_type)
{
if ((stream_type == CAM_STREAM_TYPE_PREVIEW && mPreviewWindow == NULL)
|| (stream_type == CAM_STREAM_TYPE_ANALYSIS)) {
return FALSE;
}
if ((stream_type == CAM_STREAM_TYPE_RAW)
&& (mParameters.getofflineRAW())) {
return FALSE;
}
if ((stream_type == CAM_STREAM_TYPE_SNAPSHOT)
&& (!mParameters.getRecordingHintValue())){
return TRUE;
}
if ((stream_type == CAM_STREAM_TYPE_PREVIEW)
|| (stream_type == CAM_STREAM_TYPE_METADATA)
|| (stream_type == CAM_STREAM_TYPE_RAW)
|| (stream_type == CAM_STREAM_TYPE_POSTVIEW)) {
return TRUE;
}
if (stream_type == CAM_STREAM_TYPE_VIDEO) {
return FALSE;
}
return FALSE;
}
/*===========================================================================
* FUNCTION : isRegularCapture
*
* DESCRIPTION: Check configuration for regular catpure
*
* PARAMETERS :
*
* RETURN : true - regular capture
* false - other type of capture
*==========================================================================*/
bool QCamera2HardwareInterface::isRegularCapture()
{
bool ret = false;
if (numOfSnapshotsExpected() == 1 &&
!isLongshotEnabled() &&
!mParameters.isHDREnabled() &&
!mParameters.getRecordingHintValue() &&
!isZSLMode() && !mParameters.getofflineRAW()) {
ret = true;
}
return ret;
}
/*===========================================================================
* FUNCTION : getLogLevel
*
* DESCRIPTION: Reads the log level property into a variable
*
* PARAMETERS :
* None
*
* RETURN :
* None
*==========================================================================*/
void QCamera2HardwareInterface::getLogLevel()
{
char prop[PROPERTY_VALUE_MAX];
property_get("persist.camera.kpi.debug", prop, "1");
gKpiDebugLevel = atoi(prop);
return;
}
/*===========================================================================
* FUNCTION : getSensorType
*
* DESCRIPTION: Returns the type of sensor being used whether YUV or Bayer
*
* PARAMETERS :
* None
*
* RETURN : Type of sensor - bayer or YUV
*
*==========================================================================*/
cam_sensor_t QCamera2HardwareInterface::getSensorType()
{
return gCamCapability[mCameraId]->sensor_type.sens_type;
}
/*===========================================================================
* FUNCTION : startRAWChannel
*
* DESCRIPTION: start RAW Channel
*
* PARAMETERS :
* @pChannel : Src channel to link this RAW channel.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::startRAWChannel(QCameraChannel *pMetaChannel)
{
int32_t rc = NO_ERROR;
QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_RAW];
if ((NULL != pChannel) && (mParameters.getofflineRAW())) {
// Find and try to link a metadata stream from preview channel
QCameraStream *pMetaStream = NULL;
if (pMetaChannel != NULL) {
uint32_t streamNum = pMetaChannel->getNumOfStreams();
QCameraStream *pStream = NULL;
for (uint32_t i = 0 ; i < streamNum ; i++ ) {
pStream = pMetaChannel->getStreamByIndex(i);
if ((NULL != pStream) &&
(CAM_STREAM_TYPE_METADATA == pStream->getMyType())) {
pMetaStream = pStream;
break;
}
}
if (NULL != pMetaStream) {
rc = pChannel->linkStream(pMetaChannel, pMetaStream);
if (NO_ERROR != rc) {
LOGE("Metadata stream link failed %d", rc);
}
}
}
rc = pChannel->start();
}
return rc;
}
/*===========================================================================
* FUNCTION : startRecording
*
* DESCRIPTION: start recording impl
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera2HardwareInterface::stopRAWChannel()
{
int32_t rc = NO_ERROR;
rc = stopChannel(QCAMERA_CH_TYPE_RAW);
return rc;
}
/*===========================================================================
* FUNCTION : isLowPowerMode
*
* DESCRIPTION: Returns TRUE if low power mode settings are to be applied for video recording
*
* PARAMETERS :
* None
*
* RETURN : TRUE/FALSE
*
*==========================================================================*/
bool QCamera2HardwareInterface::isLowPowerMode()
{
cam_dimension_t dim;
mParameters.getStreamDimension(CAM_STREAM_TYPE_VIDEO, dim);
char prop[PROPERTY_VALUE_MAX];
property_get("camera.lowpower.record.enable", prop, "0");
int enable = atoi(prop);
//Enable low power mode if :
//1. Video resolution is 2k (2048x1080) or above and
//2. camera.lowpower.record.enable is set
bool isLowpower = mParameters.getRecordingHintValue() && enable
&& ((dim.width * dim.height) >= (2048 * 1080));
return isLowpower;
}
}; // namespace qcamera
Reference in a new issue View git blame Copy permalink