Camera3: Set EIS mode based on capture intent

Set EIS mode based on capture intent so that it will be effective
for camcorder preview mode as well.

Bug: 17417182
Change-Id: I70324ed0c0ca1f1831b78ce323644640cd6ea8ba

4 files changed, 122 insertions, 112 deletions

diff --git a/camera/QCamera2/HAL3/QCamera3Channel.cpp b/camera/QCamera2/HAL3/QCamera3Channel.cpp
index 7d371c8c..ff81a673 100644
--- a/camera/QCamera2/HAL3/QCamera3Channel.cpp
+++ b/camera/QCamera2/HAL3/QCamera3Channel.cpp
@@ -81,7 +81,6 @@ QCamera3Channel::QCamera3Channel(uint32_t cam_handle,
                                channel_cb_routine cb_routine,
                                cam_padding_info_t *paddingInfo,
                                uint32_t postprocess_mask,
-                               cam_is_type_t is_type,
                                void *userData)
 {
     m_camHandle = cam_handle;
@@ -102,7 +101,7 @@ QCamera3Channel::QCamera3Channel(uint32_t cam_handle,
     char prop[PROPERTY_VALUE_MAX];
     property_get("persist.camera.yuv.dump", prop, "0");
     mYUVDump = atoi(prop);
-    mIsType = is_type;
+    mIsType = IS_TYPE_NONE;
 }
 
 /*===========================================================================
@@ -505,10 +504,9 @@ QCamera3RegularChannel::QCamera3RegularChannel(uint32_t cam_handle,
                     void *userData,
                     camera3_stream_t *stream,
                     cam_stream_type_t stream_type,
-                    uint32_t postprocess_mask,
-                    cam_is_type_t is_type) :
+                    uint32_t postprocess_mask) :
                         QCamera3Channel(cam_handle, cam_ops, cb_routine,
-                                paddingInfo, postprocess_mask, is_type, userData),
+                                paddingInfo, postprocess_mask, userData),
                         mCamera3Stream(stream),
                         mNumBufs(0),
                         mStreamType(stream_type)
@@ -540,11 +538,11 @@ QCamera3RegularChannel::~QCamera3RegularChannel()
  *              none-zero failure code
  *==========================================================================*/
 
-int32_t QCamera3RawChannel::initialize()
+int32_t QCamera3RawChannel::initialize(cam_is_type_t isType)
 {
-    return QCamera3RegularChannel::initialize();
+    return QCamera3RegularChannel::initialize(isType);
 }
-int32_t QCamera3RegularChannel::initialize()
+int32_t QCamera3RegularChannel::initialize(cam_is_type_t isType)
 {
     ATRACE_CALL();
     int32_t rc = NO_ERROR;
@@ -568,6 +566,7 @@ int32_t QCamera3RegularChannel::initialize()
     }
 
     mNumBufs = CAM_MAX_NUM_BUFS_PER_STREAM;
+    mIsType  = isType;
 
     if (mCamera3Stream->format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
         if (mStreamType ==  CAM_STREAM_TYPE_VIDEO) {
@@ -654,7 +653,7 @@ int32_t QCamera3RegularChannel::request(buffer_handle_t *buffer, uint32_t frameN
     }
 
     if(!m_bIsActive) {
-        rc = registerBuffer(buffer);
+        rc = registerBuffer(buffer, mIsType);
         if (NO_ERROR != rc) {
             ALOGE("%s: On-the-fly buffer registration failed %d",
                     __func__, rc);
@@ -671,7 +670,7 @@ int32_t QCamera3RegularChannel::request(buffer_handle_t *buffer, uint32_t frameN
 
     index = mMemory.getMatchBufIndex((void*)buffer);
     if(index < 0) {
-        rc = registerBuffer(buffer);
+        rc = registerBuffer(buffer, mIsType);
         if (NO_ERROR != rc) {
             ALOGE("%s: On-the-fly buffer registration failed %d",
                     __func__, rc);
@@ -708,10 +707,11 @@ int32_t QCamera3RegularChannel::request(buffer_handle_t *buffer, uint32_t frameN
  *              NO_ERROR  -- success
  *              none-zero failure code
  *==========================================================================*/
-int32_t QCamera3RegularChannel::registerBuffer(buffer_handle_t *buffer)
+int32_t QCamera3RegularChannel::registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType)
 {
     ATRACE_CALL();
     int rc = 0;
+    mIsType = isType;
 
     if ((uint32_t)mMemory.getCnt() > (mNumBufs - 1)) {
         ALOGE("%s: Trying to register more buffers than initially requested",
@@ -720,7 +720,7 @@ int32_t QCamera3RegularChannel::registerBuffer(buffer_handle_t *buffer)
     }
 
     if (0 == m_numStreams) {
-        rc = initialize();
+        rc = initialize(mIsType);
         if (rc != NO_ERROR) {
             ALOGE("%s: Couldn't initialize camera stream %d",
                     __func__, rc);
@@ -806,10 +806,9 @@ QCamera3MetadataChannel::QCamera3MetadataChannel(uint32_t cam_handle,
                     channel_cb_routine cb_routine,
                     cam_padding_info_t *paddingInfo,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     void *userData) :
                         QCamera3Channel(cam_handle, cam_ops,
-                                cb_routine, paddingInfo, postprocess_mask, is_type, userData),
+                                cb_routine, paddingInfo, postprocess_mask, userData),
                         mMemory(NULL)
 {
 }
@@ -826,7 +825,7 @@ QCamera3MetadataChannel::~QCamera3MetadataChannel()
     }
 }
 
-int32_t QCamera3MetadataChannel::initialize()
+int32_t QCamera3MetadataChannel::initialize(cam_is_type_t isType)
 {
     ATRACE_CALL();
     int32_t rc;
@@ -842,7 +841,7 @@ int32_t QCamera3MetadataChannel::initialize()
         ALOGE("%s: init failed", __func__);
         return rc;
     }
-
+    mIsType = isType;
     streamDim.width = sizeof(metadata_buffer_t),
     streamDim.height = 1;
     rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_METADATA, CAM_FORMAT_MAX,
@@ -919,11 +918,10 @@ QCamera3RawChannel::QCamera3RawChannel(uint32_t cam_handle,
                     void *userData,
                     camera3_stream_t *stream,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     bool raw_16) :
                         QCamera3RegularChannel(cam_handle, cam_ops,
                                 cb_routine, paddingInfo, userData, stream,
-                                CAM_STREAM_TYPE_RAW, postprocess_mask, is_type),
+                                CAM_STREAM_TYPE_RAW, postprocess_mask),
                         mIsRaw16(raw_16)
 {
     char prop[PROPERTY_VALUE_MAX];
@@ -1085,10 +1083,9 @@ QCamera3RawDumpChannel::QCamera3RawDumpChannel(uint32_t cam_handle,
                     cam_dimension_t rawDumpSize,
                     cam_padding_info_t *paddingInfo,
                     void *userData,
-                    uint32_t postprocess_mask,
-                    cam_is_type_t is_type) :
+                    uint32_t postprocess_mask) :
                         QCamera3Channel(cam_handle, cam_ops, NULL,
-                                paddingInfo, postprocess_mask, is_type, userData),
+                                paddingInfo, postprocess_mask, userData),
                         mDim(rawDumpSize),
                         mMemory(NULL)
 {
@@ -1268,7 +1265,7 @@ int32_t QCamera3RawDumpChannel::request(buffer_handle_t * /*buffer*/,
  *              NO_ERROR  -- success
  *              none-zero failure code
  *==========================================================================*/
-int32_t QCamera3RawDumpChannel::initialize()
+int32_t QCamera3RawDumpChannel::initialize(cam_is_type_t isType)
 {
     int32_t rc;
 
@@ -1277,7 +1274,7 @@ int32_t QCamera3RawDumpChannel::initialize()
         ALOGE("%s: init failed", __func__);
         return rc;
     }
-
+    mIsType = isType;
     rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_RAW,
         CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG, mDim, kMaxBuffers,
         mPostProcMask, mIsType);
@@ -1429,10 +1426,9 @@ QCamera3PicChannel::QCamera3PicChannel(uint32_t cam_handle,
                     camera3_stream_t *stream,
                     uint32_t postprocess_mask,
                     bool is4KVideo,
-                    cam_is_type_t is_type,
                     QCamera3Channel *metadataChannel) :
                         QCamera3Channel(cam_handle, cam_ops, cb_routine,
-                        paddingInfo, postprocess_mask, is_type, userData),
+                        paddingInfo, postprocess_mask, userData),
                         m_postprocessor(this),
                         mCamera3Stream(stream),
                         mNumBufsRegistered(CAM_MAX_NUM_BUFS_PER_STREAM),
@@ -1500,7 +1496,7 @@ QCamera3PicChannel::~QCamera3PicChannel()
    }
 }
 
-int32_t QCamera3PicChannel::initialize()
+int32_t QCamera3PicChannel::initialize(cam_is_type_t isType)
 {
     int32_t rc = NO_ERROR;
     cam_dimension_t streamDim;
@@ -1530,7 +1526,7 @@ int32_t QCamera3PicChannel::initialize()
         ALOGE("%s: init failed", __func__);
         return rc;
     }
-
+    mIsType = isType;
     streamType = mStreamType;
     streamFormat = mStreamFormat;
     streamDim.width = mYuvWidth;
@@ -1611,7 +1607,7 @@ int32_t QCamera3PicChannel::request(buffer_handle_t *buffer,
 
     index = mMemory.getMatchBufIndex((void*)buffer);
     if(index < 0) {
-        rc = registerBuffer(buffer);
+        rc = registerBuffer(buffer, mIsType);
         if (NO_ERROR != rc) {
             ALOGE("%s: On-the-fly buffer registration failed %d",
                     __func__, rc);
@@ -1812,10 +1808,10 @@ void QCamera3PicChannel::dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
  *              NO_ERROR  -- success
  *              none-zero failure code
  *==========================================================================*/
-int32_t QCamera3PicChannel::registerBuffer(buffer_handle_t *buffer)
+int32_t QCamera3PicChannel::registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType)
 {
     int rc = 0;
-
+    mIsType = isType;
     if ((uint32_t)mMemory.getCnt() > (mNumBufsRegistered - 1)) {
         ALOGE("%s: Trying to register more buffers than initially requested",
                 __func__);
@@ -1823,7 +1819,7 @@ int32_t QCamera3PicChannel::registerBuffer(buffer_handle_t *buffer)
     }
 
     if (0 == m_numStreams) {
-        rc = initialize();
+        rc = initialize(mIsType);
         if (rc != NO_ERROR) {
             ALOGE("%s: Couldn't initialize camera stream %d",
                     __func__, rc);
@@ -2585,9 +2581,8 @@ QCamera3ReprocessChannel::QCamera3ReprocessChannel(uint32_t cam_handle,
                                                  channel_cb_routine cb_routine,
                                                  cam_padding_info_t *paddingInfo,
                                                  uint32_t postprocess_mask,
-                                                 cam_is_type_t is_type,
                                                  void *userData, void *ch_hdl) :
-    QCamera3Channel(cam_handle, cam_ops, cb_routine, paddingInfo, postprocess_mask, is_type,
+    QCamera3Channel(cam_handle, cam_ops, cb_routine, paddingInfo, postprocess_mask,
                     userData),
     picChHandle(ch_hdl),
     mOfflineBuffersIndex(-1),
@@ -2612,7 +2607,7 @@ QCamera3ReprocessChannel::QCamera3ReprocessChannel(uint32_t cam_handle,
  *
  * RETURN     : none
  *==========================================================================*/
-int32_t QCamera3ReprocessChannel::initialize()
+int32_t QCamera3ReprocessChannel::initialize(cam_is_type_t isType)
 {
     int32_t rc = NO_ERROR;
     mm_camera_channel_attr_t attr;
@@ -2625,6 +2620,7 @@ int32_t QCamera3ReprocessChannel::initialize()
     if (rc < 0) {
         ALOGE("%s: init failed", __func__);
     }
+    mIsType = isType;
     return rc;
 }
 
@@ -3274,10 +3270,9 @@ QCamera3SupportChannel::QCamera3SupportChannel(uint32_t cam_handle,
                     mm_camera_ops_t *cam_ops,
                     cam_padding_info_t *paddingInfo,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     void *userData) :
                         QCamera3Channel(cam_handle, cam_ops,
-                                NULL, paddingInfo, postprocess_mask, is_type, userData),
+                                NULL, paddingInfo, postprocess_mask, userData),
                         mMemory(NULL)
 {
 }
@@ -3294,7 +3289,7 @@ QCamera3SupportChannel::~QCamera3SupportChannel()
     }
 }
 
-int32_t QCamera3SupportChannel::initialize()
+int32_t QCamera3SupportChannel::initialize(cam_is_type_t isType)
 {
     int32_t rc;
 
@@ -3308,7 +3303,7 @@ int32_t QCamera3SupportChannel::initialize()
         ALOGE("%s: init failed", __func__);
         return rc;
     }
-
+    mIsType = isType;
     // Hardcode to VGA size for now
     rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_CALLBACK,
         CAM_FORMAT_YUV_420_NV21, kDim, MIN_STREAMING_BUFFER_NUM,
diff --git a/camera/QCamera2/HAL3/QCamera3Channel.h b/camera/QCamera2/HAL3/QCamera3Channel.h
index 78f8c39f..9a65f057 100644
--- a/camera/QCamera2/HAL3/QCamera3Channel.h
+++ b/camera/QCamera2/HAL3/QCamera3Channel.h
@@ -58,7 +58,6 @@ public:
                    channel_cb_routine cb_routine,
                    cam_padding_info_t *paddingInfo,
                    uint32_t postprocess_mask,
-                   cam_is_type_t is_type,
                    void *userData);
     QCamera3Channel();
     virtual ~QCamera3Channel();
@@ -75,7 +74,7 @@ public:
 
     uint32_t getStreamTypeMask();
     uint32_t getStreamID(uint32_t streamMask);
-    virtual int32_t initialize() = 0;
+    virtual int32_t initialize(cam_is_type_t isType) = 0;
     virtual int32_t request(buffer_handle_t * /*buffer*/,
                 uint32_t /*frameNumber*/){ return 0;};
     virtual int32_t request(buffer_handle_t * /*buffer*/,
@@ -85,7 +84,7 @@ public:
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
                             QCamera3Stream *stream) = 0;
 
-    virtual int32_t registerBuffer(buffer_handle_t *buffer) = 0;
+    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0;
     virtual QCamera3Memory *getStreamBufs(uint32_t len) = 0;
     virtual void putStreamBufs() = 0;
 
@@ -140,20 +139,19 @@ public:
                     void *userData,
                     camera3_stream_t *stream,
                     cam_stream_type_t stream_type,
-                    uint32_t postprocess_mask,
-                    cam_is_type_t is_type);
+                    uint32_t postprocess_mask);
 
     virtual ~QCamera3RegularChannel();
 
     virtual int32_t start();
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
     virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
                                             QCamera3Stream *stream);
 
     virtual QCamera3Memory *getStreamBufs(uint32_t le);
     virtual void putStreamBufs();
-    virtual int32_t registerBuffer(buffer_handle_t *buffer);
+    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
 
 public:
     static int kMaxBuffers;
@@ -176,11 +174,10 @@ public:
                     channel_cb_routine cb_routine,
                     cam_padding_info_t *paddingInfo,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     void *userData);
     virtual ~QCamera3MetadataChannel();
 
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
 
     virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
@@ -188,7 +185,7 @@ public:
 
     virtual QCamera3Memory *getStreamBufs(uint32_t le);
     virtual void putStreamBufs();
-    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
+    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
             { return NO_ERROR; };
 
 private:
@@ -207,11 +204,10 @@ public:
                     void *userData,
                     camera3_stream_t *stream,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     bool raw_16 = false);
     virtual ~QCamera3RawChannel();
 
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
 
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
                             QCamera3Stream *stream);
@@ -240,15 +236,14 @@ public:
                     cam_dimension_t rawDumpSize,
                     cam_padding_info_t *paddingInfo,
                     void *userData,
-                    uint32_t postprocess_mask,
-                    cam_is_type_t is_type);
+                    uint32_t postprocess_mask);
     virtual ~QCamera3RawDumpChannel();
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
                             QCamera3Stream *stream);
     virtual QCamera3Memory *getStreamBufs(uint32_t le);
     virtual void putStreamBufs();
