msmcobalt: Update to LA.UM.5.7_RB1.07.00.00.251.006
msmcobalt: from hardware/qcom/camera
ca24979 Merge "Merge AU_LINUX_ANDROID_LA.UM.5.7.R1.07.00.00.253.042 on remote branch" into LA.UM.5.7_rb1.4
03dce79 HAL-1: Set the HAL state appropriately when backend notifies error
a8a2835 Merge AU_LINUX_ANDROID_LA.UM.5.7.R1.07.00.00.253.042 on remote branch
5b0c894 Promotion of camera.lnx.1.0-00154.
860df7d QCamera2: FOV-control interface with Spatial alignment block
7d39636 Merge "QCamera2:test: Bug fix to display current saturation value" into camera.lnx.1.0-dev.1.0
f082eac Merge "Add msm8998 to eventually replace msmcobalt. CRs-Fixed: 1087377" into camera.lnx.1.0-dev.1.0
ed09f86 Merge "QCamera2: HAL1: Provide rotation info in meta info." into camera.lnx.1.0-dev.1.0
b7d34e1 Merge "QCamera2: Add new metadata for Spatial Alignment Compute output" into camera.lnx.1.0-dev.1.0
06957fb Merge "QCamera2: HAL1: Changes to enable Low Power mode in dual camera." into camera.lnx.1.0-dev.1.0
918496a Merge "QCamera2: Changes to clean-up dual camera snapshot." into camera.lnx.1.0-dev.1.0
0afbb04 Merge "QCamera2: HAL: Add Spatial transform feature mask" into camera.lnx.1.0-dev.1.0
b5cafe4 Merge "camera: HAL: Add margins to stream size definition" into camera.lnx.1.0-dev.1.0
a983ed9 Promotion of camera.lnx.1.0-00152.
77e0147 Merge "QCamera2: HAL1: Enable CDS feature mask for postview Stream" into camera.lnx.1.0-dev.1.0
5aa82cd Merge "QCamera: Enable IR Mode Auto" into camera.lnx.1.0-dev.1.0
cddb024 Merge "QCamera2: HAL3: Adding SVHDR to PP feature mask." into camera.lnx.1.0-dev.1.0
1b5dbba Merge "QCamera2: Restrict template to maximum of 30 fps." into camera.lnx.1.0-dev.1.0
282f572 Merge "QCamera2: Changes to release video duped FD's." into camera.lnx.1.0-dev.1.0
c3103ed Merge "QCamera2: HAF2.0 : VM related change" into camera.lnx.1.0-dev.1.0
3d6c99b Merge "QCamera2: Add Camscope functionality to the HAL" into camera.lnx.1.0-dev.1.0
4ee41c5 QCamera2: Add new metadata for Spatial Alignment Compute output
6da4fb5 QCamera2: HAL: Add Spatial transform feature mask
05477d4 Merge "QCamera2: Add Setprop to disable Preview TNR" into camera.lnx.1.0-dev.1.0
b59f5fc Add msm8998 to eventually replace msmcobalt. CRs-Fixed: 1087377
234bd8d QCamera2: HAL1: Provide rotation info in meta info.
15945c2 Promotion of camera.lnx.1.0-00146.
3d9d245 QCamera2: Add Camscope functionality to the HAL
5588917 Merge "QCamera2: HAL3: Update the max size for CPP bypass" into camera.lnx.1.0-dev.1.0
161e7c1 Merge "QCamera2: HAL3: Enable HDR snapshot support" into camera.lnx.1.0-dev.1.0
721908c Merge "QCamera2:HAL1: Deleting channel if add stream fails." into camera.lnx.1.0-dev.1.0
d0cda11 Merge "QCamera2:HAL1.0: Add validation to cleanup gralloc memory." into camera.lnx.1.0-dev.1.0
7bac37e Merge "QCamera2: HAL3: Disable PAAF for Callback stream" into camera.lnx.1.0-dev.1.0
482bfc3 Merge "QCamera2: Fix race condition with handleCameraDeviceError." into camera.lnx.1.0-dev.1.0
4173056 camera: HAL: Add margins to stream size definition
77116b5 QCamera2: HAL1: Changes to enable Low Power mode in dual camera.
c9dd09c QCamera2: Changes to clean-up dual camera snapshot.
89114ea QCamera2: HAL3: Update the max size for CPP bypass
66866b1 QCamera2:test: Bug fix to display current saturation value
4187881 QCamera2: HAL3: Enable HDR snapshot support
dc16aa2 QCamera2: HAL3: Adding SVHDR to PP feature mask.
414a270 QCamera2: Add Setprop to disable Preview TNR
aff499c QCamera2:HAL1: Deleting channel if add stream fails.
93ced79 QCamera2: Restrict template to maximum of 30 fps.
d7a9681 QCamera2: HAL1: Enable CDS feature mask for postview Stream
c6c8955 QCamera: Enable IR Mode Auto
4f36254 QCamera2:HAL1.0: Add validation to cleanup gralloc memory.
17b45a0 QCamera2: Changes to release video duped FD's.
75cf1fa QCamera2: HAF2.0 : VM related change
5ed32fc QCamera2: Fix race condition with handleCameraDeviceError.
c234939 QCamera2: HAL3: Disable PAAF for Callback stream
Bug: 33405777
Change-Id: Idf806f076e3e587f21fb63a9f553086c64504910
Signed-off-by: Thierry Strudel <tstrudel@google.com>
diff --git a/msmcobalt/QCamera2/HAL3/QCamera3HWI.cpp b/msmcobalt/QCamera2/HAL3/QCamera3HWI.cpp
index 8fae872..abb2a34 100644
--- a/msmcobalt/QCamera2/HAL3/QCamera3HWI.cpp
+++ b/msmcobalt/QCamera2/HAL3/QCamera3HWI.cpp
@@ -44,6 +44,7 @@
#include "sys/ioctl.h"
#include <sync/sync.h>
#include "gralloc_priv.h"
+#include <map>
// Display dependencies
#include "qdMetaData.h"
@@ -86,6 +87,7 @@
#define MIN_FPS_FOR_BATCH_MODE (120)
#define PREVIEW_FPS_FOR_HFR (30)
#define DEFAULT_VIDEO_FPS (30.0)
+#define TEMPLATE_MAX_PREVIEW_FPS (30.0)
#define MAX_HFR_BATCH_SIZE (8)
#define REGIONS_TUPLE_COUNT 5
#define HDR_PLUS_PERF_TIME_OUT (7000) // milliseconds
@@ -446,6 +448,9 @@
memset(prop, 0, sizeof(prop));
property_get("persist.camera.raw.dump", prop, "0");
mEnableRawDump = atoi(prop);
+ property_get("persist.camera.hal3.force.hdr", prop, "0");
+ mForceHdrSnapshot = atoi(prop);
+
if (mEnableRawDump)
LOGD("Raw dump from Camera HAL enabled");
@@ -457,6 +462,10 @@
m_bTnrPreview = (uint8_t)atoi(prop);
memset(prop, 0, sizeof(prop));
+ property_get("persist.camera.swtnr.preview", prop, "1");
+ m_bSwTnrPreview = (uint8_t)atoi(prop);
+
+ memset(prop, 0, sizeof(prop));
property_get("persist.camera.tnr.video", prop, "0");
m_bTnrVideo = (uint8_t)atoi(prop);
@@ -765,7 +774,7 @@
int rc = 0;
char value[PROPERTY_VALUE_MAX];
- KPI_ATRACE_CALL();
+ KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_OPENCAMERA);
if (mCameraHandle) {
LOGE("Failure: Camera already opened");
return ALREADY_EXISTS;
@@ -878,7 +887,7 @@
*==========================================================================*/
int QCamera3HardwareInterface::closeCamera()
{
- KPI_ATRACE_CALL();
+ KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CLOSECAMERA);
int rc = NO_ERROR;
char value[PROPERTY_VALUE_MAX];
@@ -887,7 +896,7 @@
// unmap memory for related cam sync buffer
mCameraHandle->ops->unmap_buf(mCameraHandle->camera_handle,
- CAM_MAPPING_BUF_TYPE_SYNC_RELATED_SENSORS_BUF);
+ CAM_MAPPING_BUF_TYPE_DUAL_CAM_CMD_BUF);
if (NULL != m_pDualCamCmdHeap) {
m_pDualCamCmdHeap->deallocate();
delete m_pDualCamCmdHeap;
@@ -943,7 +952,7 @@
int QCamera3HardwareInterface::initialize(
const struct camera3_callback_ops *callback_ops)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_INIT);
int rc;
LOGI("E :mCameraId = %d mState = %d", mCameraId, mState);
@@ -1266,6 +1275,10 @@
|= CAM_QCOM_FEATURE_LLVD;
LOGH("Added LLVD SeeMore to pp feature mask");
}
+ if (gCamCapability[mCameraId]->qcom_supported_feature_mask &
+ CAM_QCOM_FEATURE_STAGGERED_VIDEO_HDR) {
+ mStreamConfigInfo.postprocess_mask[stream_idx] |= CAM_QCOM_FEATURE_STAGGERED_VIDEO_HDR;
+ }
break;
}
default:
@@ -1360,7 +1373,7 @@
int QCamera3HardwareInterface::configureStreams(
camera3_stream_configuration_t *streamList)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CFG_STRMS);
int rc = 0;
// Acquire perfLock before configure streams
@@ -1386,7 +1399,7 @@
int QCamera3HardwareInterface::configureStreamsPerfLocked(
camera3_stream_configuration_t *streamList)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CFG_STRMS_PERF_LKD);
int rc = 0;
// Sanity check stream_list
@@ -1953,6 +1966,10 @@
mStreamConfigInfo.postprocess_mask[mStreamConfigInfo.num_streams] &=
~CAM_QCOM_FEATURE_CDS;
}
+ if(!m_bSwTnrPreview) {
+ mStreamConfigInfo.postprocess_mask[mStreamConfigInfo.num_streams] &=
+ ~CAM_QTI_FEATURE_SW_TNR;
+ }
padding_info.width_padding = mSurfaceStridePadding;
padding_info.height_padding = CAM_PAD_TO_2;
}
@@ -2418,7 +2435,8 @@
*
*==========================================================================*/
int QCamera3HardwareInterface::validateCaptureRequest(
- camera3_capture_request_t *request)
+ camera3_capture_request_t *request,
+ List<InternalRequest> &internallyRequestedStreams)
{
ssize_t idx = 0;
const camera3_stream_buffer_t *b;
@@ -2436,7 +2454,8 @@
}
uint32_t frameNumber = request->frame_number;
- if (request->num_output_buffers < 1 || request->output_buffers == NULL) {
+ if ((request->num_output_buffers < 1 || request->output_buffers == NULL)
+ && (internallyRequestedStreams.size() == 0)) {
LOGE("Request %d: No output buffers provided!",
__FUNCTION__, frameNumber);
return BAD_VALUE;
@@ -2467,7 +2486,7 @@
// Validate all buffers
b = request->output_buffers;
- do {
+ while (idx < (ssize_t)request->num_output_buffers) {
QCamera3ProcessingChannel *channel =
static_cast<QCamera3ProcessingChannel*>(b->stream->priv);
if (channel == NULL) {
@@ -2497,8 +2516,7 @@
}
idx++;
b = request->output_buffers + idx;
- } while (idx < (ssize_t)request->num_output_buffers);
-
+ }
return NO_ERROR;
}
@@ -2671,7 +2689,7 @@
for (List<PendingReprocessResult>::iterator j = mPendingReprocessResultList.begin();
j != mPendingReprocessResultList.end(); j++) {
if (j->frame_number == frame_number) {
- mCallbackOps->notify(mCallbackOps, &j->notify_msg);
+ orchestrateNotify(&j->notify_msg);
LOGD("Delayed reprocess notify %d",
frame_number);
@@ -2692,7 +2710,7 @@
result.input_buffer = k->input_buffer;
result.result = k->settings;
result.partial_result = PARTIAL_RESULT_COUNT;
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
erasePendingRequest(k);
break;
@@ -2720,7 +2738,7 @@
void QCamera3HardwareInterface::handleBatchMetadata(
mm_camera_super_buf_t *metadata_buf, bool free_and_bufdone_meta_buf)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_HANDLE_BATCH_METADATA);
if (NULL == metadata_buf) {
LOGE("metadata_buf is NULL");
@@ -2891,7 +2909,7 @@
notify_msg.message.error.error_code = errorCode;
notify_msg.message.error.error_stream = NULL;
notify_msg.message.error.frame_number = frameNumber;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
return;
}
@@ -2913,7 +2931,7 @@
mm_camera_super_buf_t *metadata_buf, bool free_and_bufdone_meta_buf,
bool firstMetadataInBatch)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_HANDLE_METADATA_LKD);
if ((mFlushPerf) || (ERROR == mState) || (DEINIT == mState)) {
//during flush do not send metadata from this thread
LOGD("not sending metadata during flush or when mState is error");
@@ -3016,7 +3034,7 @@
result.output_buffers = NULL;
result.partial_result = i->partial_result_cnt;
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
LOGD("urgent frame_number = %u, capture_time = %lld",
result.frame_number, capture_time);
if (mResetInstantAEC && mInstantAECSettledFrameNumber == 0) {
@@ -3094,7 +3112,7 @@
notify_msg.message.error.frame_number = i->frame_number;
notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_BUFFER ;
notify_msg.message.error.error_stream = j->stream;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
if (p_cam_frame_drop) {
// Treat msg as error for system buffer drops
LOGE("End of reporting error frame#=%u, streamID=%u",
@@ -3144,7 +3162,7 @@
notify_msg.type = CAMERA3_MSG_SHUTTER;
notify_msg.message.shutter.frame_number = i->frame_number;
notify_msg.message.shutter.timestamp = (uint64_t)capture_time;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
i->timestamp = capture_time;
@@ -3169,6 +3187,18 @@
}
}
+ for (auto itr = i->internalRequestList.begin();
+ itr != i->internalRequestList.end(); itr++) {
+ if (itr->need_metadata) {
+ internalPproc = true;
+ QCamera3ProcessingChannel *channel =
+ (QCamera3ProcessingChannel *)itr->stream->priv;
+ channel->queueReprocMetadata(metadata_buf);
+ break;
+ }
+ }
+
+
result.result = translateFromHalMetadata(metadata,
i->timestamp, i->request_id, i->jpegMetadata, i->pipeline_depth,
i->capture_intent, internalPproc, i->fwkCacMode,
@@ -3247,7 +3277,7 @@
}
result.output_buffers = result_buffers;
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
LOGD("meta frame_number = %u, capture_time = %lld",
result.frame_number, i->timestamp);
free_camera_metadata((camera_metadata_t *)result.result);
@@ -3256,7 +3286,7 @@
LOGE("Fatal error: out of memory");
}
} else {
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
LOGD("meta frame_number = %u, capture_time = %lld",
result.frame_number, i->timestamp);
free_camera_metadata((camera_metadata_t *)result.result);
@@ -3328,7 +3358,7 @@
*==========================================================================*/
void QCamera3HardwareInterface::handleInputBufferWithLock(uint32_t frame_number)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_HANDLE_IN_BUF_LKD);
pendingRequestIterator i = mPendingRequestsList.begin();
while (i != mPendingRequestsList.end() && i->frame_number != frame_number){
i++;
@@ -3354,7 +3384,7 @@
notify_msg.type = CAMERA3_MSG_SHUTTER;
notify_msg.message.shutter.frame_number = frame_number;
notify_msg.message.shutter.timestamp = (uint64_t)capture_time;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
i->shutter_notified = true;
LOGD("Input request metadata notify frame_number = %u, capture_time = %llu",
i->frame_number, notify_msg.message.shutter.timestamp);
@@ -3375,7 +3405,7 @@
result.input_buffer = i->input_buffer;
result.partial_result = PARTIAL_RESULT_COUNT;
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
LOGD("Input request metadata and input buffer frame_number = %u",
i->frame_number);
i = erasePendingRequest(i);
@@ -3398,7 +3428,7 @@
void QCamera3HardwareInterface::handleBufferWithLock(
camera3_stream_buffer_t *buffer, uint32_t frame_number)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_HANDLE_BUF_LKD);
if (buffer->stream->format == HAL_PIXEL_FORMAT_BLOB) {
mPerfLockMgr.releasePerfLock(PERF_LOCK_TAKE_SNAPSHOT);
@@ -3454,7 +3484,7 @@
mPendingBuffersMap.removeBuf(buffer->buffer);
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
} else {
if (i->input_buffer) {
CameraMetadata settings;
@@ -3495,8 +3525,8 @@
result.output_buffers = buffer;
result.partial_result = PARTIAL_RESULT_COUNT;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateNotify(¬ify_msg);
+ orchestrateResult(&result);
LOGD("Notify reprocess now %d!", frame_number);
i = erasePendingRequest(i);
} else {
@@ -3547,6 +3577,388 @@
pthread_cond_signal(&mRequestCond);
}
+/*===========================================================================
+ * FUNCTION : isHdrSnapshotRequest
+ *
+ * DESCRIPTION: Function to determine if the request is for a HDR snapshot
+ *
+ * PARAMETERS : camera3 request structure
+ *
+ * RETURN : boolean decision variable
+ *
+ *==========================================================================*/
+bool QCamera3HardwareInterface::isHdrSnapshotRequest(camera3_capture_request *request)
+{
+ if (request == NULL) {
+ LOGE("Invalid request handle");
+ assert(0);
+ return false;
+ }
+
+ if (!mForceHdrSnapshot) {
+ CameraMetadata frame_settings;
+ frame_settings = request->settings;
+
+ if (frame_settings.exists(ANDROID_CONTROL_MODE)) {
+ uint8_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.u8[0];
+ if (metaMode != ANDROID_CONTROL_MODE_USE_SCENE_MODE) {
+ return false;
+ }
+ } else {
+ return false;
+ }
+
+ if (frame_settings.exists(ANDROID_CONTROL_SCENE_MODE)) {
+ uint8_t fwk_sceneMode = frame_settings.find(ANDROID_CONTROL_SCENE_MODE).data.u8[0];
+ if (fwk_sceneMode != ANDROID_CONTROL_SCENE_MODE_HDR) {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ for (uint32_t i = 0; i < request->num_output_buffers; i++) {
+ if (request->output_buffers[i].stream->format
+ == HAL_PIXEL_FORMAT_BLOB) {
+ return true;
+ }
+ }
+
+ return false;
+}
+/*===========================================================================
+ * FUNCTION : orchestrateRequest
+ *
+ * DESCRIPTION: Orchestrates a capture request from camera service
+ *
+ * PARAMETERS :
+ * @request : request from framework to process
+ *
+ * RETURN : Error status codes
+ *
+ *==========================================================================*/
+int32_t QCamera3HardwareInterface::orchestrateRequest(
+ camera3_capture_request_t *request)
+{
+
+ uint32_t originalFrameNumber = request->frame_number;
+ uint32_t originalOutputCount = request->num_output_buffers;
+ const camera_metadata_t *original_settings = request->settings;
+ List<InternalRequest> internallyRequestedStreams;
+ List<InternalRequest> emptyInternalList;
+
+ if (isHdrSnapshotRequest(request) && request->input_buffer == NULL) {
+ LOGD("Framework requested:%d buffers in HDR snapshot", request->num_output_buffers);
+ uint32_t internalFrameNumber;
+ CameraMetadata modified_meta;
+
+
+ /* Add Blob channel to list of internally requested streams */
+ for (uint32_t i = 0; i < request->num_output_buffers; i++) {
+ if (request->output_buffers[i].stream->format
+ == HAL_PIXEL_FORMAT_BLOB) {
+ InternalRequest streamRequested;
+ streamRequested.meteringOnly = 1;
+ streamRequested.need_metadata = 0;
+ streamRequested.stream = request->output_buffers[i].stream;
+ internallyRequestedStreams.push_back(streamRequested);
+ }
+ }
+ request->num_output_buffers = 0;
+ auto itr = internallyRequestedStreams.begin();
+
+ /* Modify setting to set compensation */
+ modified_meta = request->settings;
+ int32_t expCompensation = GB_HDR_HALF_STEP_EV;
+ uint8_t aeLock = 1;
+ modified_meta.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &expCompensation, 1);
+ modified_meta.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
+ camera_metadata_t *modified_settings = modified_meta.release();
+ request->settings = modified_settings;
+
+ /* Capture Settling & -2x frame */
+ _orchestrationDb.generateStoreInternalFrameNumber(internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, internallyRequestedStreams);
+
+ request->num_output_buffers = originalOutputCount;
+ _orchestrationDb.allocStoreInternalFrameNumber(originalFrameNumber, internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, emptyInternalList);
+ request->num_output_buffers = 0;
+
+ modified_meta = modified_settings;
+ expCompensation = 0;
+ aeLock = 1;
+ modified_meta.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &expCompensation, 1);
+ modified_meta.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
+ modified_settings = modified_meta.release();
+ request->settings = modified_settings;
+
+ /* Capture Settling & 0X frame */
+
+ itr = internallyRequestedStreams.begin();
+ if (itr == internallyRequestedStreams.end()) {
+ LOGE("Error Internally Requested Stream list is empty");
+ assert(0);
+ } else {
+ itr->need_metadata = 0;
+ itr->meteringOnly = 1;
+ }
+
+ _orchestrationDb.generateStoreInternalFrameNumber(internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, internallyRequestedStreams);
+
+ itr = internallyRequestedStreams.begin();
+ if (itr == internallyRequestedStreams.end()) {
+ ALOGE("Error Internally Requested Stream list is empty");
+ assert(0);
+ } else {
+ itr->need_metadata = 1;
+ itr->meteringOnly = 0;
+ }
+
+ _orchestrationDb.generateStoreInternalFrameNumber(internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, internallyRequestedStreams);
+
+ /* Capture 2X frame*/
+ modified_meta = modified_settings;
+ expCompensation = GB_HDR_2X_STEP_EV;
+ aeLock = 1;
+ modified_meta.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &expCompensation, 1);
+ modified_meta.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
+ modified_settings = modified_meta.release();
+ request->settings = modified_settings;
+
+ itr = internallyRequestedStreams.begin();
+ if (itr == internallyRequestedStreams.end()) {
+ ALOGE("Error Internally Requested Stream list is empty");
+ assert(0);
+ } else {
+ itr->need_metadata = 0;
+ itr->meteringOnly = 1;
+ }
+ _orchestrationDb.generateStoreInternalFrameNumber(internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, internallyRequestedStreams);
+
+ itr = internallyRequestedStreams.begin();
+ if (itr == internallyRequestedStreams.end()) {
+ ALOGE("Error Internally Requested Stream list is empty");
+ assert(0);
+ } else {
+ itr->need_metadata = 1;
+ itr->meteringOnly = 0;
+ }
+
+ _orchestrationDb.generateStoreInternalFrameNumber(internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ processCaptureRequest(request, internallyRequestedStreams);
+
+
+ /* Capture 2X on original streaming config*/
+ internallyRequestedStreams.clear();
+
+ /* Restore original settings pointer */
+ request->settings = original_settings;
+ } else {
+ uint32_t internalFrameNumber;
+ _orchestrationDb.allocStoreInternalFrameNumber(request->frame_number, internalFrameNumber);
+ request->frame_number = internalFrameNumber;
+ return processCaptureRequest(request, internallyRequestedStreams);
+ }
+
+ return NO_ERROR;
+}
+
+/*===========================================================================
+ * FUNCTION : orchestrateResult
+ *
+ * DESCRIPTION: Orchestrates a capture result to camera service
+ *
+ * PARAMETERS :
+ * @request : request from framework to process
+ *
+ * RETURN :
+ *
+ *==========================================================================*/
+void QCamera3HardwareInterface::orchestrateResult(
+ camera3_capture_result_t *result)
+{
+ uint32_t frameworkFrameNumber;
+ int32_t rc = _orchestrationDb.getFrameworkFrameNumber(result->frame_number,
+ frameworkFrameNumber);
+ if (rc != NO_ERROR) {
+ LOGE("Cannot find translated frameworkFrameNumber");
+ assert(0);
+ } else {
+ if (frameworkFrameNumber == EMPTY_FRAMEWORK_FRAME_NUMBER) {
+ LOGD("CAM_DEBUG Internal Request drop the result");
+ } else {
+ result->frame_number = frameworkFrameNumber;
+ mCallbackOps->process_capture_result(mCallbackOps, result);
+ }
+ }
+}
+
+/*===========================================================================
+ * FUNCTION : orchestrateNotify
+ *
+ * DESCRIPTION: Orchestrates a notify to camera service
+ *
+ * PARAMETERS :
+ * @request : request from framework to process
+ *
+ * RETURN :
+ *
+ *==========================================================================*/
+void QCamera3HardwareInterface::orchestrateNotify(camera3_notify_msg_t *notify_msg)
+{
+ uint32_t frameworkFrameNumber;
+ uint32_t internalFrameNumber = notify_msg->message.shutter.frame_number;
+ int32_t rc = _orchestrationDb.getFrameworkFrameNumber(internalFrameNumber,
+ frameworkFrameNumber);
+ if (rc != NO_ERROR) {
+ LOGE("Cannot find translated frameworkFrameNumber");
+ assert(0);
+ } else {
+ if (frameworkFrameNumber == EMPTY_FRAMEWORK_FRAME_NUMBER) {
+ LOGE("CAM_DEBUG Internal Request drop the notifyCb");
+ } else {
+ notify_msg->message.shutter.frame_number = frameworkFrameNumber;
+ mCallbackOps->notify(mCallbackOps, notify_msg);
+ }
+ }
+}
+
+/*===========================================================================
+ * FUNCTION : FrameNumberRegistry
+ *
+ * DESCRIPTION: Constructor
+ *
+ * PARAMETERS :
+ *
+ * RETURN :
+ *
+ *==========================================================================*/
+FrameNumberRegistry::FrameNumberRegistry()
+{
+ _nextFreeInternalNumber = INTERNAL_FRAME_STARTING_NUMBER;
+}
+
+/*===========================================================================
+ * FUNCTION : ~FrameNumberRegistry
+ *
+ * DESCRIPTION: Destructor
+ *
+ * PARAMETERS :
+ *
+ * RETURN :
+ *
+ *==========================================================================*/
+FrameNumberRegistry::~FrameNumberRegistry()
+{
+}
+
+/*===========================================================================
+ * FUNCTION : PurgeOldEntriesLocked
+ *
+ * DESCRIPTION: Maintainance function to trigger LRU cleanup mechanism
+ *
+ * PARAMETERS :
+ *
+ * RETURN : NONE
+ *
+ *==========================================================================*/
+void FrameNumberRegistry::purgeOldEntriesLocked()
+{
+ while (_register.begin() != _register.end()) {
+ auto itr = _register.begin();
+ if (itr->first < (_nextFreeInternalNumber - FRAME_REGISTER_LRU_SIZE)) {
+ _register.erase(itr);
+ } else {
+ return;
+ }
+ }
+}
+
+/*===========================================================================
+ * FUNCTION : allocStoreInternalFrameNumber
+ *
+ * DESCRIPTION: Method to note down a framework request and associate a new
+ * internal request number against it
+ *
+ * PARAMETERS :
+ * @fFrameNumber: Identifier given by framework
+ * @internalFN : Output parameter which will have the newly generated internal
+ * entry
+ *
+ * RETURN : Error code
+ *
+ *==========================================================================*/
+int32_t FrameNumberRegistry::allocStoreInternalFrameNumber(uint32_t frameworkFrameNumber,
+ uint32_t &internalFrameNumber)
+{
+ Mutex::Autolock lock(mRegistryLock);
+ internalFrameNumber = _nextFreeInternalNumber++;
+ LOGD("Storing ff#:%d, with internal:%d", frameworkFrameNumber, internalFrameNumber);
+ _register.insert(std::pair<uint32_t,uint32_t>(internalFrameNumber, frameworkFrameNumber));
+ purgeOldEntriesLocked();
+ return NO_ERROR;
+}
+
+/*===========================================================================
+ * FUNCTION : generateStoreInternalFrameNumber
+ *
+ * DESCRIPTION: Method to associate a new internal request number independent
+ * of any associate with framework requests
+ *
+ * PARAMETERS :
+ * @internalFrame#: Output parameter which will have the newly generated internal
+ *
+ *
+ * RETURN : Error code
+ *
+ *==========================================================================*/
+int32_t FrameNumberRegistry::generateStoreInternalFrameNumber(uint32_t &internalFrameNumber)
+{
+ Mutex::Autolock lock(mRegistryLock);
+ internalFrameNumber = _nextFreeInternalNumber++;
+ LOGD("Generated internal framenumber:%d", internalFrameNumber);
+ _register.insert(std::pair<uint32_t,uint32_t>(internalFrameNumber, EMPTY_FRAMEWORK_FRAME_NUMBER));
+ purgeOldEntriesLocked();
+ return NO_ERROR;
+}
+
+/*===========================================================================
+ * FUNCTION : getFrameworkFrameNumber
+ *
+ * DESCRIPTION: Method to query the framework framenumber given an internal #
+ *
+ * PARAMETERS :
+ * @internalFrame#: Internal reference
+ * @frameworkframenumber: Output parameter holding framework frame entry
+ *
+ * RETURN : Error code
+ *
+ *==========================================================================*/
+int32_t FrameNumberRegistry::getFrameworkFrameNumber(uint32_t internalFrameNumber,
+ uint32_t &frameworkFrameNumber)
+{
+ Mutex::Autolock lock(mRegistryLock);
+ auto itr = _register.find(internalFrameNumber);
+ if (itr == _register.end()) {
+ LOGE("CAM_DEBUG: Cannot find internal#: %d", internalFrameNumber);
+ return -ENOENT;
+ }
+
+ frameworkFrameNumber = itr->second;
+ purgeOldEntriesLocked();
+ return NO_ERROR;
+}
/*===========================================================================
* FUNCTION : processCaptureRequest
@@ -3560,9 +3972,10 @@
*
*==========================================================================*/
int QCamera3HardwareInterface::processCaptureRequest(
- camera3_capture_request_t *request)
+ camera3_capture_request_t *request,
+ List<InternalRequest> &internallyRequestedStreams)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PROC_CAP_REQ);
int rc = NO_ERROR;
int32_t request_id;
CameraMetadata meta;
@@ -3589,7 +4002,7 @@
return -ENODEV;
}
- rc = validateCaptureRequest(request);
+ rc = validateCaptureRequest(request, internallyRequestedStreams);
if (rc != NO_ERROR) {
LOGE("incoming request is not valid");
pthread_mutex_unlock(&mMutex);
@@ -4100,7 +4513,7 @@
QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
- //Call function to store local copy of jpeg data for encode params.
+ //FIXME??:Call function to store local copy of jpeg data for encode params.
blob_request = 1;
snapshotStreamId = channel->getStreamID(channel->getStreamTypeMask());
}
@@ -4123,8 +4536,20 @@
}
}
+ //FIXME: Add checks to ensure to dups in validateCaptureRequest
+ for (auto itr = internallyRequestedStreams.begin(); itr != internallyRequestedStreams.end();
+ itr++) {
+ QCamera3Channel *channel = (QCamera3Channel *)(*itr).stream->priv;
+ streamsArray.stream_request[streamsArray.num_streams++].streamID =
+ channel->getStreamID(channel->getStreamTypeMask());
+
+ if ((1U << CAM_STREAM_TYPE_VIDEO) == channel->getStreamTypeMask()) {
+ isVidBufRequested = true;
+ }
+ }
+
if (blob_request) {
- KPI_ATRACE_INT("SNAPSHOT", 1);
+ KPI_ATRACE_CAMSCOPE_INT("SNAPSHOT", CAMSCOPE_HAL3_SNAPSHOT, 1);
mPerfLockMgr.acquirePerfLock(PERF_LOCK_TAKE_SNAPSHOT);
}
if (blob_request && mRawDumpChannel) {
@@ -4309,7 +4734,7 @@
output.buffer, request->input_buffer, frameNumber);
if(request->input_buffer != NULL){
rc = channel->request(output.buffer, frameNumber,
- pInputBuffer, &mReprocMeta, indexUsed);
+ pInputBuffer, &mReprocMeta, indexUsed, false, false);
if (rc < 0) {
LOGE("Fail to request on picture channel");
pthread_mutex_unlock(&mMutex);
@@ -4354,8 +4779,8 @@
bool needMetadata = false;
QCamera3YUVChannel *yuvChannel = (QCamera3YUVChannel *)channel;
rc = yuvChannel->request(output.buffer, frameNumber,
- pInputBuffer,
- (pInputBuffer ? &mReprocMeta : mParameters), needMetadata, indexUsed);
+ pInputBuffer, (pInputBuffer ? &mReprocMeta : mParameters),
+ needMetadata, indexUsed, false, false);
if (rc < 0) {
LOGE("Fail to request on YUV channel");
pthread_mutex_unlock(&mMutex);
@@ -4421,6 +4846,76 @@
pendingBufferIter++;
}
+ for (auto itr = internallyRequestedStreams.begin(); itr != internallyRequestedStreams.end();
+ itr++) {
+ QCamera3Channel *channel = (QCamera3Channel *)(*itr).stream->priv;
+
+ if (channel == NULL) {
+ LOGE("invalid channel pointer for stream");
+ assert(0);
+ return BAD_VALUE;
+ }
+
+ InternalRequest requestedStream;
+ requestedStream = (*itr);
+
+
+ if ((*itr).stream->format == HAL_PIXEL_FORMAT_BLOB) {
+ LOGD("snapshot request internally input buffer %p, frame_number %d",
+ request->input_buffer, frameNumber);
+ if(request->input_buffer != NULL){
+ rc = channel->request(NULL, frameNumber,
+ pInputBuffer, &mReprocMeta, indexUsed, true, requestedStream.meteringOnly);
+ if (rc < 0) {
+ LOGE("Fail to request on picture channel");
+ pthread_mutex_unlock(&mMutex);
+ return rc;
+ }
+ } else {
+ LOGD("snapshot request with frame_number %d", frameNumber);
+ if (!request->settings) {
+ rc = channel->request(NULL, frameNumber,
+ NULL, mPrevParameters, indexUsed, true, requestedStream.meteringOnly);
+ } else {
+ rc = channel->request(NULL, frameNumber,
+ NULL, mParameters, indexUsed, true, requestedStream.meteringOnly);
+ }
+ if (rc < 0) {
+ LOGE("Fail to request on picture channel");
+ pthread_mutex_unlock(&mMutex);
+ return rc;
+ }
+
+ if ((*itr).meteringOnly != 1) {
+ requestedStream.need_metadata = 1;
+ streams_need_metadata++;
+ }
+ }
+
+ uint32_t streamId = channel->getStreamID(channel->getStreamTypeMask());
+ uint32_t j = 0;
+ for (j = 0; j < streamsArray.num_streams; j++) {
+ if (streamsArray.stream_request[j].streamID == streamId) {
+ if (mOpMode == CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE)
+ streamsArray.stream_request[j].buf_index = CAM_FREERUN_IDX;
+ else
+ streamsArray.stream_request[j].buf_index = indexUsed;
+ break;
+ }
+ }
+ if (j == streamsArray.num_streams) {
+ LOGE("Did not find matching stream to update index");
+ assert(0);
+ }
+
+ } else {
+ LOGE("Internal requests not supported on this stream type");
+ assert(0);
+ return INVALID_OPERATION;
+ }
+ latestRequest->internalRequestList.push_back(requestedStream);
+ }
+
//If 2 streams have need_metadata set to true, fail the request, unless
//we copy/reference count the metadata buffer
if (streams_need_metadata > 1) {
@@ -4617,7 +5112,7 @@
*==========================================================================*/
int QCamera3HardwareInterface::flush(bool restartChannels)
{
- KPI_ATRACE_CALL();
+ KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_FLUSH);
int32_t rc = NO_ERROR;
LOGD("Unblocking Process Capture Request");
@@ -4727,7 +5222,7 @@
*==========================================================================*/
int QCamera3HardwareInterface::flushPerf()
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_FLUSH_PREF);
int32_t rc = 0;
struct timespec timeout;
bool timed_wait = false;
@@ -4841,22 +5336,25 @@
{
int32_t rc = NO_ERROR;
- pthread_mutex_lock(&mMutex);
- if (mState != ERROR) {
- //if mState != ERROR, nothing to be done
+ {
+ Mutex::Autolock lock(mFlushLock);
+ pthread_mutex_lock(&mMutex);
+ if (mState != ERROR) {
+ //if mState != ERROR, nothing to be done
+ pthread_mutex_unlock(&mMutex);
+ return NO_ERROR;
+ }
pthread_mutex_unlock(&mMutex);
- return NO_ERROR;
- }
- pthread_mutex_unlock(&mMutex);
- rc = flush(false /* restart channels */);
- if (NO_ERROR != rc) {
- LOGE("internal flush to handle mState = ERROR failed");
- }
+ rc = flush(false /* restart channels */);
+ if (NO_ERROR != rc) {
+ LOGE("internal flush to handle mState = ERROR failed");
+ }
- pthread_mutex_lock(&mMutex);
- mState = DEINIT;
- pthread_mutex_unlock(&mMutex);
+ pthread_mutex_lock(&mMutex);
+ mState = DEINIT;
+ pthread_mutex_unlock(&mMutex);
+ }
camera3_notify_msg_t notify_msg;
memset(¬ify_msg, 0, sizeof(camera3_notify_msg_t));
@@ -4864,7 +5362,7 @@
notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_DEVICE;
notify_msg.message.error.error_stream = NULL;
notify_msg.message.error.frame_number = 0;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
return rc;
}
@@ -8445,7 +8943,7 @@
int QCamera3HardwareInterface::getCamInfo(uint32_t cameraId,
struct camera_info *info)
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_GET_CAM_INFO);
int rc = 0;
pthread_mutex_lock(&gCamLock);
@@ -8794,11 +9292,16 @@
settings.update(ANDROID_LENS_FOCUS_DISTANCE, &focus_distance, 1);
/*target fps range: use maximum range for picture, and maximum fixed range for video*/
+ /* Restrict template max_fps to 30 */
float max_range = 0.0;
float max_fixed_fps = 0.0;
int32_t fps_range[2] = {0, 0};
for (uint32_t i = 0; i < gCamCapability[mCameraId]->fps_ranges_tbl_cnt;
i++) {
+ if (gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps >
+ TEMPLATE_MAX_PREVIEW_FPS) {
+ continue;
+ }
float range = gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps -
gCamCapability[mCameraId]->fps_ranges_tbl[i].min_fps;
if (type == CAMERA3_TEMPLATE_PREVIEW ||
@@ -9559,6 +10062,7 @@
expCompensation = gCamCapability[mCameraId]->exposure_compensation_min;
if (expCompensation > gCamCapability[mCameraId]->exposure_compensation_max)
expCompensation = gCamCapability[mCameraId]->exposure_compensation_max;
+ ALOGE("CAM_DEBUG: Setting compensation:%d", expCompensation);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(hal_metadata, CAM_INTF_PARM_EXPOSURE_COMPENSATION,
expCompensation)) {
rc = BAD_VALUE;
@@ -10487,6 +10991,7 @@
camera3_capture_request_t *request)
{
LOGD("E");
+ CAMSCOPE_UPDATE_FLAGS(CAMSCOPE_SECTION_HAL, kpi_camscope_flags);
QCamera3HardwareInterface *hw =
reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
if (!hw) {
@@ -10494,7 +10999,7 @@
return -EINVAL;
}
- int rc = hw->processCaptureRequest(request);
+ int rc = hw->orchestrateRequest(request);
LOGD("X");
return rc;
}
@@ -10602,6 +11107,7 @@
LOGI("[KPI Perf]: E camera id %d", hw->mCameraId);
delete hw;
LOGI("[KPI Perf]: X");
+ CAMSCOPE_DESTROY(CAMSCOPE_SECTION_HAL);
return ret;
}
@@ -10702,6 +11208,17 @@
rc = BAD_VALUE;
}
}
+
+ if (fwk_sceneMode == ANDROID_CONTROL_SCENE_MODE_HDR) {
+ cam_hdr_param_t hdr_params;
+ hdr_params.hdr_enable = 1;
+ hdr_params.hdr_mode = CAM_HDR_MODE_MULTIFRAME;
+ hdr_params.hdr_need_1x = false;
+ if (ADD_SET_PARAM_ENTRY_TO_BATCH(hal_metadata,
+ CAM_INTF_PARM_HAL_BRACKETING_HDR, hdr_params)) {
+ rc = BAD_VALUE;
+ }
+ }
} else if ((ANDROID_CONTROL_MODE_OFF == metaMode) ||
(ANDROID_CONTROL_MODE_AUTO == metaMode)) {
uint8_t sceneMode = CAM_SCENE_MODE_OFF;
@@ -10711,6 +11228,18 @@
rc = BAD_VALUE;
}
}
+
+ if (mForceHdrSnapshot) {
+ cam_hdr_param_t hdr_params;
+ hdr_params.hdr_enable = 1;
+ hdr_params.hdr_mode = CAM_HDR_MODE_MULTIFRAME;
+ hdr_params.hdr_need_1x = false;
+ if (ADD_SET_PARAM_ENTRY_TO_BATCH(hal_metadata,
+ CAM_INTF_PARM_HAL_BRACKETING_HDR, hdr_params)) {
+ rc = BAD_VALUE;
+ }
+ }
+
return rc;
}
@@ -10834,7 +11363,7 @@
*==========================================================================*/
bool QCamera3HardwareInterface::needJpegExifRotation()
{
- /*If the pp does not have the ability to do rotation, enable jpeg rotation*/
+ /*If the pp does not have the ability to do rotation, enable jpeg rotation*/
if (!(gCamCapability[mCameraId]->qcom_supported_feature_mask & CAM_QCOM_FEATURE_ROTATION)) {
LOGD("Need use Jpeg EXIF Rotation");
return true;
@@ -10891,6 +11420,18 @@
pp_config.feature_mask &= ~CAM_QCOM_FEATURE_ROTATION;
}
+ if (config.hdr_param.hdr_enable) {
+ pp_config.feature_mask |= CAM_QCOM_FEATURE_HDR;
+ pp_config.hdr_param = config.hdr_param;
+ }
+
+ if (mForceHdrSnapshot) {
+ pp_config.feature_mask |= CAM_QCOM_FEATURE_HDR;
+ pp_config.hdr_param.hdr_enable = 1;
+ pp_config.hdr_param.hdr_need_1x = 0;
+ pp_config.hdr_param.hdr_mode = CAM_HDR_MODE_MULTIFRAME;
+ }
+
rc = pChannel->addReprocStreamsFromSource(pp_config,
config,
IS_TYPE_NONE,
@@ -11119,7 +11660,7 @@
*==========================================================================*/
int32_t QCamera3HardwareInterface::dynamicUpdateMetaStreamInfo()
{
- ATRACE_CALL();
+ ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_DYN_UPDATE_META_STRM_INFO);
int rc = NO_ERROR;
LOGD("E");
@@ -11336,7 +11877,7 @@
pStream_Buf[index].buffer = info->buffer;
pStream_Buf[index].status = CAMERA3_BUFFER_STATUS_ERROR;
pStream_Buf[index].stream = info->stream;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
index++;
// Remove buffer from list
info = req->mPendingBufferList.erase(info);
@@ -11347,7 +11888,7 @@
req->frame_number, mPendingBuffersMap.mPendingBuffersInRequest.size());
req = mPendingBuffersMap.mPendingBuffersInRequest.erase(req);
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
delete [] pStream_Buf;
} else {
@@ -11364,7 +11905,7 @@
notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_REQUEST;
notify_msg.message.error.error_stream = NULL;
notify_msg.message.error.frame_number = req->frame_number;
- mCallbackOps->notify(mCallbackOps, ¬ify_msg);
+ orchestrateNotify(¬ify_msg);
pStream_Buf = new camera3_stream_buffer_t[req->mPendingBufferList.size()];
if (NULL == pStream_Buf) {
@@ -11397,7 +11938,7 @@
req->frame_number, mPendingBuffersMap.mPendingBuffersInRequest.size());
req = mPendingBuffersMap.mPendingBuffersInRequest.erase(req);
- mCallbackOps->process_capture_result(mCallbackOps, &result);
+ orchestrateResult(&result);
delete [] pStream_Buf;
i = erasePendingRequest(i);
}
@@ -11420,8 +11961,10 @@
const cam_dimension_t max_viewfinder_size,
uint32_t width, uint32_t height)
{
- return (width > (uint32_t)max_viewfinder_size.width ||
- height > (uint32_t)max_viewfinder_size.height);
+ return ((width > (uint32_t)max_viewfinder_size.width) ||
+ (height > (uint32_t)max_viewfinder_size.height) ||
+ (width > (uint32_t)VIDEO_4K_WIDTH) ||
+ (height > (uint32_t)VIDEO_4K_HEIGHT));
}
/*===========================================================================
@@ -11623,8 +12166,8 @@
case CAM_FILTER_ARRANGEMENT_GRBG:
case CAM_FILTER_ARRANGEMENT_GBRG:
case CAM_FILTER_ARRANGEMENT_BGGR:
- if ((stream_type == CAM_STREAM_TYPE_CALLBACK) ||
- (stream_type == CAM_STREAM_TYPE_PREVIEW) ||
+ if ((stream_type == CAM_STREAM_TYPE_PREVIEW) ||
+ (stream_type == CAM_STREAM_TYPE_ANALYSIS) ||
(stream_type == CAM_STREAM_TYPE_VIDEO)) {
feature_mask |= CAM_QCOM_FEATURE_PAAF;
}