-    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
+    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
             { return NO_ERROR; };
     virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
     void dumpRawSnapshot(mm_camera_buf_def_t *frame);
@@ -275,11 +270,10 @@ public:
             camera3_stream_t *stream,
             uint32_t postprocess_mask,
             bool is4KVideo,
-            cam_is_type_t is_type,
             QCamera3Channel *metadataChannel);
     ~QCamera3PicChannel();
 
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
     virtual int32_t stop();
     virtual int32_t request(buffer_handle_t *buffer,
             uint32_t frameNumber,
@@ -304,7 +298,7 @@ public:
             void *userdata);
     static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
             void *userdata);
-    virtual int32_t registerBuffer(buffer_handle_t *buffer);
+    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
     int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata);
 
 private:
@@ -349,7 +343,6 @@ public:
                             channel_cb_routine cb_routine,
                             cam_padding_info_t *paddingInfo,
                             uint32_t postprocess_mask,
-                            cam_is_type_t is_type,
                             void *userData, void *ch_hdl);
     QCamera3ReprocessChannel();
     virtual ~QCamera3ReprocessChannel();
@@ -364,7 +357,7 @@ public:
     int32_t extractCrop(qcamera_fwk_input_pp_data_t *frame);
     virtual QCamera3Memory *getStreamBufs(uint32_t len);
     virtual void putStreamBufs();
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
     int32_t unmapOfflineBuffers(bool all);
     virtual int32_t stop();
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
@@ -377,7 +370,7 @@ public:
            QCamera3Channel *pMetaChannel);
     QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
     QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
-    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
+    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
             { return NO_ERROR; };
 
 public:
@@ -407,11 +400,10 @@ public:
                     mm_camera_ops_t *cam_ops,
                     cam_padding_info_t *paddingInfo,
                     uint32_t postprocess_mask,
-                    cam_is_type_t is_type,
                     void *userData);
     virtual ~QCamera3SupportChannel();
 
-    virtual int32_t initialize();
+    virtual int32_t initialize(cam_is_type_t isType);
 
     virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
     virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
@@ -419,7 +411,7 @@ public:
 
     virtual QCamera3Memory *getStreamBufs(uint32_t le);
     virtual void putStreamBufs();
-    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
+    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
             { return NO_ERROR; };
 
     static cam_dimension_t kDim;
diff --git a/camera/QCamera2/HAL3/QCamera3HWI.cpp b/camera/QCamera2/HAL3/QCamera3HWI.cpp
index d088bcf4..10f05f35 100644
--- a/camera/QCamera2/HAL3/QCamera3HWI.cpp
+++ b/camera/QCamera2/HAL3/QCamera3HWI.cpp
@@ -926,28 +926,17 @@ int QCamera3HardwareInterface::configureStreams(
         mSupportChannel = NULL;
     }
 
-    /* get eis information for stream configuration */
-    cam_is_type_t is_type;
-    char is_type_value[PROPERTY_VALUE_MAX];
-    property_get("camera.is_type", is_type_value, "4");
-    is_type = static_cast<cam_is_type_t>(atoi(is_type_value));
-    //for camera use case, front camcorder and 4k video, no eis
-    if (gCamCapability[mCameraId]->position != CAM_POSITION_BACK ||
-        !m_bIsVideo || m_bIs4KVideo) {
-        is_type = IS_TYPE_NONE;
-    }
-
     //Create metadata channel and initialize it
     mMetadataChannel = new QCamera3MetadataChannel(mCameraHandle->camera_handle,
                     mCameraHandle->ops, captureResultCb,
-                    &gCamCapability[mCameraId]->padding_info, CAM_QCOM_FEATURE_NONE, is_type, this);
+                    &gCamCapability[mCameraId]->padding_info, CAM_QCOM_FEATURE_NONE, this);
     if (mMetadataChannel == NULL) {
         ALOGE("%s: failed to allocate metadata channel", __func__);
         rc = -ENOMEM;
         pthread_mutex_unlock(&mMutex);
         return rc;
     }
-    rc = mMetadataChannel->initialize();
+    rc = mMetadataChannel->initialize(IS_TYPE_NONE);
     if (rc < 0) {
         ALOGE("%s: metadata channel initialization failed", __func__);
         delete mMetadataChannel;
@@ -967,7 +956,6 @@ int QCamera3HardwareInterface::configureStreams(
                 mCameraHandle->ops,
                 &gCamCapability[mCameraId]->padding_info,
                 CAM_QCOM_FEATURE_NONE,
-                is_type,
                 this);
         if (!mSupportChannel) {
             ALOGE("%s: dummy channel cannot be created", __func__);
@@ -1083,8 +1071,7 @@ int QCamera3HardwareInterface::configureStreams(
                             this,
                             newStream,
                             (cam_stream_type_t) stream_config_info.type[i],
-                            stream_config_info.postprocess_mask[i],
-                            is_type);
+                            stream_config_info.postprocess_mask[i]);
                     if (channel == NULL) {
                         ALOGE("%s: allocation of channel failed", __func__);
                         pthread_mutex_unlock(&mMutex);
@@ -1102,7 +1089,6 @@ int QCamera3HardwareInterface::configureStreams(
                             mCameraHandle->ops, captureResultCb,
                             &gCamCapability[mCameraId]->padding_info,
                             this, newStream, CAM_QCOM_FEATURE_NONE,
-                            is_type,
                             (newStream->format == HAL_PIXEL_FORMAT_RAW16));
                     if (mRawChannel == NULL) {
                         ALOGE("%s: allocation of raw channel failed", __func__);
@@ -1118,7 +1104,7 @@ int QCamera3HardwareInterface::configureStreams(
                             mCameraHandle->ops, captureResultCb,
                             &gCamCapability[mCameraId]->padding_info, this, newStream,
                             stream_config_info.postprocess_mask[i],
-                            m_bIs4KVideo, is_type, mMetadataChannel);
+                            m_bIs4KVideo, mMetadataChannel);
                     if (mPictureChannel == NULL) {
                         ALOGE("%s: allocation of channel failed", __func__);
                         pthread_mutex_unlock(&mMutex);
@@ -1162,7 +1148,7 @@ int QCamera3HardwareInterface::configureStreams(
                                   mCameraHandle->ops,
                                   rawDumpSize,
                                   &gCamCapability[mCameraId]->padding_info,
-                                  this, CAM_QCOM_FEATURE_NONE, is_type);
+                                  this, CAM_QCOM_FEATURE_NONE);
         if (!mRawDumpChannel) {
             ALOGE("%s: Raw Dump channel cannot be created", __func__);
             pthread_mutex_unlock(&mMutex);
@@ -1204,18 +1190,6 @@ int QCamera3HardwareInterface::configureStreams(
     AddSetParmEntryToBatch(mParameters,CAM_INTF_PARM_TINTLESS,
                 sizeof(tintless_value), &tintless_value);
 
-    //If EIS is enabled, turn it on for video
-    int32_t vsMode;
-    if (gCamCapability[mCameraId]->position == CAM_POSITION_BACK &&
-        mEisEnable && m_bIsVideo && !m_bIs4KVideo){
-       vsMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
-    } else {
-       vsMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
-    }
-    rc = AddSetParmEntryToBatch(mParameters,
-            CAM_INTF_PARM_DIS_ENABLE,
-            sizeof(vsMode), &vsMode);
-
     mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
 
     /* Initialize mPendingRequestInfo and mPendnigBuffersMap */
@@ -1978,17 +1952,11 @@ int QCamera3HardwareInterface::processCaptureRequest(
     // stream on all streams
     if (mFirstRequest) {
 
-        for (size_t i = 0; i < request->num_output_buffers; i++) {
-            const camera3_stream_buffer_t& output = request->output_buffers[i];
-            QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
-            rc = channel->registerBuffer(output.buffer);
-            if (rc < 0) {
-                ALOGE("%s: registerBuffer failed",
-                        __func__);
-                pthread_mutex_unlock(&mMutex);
-                return -ENODEV;
-            }
-        }
+         /* get eis information for stream configuration */
+        cam_is_type_t is_type;
+        char is_type_value[PROPERTY_VALUE_MAX];
+        property_get("camera.is_type", is_type_value, "0");
+        is_type = static_cast<cam_is_type_t>(atoi(is_type_value));
 
         if (meta.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
             int32_t hal_version = CAM_HAL_V3;
@@ -2000,15 +1968,65 @@ int QCamera3HardwareInterface::processCaptureRequest(
                 sizeof(hal_version), &hal_version);
             AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT,
                 sizeof(captureIntent), &captureIntent);
-            mCameraHandle->ops->set_parms(mCameraHandle->camera_handle,
-                mParameters);
         }
 
+        //If EIS is enabled, turn it on for video
+        //for camera use case, front camcorder and 4k video, no eis
+        bool setEis = gCamCapability[mCameraId]->position == CAM_POSITION_BACK &&
+            (mCaptureIntent ==  CAMERA3_TEMPLATE_VIDEO_RECORD ||
+             mCaptureIntent == CAMERA3_TEMPLATE_VIDEO_SNAPSHOT);
+
+        int32_t vsMode;
+        if (setEis){
+           vsMode = DIS_ENABLE;
+        } else {
+           vsMode = DIS_DISABLE;
+        }
+        rc = AddSetParmEntryToBatch(mParameters,
+                CAM_INTF_PARM_DIS_ENABLE,
+                sizeof(vsMode), &vsMode);
+
+        //IS type will be 0 unless EIS is supported. If EIS is supported
+        //it could either be 1 or 4 depending on the stream and video size
+        if (setEis){
+            if (m_bIs4KVideo) {
+                is_type = IS_TYPE_DIS;
+            } else {
+                is_type = IS_TYPE_EIS_2_0;
+            }
+        }
+
+        for (size_t i = 0; i < request->num_output_buffers; i++) {
+            const camera3_stream_buffer_t& output = request->output_buffers[i];
+            QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
+            /*for livesnapshot stream is_type will be DIS*/
+            if (setEis && output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
+                rc = channel->registerBuffer(output.buffer, IS_TYPE_DIS);
+            } else {
+                rc = channel->registerBuffer(output.buffer, is_type);
+            }
+            if (rc < 0) {
+                ALOGE("%s: registerBuffer failed",
+                        __func__);
+                pthread_mutex_unlock(&mMutex);
+                return -ENODEV;
+            }
+        }
+
+        /*set the capture intent, hal version and dis enable parameters to the backend*/
+        mCameraHandle->ops->set_parms(mCameraHandle->camera_handle,
+                    mParameters);
+
+
         //First initialize all streams
         for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
             it != mStreamInfo.end(); it++) {
             QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
-            rc = channel->initialize();
+            if (setEis && (*it)->stream->format == HAL_PIXEL_FORMAT_BLOB) {
+                rc = channel->initialize(IS_TYPE_DIS);
+            } else {
+                rc = channel->initialize(is_type);
+            }
             if (NO_ERROR != rc) {
                 ALOGE("%s : Channel initialization failed %d", __func__, rc);
                 pthread_mutex_unlock(&mMutex);
@@ -2017,7 +2035,7 @@ int QCamera3HardwareInterface::processCaptureRequest(
         }
 
         if (mRawDumpChannel) {
-            rc = mRawDumpChannel->initialize();
+            rc = mRawDumpChannel->initialize(is_type);
             if (rc != NO_ERROR) {
                 ALOGE("%s: Error: Raw Dump Channel init failed", __func__);
                 pthread_mutex_unlock(&mMutex);
@@ -2025,7 +2043,7 @@ int QCamera3HardwareInterface::processCaptureRequest(
             }
         }
         if (mSupportChannel) {
-            rc = mSupportChannel->initialize();
+            rc = mSupportChannel->initialize(is_type);
             if (rc < 0) {
                 ALOGE("%s: Support channel initialization failed", __func__);
                 pthread_mutex_unlock(&mMutex);
@@ -6766,13 +6784,13 @@ QCamera3ReprocessChannel *QCamera3HardwareInterface::addOfflineReprocChannel(
     QCamera3ReprocessChannel *pChannel = NULL;
 
     pChannel = new QCamera3ReprocessChannel(mCameraHandle->camera_handle,
-            mCameraHandle->ops, NULL, config.padding, CAM_QCOM_FEATURE_NONE, IS_TYPE_NONE, this, picChHandle);
+            mCameraHandle->ops, NULL, config.padding, CAM_QCOM_FEATURE_NONE, this, picChHandle);
     if (NULL == pChannel) {
         ALOGE("%s: no mem for reprocess channel", __func__);
         return NULL;
     }
 
-    rc = pChannel->initialize();
+    rc = pChannel->initialize(IS_TYPE_NONE);
     if (rc != NO_ERROR) {
         ALOGE("%s: init reprocess channel failed, ret = %d", __func__, rc);
         delete pChannel;
diff --git a/camera/QCamera2/stack/common/cam_types.h b/camera/QCamera2/stack/common/cam_types.h
index ee363bab..8e742df9 100644
--- a/camera/QCamera2/stack/common/cam_types.h
+++ b/camera/QCamera2/stack/common/cam_types.h
@@ -668,6 +668,11 @@ typedef enum {
 } cam_is_type_t;
 
 typedef enum {
+   DIS_DISABLE,
+   DIS_ENABLE
+} cam_dis_mode_t;
+
+typedef enum {
   NON_SECURE,
   SECURE
 } cam_stream_secure_t;