Home | History | Annotate | Download | only in HAL
      1 /* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
      2 *
      3 * Redistribution and use in source and binary forms, with or without
      4 * modification, are permitted provided that the following conditions are
      5 * met:
      6 *     * Redistributions of source code must retain the above copyright
      7 *       notice, this list of conditions and the following disclaimer.
      8 *     * Redistributions in binary form must reproduce the above
      9 *       copyright notice, this list of conditions and the following
     10 *       disclaimer in the documentation and/or other materials provided
     11 *       with the distribution.
     12 *     * Neither the name of The Linux Foundation nor the names of its
     13 *       contributors may be used to endorse or promote products derived
     14 *       from this software without specific prior written permission.
     15 *
     16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 *
     28 */
     29 
     30 #define LOG_TAG "QCamera2HWI"
     31 
     32 // To remove
     33 #include <cutils/properties.h>
     34 
     35 // System definitions
     36 #include <utils/Errors.h>
     37 #include <dlfcn.h>
     38 #include <stdio.h>
     39 #include <stdlib.h>
     40 #include "gralloc_priv.h"
     41 #include "native_handle.h"
     42 
     43 // Camera definitions
     44 #include "android/QCamera2External.h"
     45 #include "QCamera2HWI.h"
     46 #include "QCameraBufferMaps.h"
     47 #include "QCameraFlash.h"
     48 #include "QCameraTrace.h"
     49 
     50 extern "C" {
     51 #include "mm_camera_dbg.h"
     52 }
     53 
     54 #define MAP_TO_DRIVER_COORDINATE(val, base, scale, offset) \
     55     ((int32_t)val * (int32_t)scale / (int32_t)base + (int32_t)offset)
     56 #define CAMERA_MIN_STREAMING_BUFFERS     3
     57 #define EXTRA_ZSL_PREVIEW_STREAM_BUF     2
     58 #define CAMERA_MIN_JPEG_ENCODING_BUFFERS 2
     59 #define CAMERA_MIN_VIDEO_BUFFERS         9
     60 #define CAMERA_MIN_CALLBACK_BUFFERS      5
     61 #define CAMERA_LONGSHOT_STAGES           4
     62 #define CAMERA_MIN_CAMERA_BATCH_BUFFERS  6
     63 #define CAMERA_ISP_PING_PONG_BUFFERS     2
     64 #define MIN_UNDEQUEUED_BUFFERS           1 // This is required if preview window is not set
     65 
     66 #define HDR_CONFIDENCE_THRESHOLD 0.4
     67 
     68 #define CAMERA_OPEN_PERF_TIME_OUT 500 // 500 milliseconds
     69 
     70 // Very long wait, just to be sure we don't deadlock
     71 #define CAMERA_DEFERRED_THREAD_TIMEOUT 5000000000 // 5 seconds
     72 #define CAMERA_DEFERRED_MAP_BUF_TIMEOUT 2000000000 // 2 seconds
     73 #define CAMERA_MIN_METADATA_BUFFERS 10 // Need at least 10 for ZSL snapshot
     74 #define CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS 5
     75 #define CAMERA_MAX_PARAM_APPLY_DELAY 3
     76 
     77 namespace qcamera {
     78 
     79 extern cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS];
     80 extern pthread_mutex_t gCamLock;
     81 volatile uint32_t gCamHalLogLevel = 1;
     82 extern uint8_t gNumCameraSessions;
     83 uint32_t QCamera2HardwareInterface::sNextJobId = 1;
     84 
     85 camera_device_ops_t QCamera2HardwareInterface::mCameraOps = {
     86     .set_preview_window =        QCamera2HardwareInterface::set_preview_window,
     87     .set_callbacks =             QCamera2HardwareInterface::set_CallBacks,
     88     .enable_msg_type =           QCamera2HardwareInterface::enable_msg_type,
     89     .disable_msg_type =          QCamera2HardwareInterface::disable_msg_type,
     90     .msg_type_enabled =          QCamera2HardwareInterface::msg_type_enabled,
     91 
     92     .start_preview =             QCamera2HardwareInterface::start_preview,
     93     .stop_preview =              QCamera2HardwareInterface::stop_preview,
     94     .preview_enabled =           QCamera2HardwareInterface::preview_enabled,
     95     .store_meta_data_in_buffers= QCamera2HardwareInterface::store_meta_data_in_buffers,
     96 
     97     .start_recording =           QCamera2HardwareInterface::start_recording,
     98     .stop_recording =            QCamera2HardwareInterface::stop_recording,
     99     .recording_enabled =         QCamera2HardwareInterface::recording_enabled,
    100     .release_recording_frame =   QCamera2HardwareInterface::release_recording_frame,
    101 
    102     .auto_focus =                QCamera2HardwareInterface::auto_focus,
    103     .cancel_auto_focus =         QCamera2HardwareInterface::cancel_auto_focus,
    104 
    105     .take_picture =              QCamera2HardwareInterface::take_picture,
    106     .cancel_picture =            QCamera2HardwareInterface::cancel_picture,
    107 
    108     .set_parameters =            QCamera2HardwareInterface::set_parameters,
    109     .get_parameters =            QCamera2HardwareInterface::get_parameters,
    110     .put_parameters =            QCamera2HardwareInterface::put_parameters,
    111     .send_command =              QCamera2HardwareInterface::send_command,
    112 
    113     .release =                   QCamera2HardwareInterface::release,
    114     .dump =                      QCamera2HardwareInterface::dump,
    115 };
    116 
    117 /*===========================================================================
    118  * FUNCTION   : set_preview_window
    119  *
    120  * DESCRIPTION: set preview window.
    121  *
    122  * PARAMETERS :
    123  *   @device  : ptr to camera device struct
    124  *   @window  : window ops table
    125  *
    126  * RETURN     : int32_t type of status
    127  *              NO_ERROR  -- success
    128  *              none-zero failure code
    129  *==========================================================================*/
    130 int QCamera2HardwareInterface::set_preview_window(struct camera_device *device,
    131         struct preview_stream_ops *window)
    132 {
    133     ATRACE_CALL();
    134     int rc = NO_ERROR;
    135     QCamera2HardwareInterface *hw =
    136         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    137     if (!hw) {
    138         LOGE("NULL camera device");
    139         return BAD_VALUE;
    140     }
    141     LOGD("E camera id %d window = %p", hw->getCameraId(), window);
    142 
    143     hw->lockAPI();
    144     qcamera_api_result_t apiResult;
    145     rc = hw->processAPI(QCAMERA_SM_EVT_SET_PREVIEW_WINDOW, (void *)window);
    146     if (rc == NO_ERROR) {
    147         hw->waitAPIResult(QCAMERA_SM_EVT_SET_PREVIEW_WINDOW, &apiResult);
    148         rc = apiResult.status;
    149     }
    150     hw->unlockAPI();
    151     LOGD("X camera id %d", hw->getCameraId());
    152 
    153     return rc;
    154 }
    155 
    156 /*===========================================================================
    157  * FUNCTION   : set_CallBacks
    158  *
    159  * DESCRIPTION: set callbacks for notify and data
    160  *
    161  * PARAMETERS :
    162  *   @device     : ptr to camera device struct
    163  *   @notify_cb  : notify cb
    164  *   @data_cb    : data cb
    165  *   @data_cb_timestamp  : video data cd with timestamp
    166  *   @get_memory : ops table for request gralloc memory
    167  *   @user       : user data ptr
    168  *
    169  * RETURN     : none
    170  *==========================================================================*/
    171 void QCamera2HardwareInterface::set_CallBacks(struct camera_device *device,
    172         camera_notify_callback notify_cb,
    173         camera_data_callback data_cb,
    174         camera_data_timestamp_callback data_cb_timestamp,
    175         camera_request_memory get_memory,
    176         void *user)
    177 {
    178     ATRACE_CALL();
    179     QCamera2HardwareInterface *hw =
    180         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    181     if (!hw) {
    182         LOGE("NULL camera device");
    183         return;
    184     }
    185     LOGD("E camera id %d", hw->getCameraId());
    186 
    187     qcamera_sm_evt_setcb_payload_t payload;
    188     payload.notify_cb = notify_cb;
    189     payload.data_cb = data_cb;
    190     payload.data_cb_timestamp = data_cb_timestamp;
    191     payload.get_memory = get_memory;
    192     payload.user = user;
    193 
    194     hw->lockAPI();
    195     qcamera_api_result_t apiResult;
    196     int32_t rc = hw->processAPI(QCAMERA_SM_EVT_SET_CALLBACKS, (void *)&payload);
    197     if (rc == NO_ERROR) {
    198         hw->waitAPIResult(QCAMERA_SM_EVT_SET_CALLBACKS, &apiResult);
    199     }
    200     hw->unlockAPI();
    201     LOGD("X camera id %d", hw->getCameraId());
    202 
    203 }
    204 
    205 /*===========================================================================
    206  * FUNCTION   : enable_msg_type
    207  *
    208  * DESCRIPTION: enable certain msg type
    209  *
    210  * PARAMETERS :
    211  *   @device     : ptr to camera device struct
    212  *   @msg_type   : msg type mask
    213  *
    214  * RETURN     : none
    215  *==========================================================================*/
    216 void QCamera2HardwareInterface::enable_msg_type(struct camera_device *device, int32_t msg_type)
    217 {
    218     ATRACE_CALL();
    219     QCamera2HardwareInterface *hw =
    220         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    221     if (!hw) {
    222         LOGE("NULL camera device");
    223         return;
    224     }
    225     LOGD("E camera id %d", hw->getCameraId());
    226 
    227     hw->lockAPI();
    228     qcamera_api_result_t apiResult;
    229     int32_t rc = hw->processAPI(QCAMERA_SM_EVT_ENABLE_MSG_TYPE, (void *)&msg_type);
    230     if (rc == NO_ERROR) {
    231         hw->waitAPIResult(QCAMERA_SM_EVT_ENABLE_MSG_TYPE, &apiResult);
    232     }
    233     hw->unlockAPI();
    234     LOGD("X camera id %d", hw->getCameraId());
    235 
    236 }
    237 
    238 /*===========================================================================
    239  * FUNCTION   : disable_msg_type
    240  *
    241  * DESCRIPTION: disable certain msg type
    242  *
    243  * PARAMETERS :
    244  *   @device     : ptr to camera device struct
    245  *   @msg_type   : msg type mask
    246  *
    247  * RETURN     : none
    248  *==========================================================================*/
    249 void QCamera2HardwareInterface::disable_msg_type(struct camera_device *device, int32_t msg_type)
    250 {
    251     ATRACE_CALL();
    252     QCamera2HardwareInterface *hw =
    253         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    254     if (!hw) {
    255         LOGE("NULL camera device");
    256         return;
    257     }
    258     LOGD("E camera id %d", hw->getCameraId());
    259 
    260     hw->lockAPI();
    261     qcamera_api_result_t apiResult;
    262     int32_t rc = hw->processAPI(QCAMERA_SM_EVT_DISABLE_MSG_TYPE, (void *)&msg_type);
    263     if (rc == NO_ERROR) {
    264         hw->waitAPIResult(QCAMERA_SM_EVT_DISABLE_MSG_TYPE, &apiResult);
    265     }
    266     hw->unlockAPI();
    267     LOGD("X camera id %d", hw->getCameraId());
    268 
    269 }
    270 
    271 /*===========================================================================
    272  * FUNCTION   : msg_type_enabled
    273  *
    274  * DESCRIPTION: if certain msg type is enabled
    275  *
    276  * PARAMETERS :
    277  *   @device     : ptr to camera device struct
    278  *   @msg_type   : msg type mask
    279  *
    280  * RETURN     : 1 -- enabled
    281  *              0 -- not enabled
    282  *==========================================================================*/
    283 int QCamera2HardwareInterface::msg_type_enabled(struct camera_device *device, int32_t msg_type)
    284 {
    285     ATRACE_CALL();
    286     int ret = NO_ERROR;
    287     QCamera2HardwareInterface *hw =
    288         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    289     if (!hw) {
    290         LOGE("NULL camera device");
    291         return BAD_VALUE;
    292     }
    293     LOGD("E camera id %d", hw->getCameraId());
    294 
    295     hw->lockAPI();
    296     qcamera_api_result_t apiResult;
    297     ret = hw->processAPI(QCAMERA_SM_EVT_MSG_TYPE_ENABLED, (void *)&msg_type);
    298     if (ret == NO_ERROR) {
    299         hw->waitAPIResult(QCAMERA_SM_EVT_MSG_TYPE_ENABLED, &apiResult);
    300         ret = apiResult.enabled;
    301     }
    302     hw->unlockAPI();
    303     LOGD("X camera id %d", hw->getCameraId());
    304 
    305    return ret;
    306 }
    307 
    308 /*===========================================================================
    309  * FUNCTION   : prepare_preview
    310  *
    311  * DESCRIPTION: prepare preview
    312  *
    313  * PARAMETERS :
    314  *   @device  : ptr to camera device struct
    315  *
    316  * RETURN     : int32_t type of status
    317  *              NO_ERROR  -- success
    318  *              none-zero failure code
    319  *==========================================================================*/
    320 int QCamera2HardwareInterface::prepare_preview(struct camera_device *device)
    321 {
    322     ATRACE_CALL();
    323     int ret = NO_ERROR;
    324     QCamera2HardwareInterface *hw =
    325         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    326     if (!hw) {
    327         LOGE("NULL camera device");
    328         return BAD_VALUE;
    329     }
    330     LOGH("[KPI Perf]: E PROFILE_PREPARE_PREVIEW camera id %d",
    331              hw->getCameraId());
    332     hw->lockAPI();
    333     qcamera_api_result_t apiResult;
    334     qcamera_sm_evt_enum_t evt = QCAMERA_SM_EVT_PREPARE_PREVIEW;
    335     ret = hw->processAPI(evt, NULL);
    336     if (ret == NO_ERROR) {
    337         hw->waitAPIResult(evt, &apiResult);
    338         ret = apiResult.status;
    339     }
    340     hw->unlockAPI();
    341     LOGH("[KPI Perf]: X");
    342     return ret;
    343 }
    344 
    345 
    346 /*===========================================================================
    347  * FUNCTION   : start_preview
    348  *
    349  * DESCRIPTION: start preview
    350  *
    351  * PARAMETERS :
    352  *   @device  : ptr to camera device struct
    353  *
    354  * RETURN     : int32_t type of status
    355  *              NO_ERROR  -- success
    356  *              none-zero failure code
    357  *==========================================================================*/
    358 int QCamera2HardwareInterface::start_preview(struct camera_device *device)
    359 {
    360     KPI_ATRACE_CALL();
    361     int ret = NO_ERROR;
    362     QCamera2HardwareInterface *hw =
    363         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    364     if (!hw) {
    365         LOGE("NULL camera device");
    366         return BAD_VALUE;
    367     }
    368     LOGI("[KPI Perf]: E PROFILE_START_PREVIEW camera id %d",
    369              hw->getCameraId());
    370 
    371     // Release the timed perf lock acquired in openCamera
    372     hw->m_perfLock.lock_rel_timed();
    373 
    374     hw->m_perfLock.lock_acq();
    375     hw->lockAPI();
    376     qcamera_api_result_t apiResult;
    377     qcamera_sm_evt_enum_t evt = QCAMERA_SM_EVT_START_PREVIEW;
    378     if (hw->isNoDisplayMode()) {
    379         evt = QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW;
    380     }
    381     ret = hw->processAPI(evt, NULL);
    382     if (ret == NO_ERROR) {
    383         hw->waitAPIResult(evt, &apiResult);
    384         ret = apiResult.status;
    385     }
    386     hw->unlockAPI();
    387     hw->m_bPreviewStarted = true;
    388     LOGI("[KPI Perf]: X ret = %d", ret);
    389     return ret;
    390 }
    391 
    392 /*===========================================================================
    393  * FUNCTION   : stop_preview
    394  *
    395  * DESCRIPTION: stop preview
    396  *
    397  * PARAMETERS :
    398  *   @device  : ptr to camera device struct
    399  *
    400  * RETURN     : none
    401  *==========================================================================*/
    402 void QCamera2HardwareInterface::stop_preview(struct camera_device *device)
    403 {
    404     KPI_ATRACE_CALL();
    405     QCamera2HardwareInterface *hw =
    406         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    407     if (!hw) {
    408         LOGE("NULL camera device");
    409         return;
    410     }
    411     LOGI("[KPI Perf]: E PROFILE_STOP_PREVIEW camera id %d",
    412              hw->getCameraId());
    413 
    414     // Disable power Hint for preview
    415     hw->m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, false);
    416 
    417     hw->m_perfLock.lock_acq();
    418     hw->lockAPI();
    419     qcamera_api_result_t apiResult;
    420     int32_t ret = hw->processAPI(QCAMERA_SM_EVT_STOP_PREVIEW, NULL);
    421     if (ret == NO_ERROR) {
    422         hw->waitAPIResult(QCAMERA_SM_EVT_STOP_PREVIEW, &apiResult);
    423     }
    424     hw->unlockAPI();
    425     LOGI("[KPI Perf]: X ret = %d", ret);
    426 }
    427 
    428 /*===========================================================================
    429  * FUNCTION   : preview_enabled
    430  *
    431  * DESCRIPTION: if preview is running
    432  *
    433  * PARAMETERS :
    434  *   @device  : ptr to camera device struct
    435  *
    436  * RETURN     : 1 -- running
    437  *              0 -- not running
    438  *==========================================================================*/
    439 int QCamera2HardwareInterface::preview_enabled(struct camera_device *device)
    440 {
    441     ATRACE_CALL();
    442     int ret = NO_ERROR;
    443     QCamera2HardwareInterface *hw =
    444         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    445     if (!hw) {
    446         LOGE("NULL camera device");
    447         return BAD_VALUE;
    448     }
    449     LOGD("E camera id %d", hw->getCameraId());
    450 
    451     hw->lockAPI();
    452     qcamera_api_result_t apiResult;
    453     ret = hw->processAPI(QCAMERA_SM_EVT_PREVIEW_ENABLED, NULL);
    454     if (ret == NO_ERROR) {
    455         hw->waitAPIResult(QCAMERA_SM_EVT_PREVIEW_ENABLED, &apiResult);
    456         ret = apiResult.enabled;
    457     }
    458 
    459     //if preview enabled, can enable preview callback send
    460     if(apiResult.enabled) {
    461         hw->m_stateMachine.setPreviewCallbackNeeded(true);
    462     }
    463     hw->unlockAPI();
    464     LOGD("X camera id %d", hw->getCameraId());
    465 
    466     return ret;
    467 }
    468 
    469 /*===========================================================================
    470  * FUNCTION   : store_meta_data_in_buffers
    471  *
    472  * DESCRIPTION: if need to store meta data in buffers for video frame
    473  *
    474  * PARAMETERS :
    475  *   @device  : ptr to camera device struct
    476  *   @enable  : flag if enable
    477  *
    478  * RETURN     : int32_t type of status
    479  *              NO_ERROR  -- success
    480  *              none-zero failure code
    481  *==========================================================================*/
    482 int QCamera2HardwareInterface::store_meta_data_in_buffers(
    483                 struct camera_device *device, int enable)
    484 {
    485     int ret = NO_ERROR;
    486     QCamera2HardwareInterface *hw =
    487         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    488     if (!hw) {
    489         LOGE("NULL camera device");
    490         return BAD_VALUE;
    491     }
    492     LOGD("E camera id %d", hw->getCameraId());
    493 
    494     hw->lockAPI();
    495     qcamera_api_result_t apiResult;
    496     ret = hw->processAPI(QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS, (void *)&enable);
    497     if (ret == NO_ERROR) {
    498         hw->waitAPIResult(QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS, &apiResult);
    499         ret = apiResult.status;
    500     }
    501     hw->unlockAPI();
    502     LOGD("X camera id %d", hw->getCameraId());
    503 
    504     return ret;
    505 }
    506 
    507 /*===========================================================================
    508  * FUNCTION   : restart_start_preview
    509  *
    510  * DESCRIPTION: start preview as part of the restart preview
    511  *
    512  * PARAMETERS :
    513  *   @device  : ptr to camera device struct
    514  *
    515  * RETURN     : int32_t type of status
    516  *              NO_ERROR  -- success
    517  *              none-zero failure code
    518  *==========================================================================*/
    519 int QCamera2HardwareInterface::restart_start_preview(struct camera_device *device)
    520 {
    521     ATRACE_CALL();
    522     int ret = NO_ERROR;
    523     QCamera2HardwareInterface *hw =
    524         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    525     if (!hw) {
    526         LOGE("NULL camera device");
    527         return BAD_VALUE;
    528     }
    529     LOGI("E camera id %d", hw->getCameraId());
    530     hw->lockAPI();
    531     qcamera_api_result_t apiResult;
    532 
    533     if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
    534         ret = hw->processAPI(QCAMERA_SM_EVT_RESTART_START_PREVIEW, NULL);
    535         if (ret == NO_ERROR) {
    536             hw->waitAPIResult(QCAMERA_SM_EVT_RESTART_START_PREVIEW, &apiResult);
    537             ret = apiResult.status;
    538         }
    539     } else {
    540         LOGE("This function is not supposed to be called in single-camera mode");
    541         ret = INVALID_OPERATION;
    542     }
    543     // Preview restart done, update the mPreviewRestartNeeded flag to false.
    544     hw->mPreviewRestartNeeded = false;
    545     hw->unlockAPI();
    546     LOGI("X camera id %d", hw->getCameraId());
    547 
    548     return ret;
    549 }
    550 
    551 /*===========================================================================
    552  * FUNCTION   : restart_stop_preview
    553  *
    554  * DESCRIPTION: stop preview as part of the restart preview
    555  *
    556  * PARAMETERS :
    557  *   @device  : ptr to camera device struct
    558  *
    559  * RETURN     : int32_t type of status
    560  *              NO_ERROR  -- success
    561  *              none-zero failure code
    562  *==========================================================================*/
    563 int QCamera2HardwareInterface::restart_stop_preview(struct camera_device *device)
    564 {
    565     ATRACE_CALL();
    566     int ret = NO_ERROR;
    567     QCamera2HardwareInterface *hw =
    568         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    569     if (!hw) {
    570         LOGE("NULL camera device");
    571         return BAD_VALUE;
    572     }
    573     LOGI("E camera id %d", hw->getCameraId());
    574     hw->lockAPI();
    575     qcamera_api_result_t apiResult;
    576 
    577     if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
    578         ret = hw->processAPI(QCAMERA_SM_EVT_RESTART_STOP_PREVIEW, NULL);
    579         if (ret == NO_ERROR) {
    580             hw->waitAPIResult(QCAMERA_SM_EVT_RESTART_STOP_PREVIEW, &apiResult);
    581             ret = apiResult.status;
    582         }
    583     } else {
    584         LOGE("This function is not supposed to be called in single-camera mode");
    585         ret = INVALID_OPERATION;
    586     }
    587 
    588     hw->unlockAPI();
    589     LOGI("X camera id %d", hw->getCameraId());
    590 
    591     return ret;
    592 }
    593 
    594 /*===========================================================================
    595  * FUNCTION   : pre_start_recording
    596  *
    597  * DESCRIPTION: prepare for the start recording
    598  *
    599  * PARAMETERS :
    600  *   @device  : ptr to camera device struct
    601  *
    602  * RETURN     : int32_t type of status
    603  *              NO_ERROR  -- success
    604  *              none-zero failure code
    605  *==========================================================================*/
    606 int QCamera2HardwareInterface::pre_start_recording(struct camera_device *device)
    607 {
    608     ATRACE_CALL();
    609     int ret = NO_ERROR;
    610     QCamera2HardwareInterface *hw =
    611         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    612     if (!hw) {
    613         LOGE("NULL camera device");
    614         return BAD_VALUE;
    615     }
    616     LOGH("[KPI Perf]: E PROFILE_PRE_START_RECORDING camera id %d",
    617           hw->getCameraId());
    618     hw->lockAPI();
    619     qcamera_api_result_t apiResult;
    620     ret = hw->processAPI(QCAMERA_SM_EVT_PRE_START_RECORDING, NULL);
    621     if (ret == NO_ERROR) {
    622         hw->waitAPIResult(QCAMERA_SM_EVT_PRE_START_RECORDING, &apiResult);
    623         ret = apiResult.status;
    624     }
    625     hw->unlockAPI();
    626     LOGH("[KPI Perf]: X");
    627     return ret;
    628 }
    629 
    630 /*===========================================================================
    631  * FUNCTION   : start_recording
    632  *
    633  * DESCRIPTION: start recording
    634  *
    635  * PARAMETERS :
    636  *   @device  : ptr to camera device struct
    637  *
    638  * RETURN     : int32_t type of status
    639  *              NO_ERROR  -- success
    640  *              none-zero failure code
    641  *==========================================================================*/
    642 int QCamera2HardwareInterface::start_recording(struct camera_device *device)
    643 {
    644     ATRACE_CALL();
    645     int ret = NO_ERROR;
    646     QCamera2HardwareInterface *hw =
    647         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    648     if (!hw) {
    649         LOGE("NULL camera device");
    650         return BAD_VALUE;
    651     }
    652     LOGI("[KPI Perf]: E PROFILE_START_RECORDING camera id %d",
    653           hw->getCameraId());
    654     // Give HWI control to call pre_start_recording in single camera mode.
    655     // In dual-cam mode, this control belongs to muxer.
    656     if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
    657         ret = pre_start_recording(device);
    658         if (ret != NO_ERROR) {
    659             LOGE("pre_start_recording failed with ret = %d", ret);
    660             return ret;
    661         }
    662     }
    663 
    664     hw->lockAPI();
    665     qcamera_api_result_t apiResult;
    666     ret = hw->processAPI(QCAMERA_SM_EVT_START_RECORDING, NULL);
    667     if (ret == NO_ERROR) {
    668         hw->waitAPIResult(QCAMERA_SM_EVT_START_RECORDING, &apiResult);
    669         ret = apiResult.status;
    670     }
    671     hw->unlockAPI();
    672     hw->m_bRecordStarted = true;
    673     LOGI("[KPI Perf]: X ret = %d", ret);
    674 
    675     return ret;
    676 }
    677 
    678 /*===========================================================================
    679  * FUNCTION   : stop_recording
    680  *
    681  * DESCRIPTION: stop recording
    682  *
    683  * PARAMETERS :
    684  *   @device  : ptr to camera device struct
    685  *
    686  * RETURN     : none
    687  *==========================================================================*/
    688 void QCamera2HardwareInterface::stop_recording(struct camera_device *device)
    689 {
    690     ATRACE_CALL();
    691     QCamera2HardwareInterface *hw =
    692         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    693     if (!hw) {
    694         LOGE("NULL camera device");
    695         return;
    696     }
    697     LOGI("[KPI Perf]: E PROFILE_STOP_RECORDING camera id %d",
    698              hw->getCameraId());
    699 
    700     hw->lockAPI();
    701     qcamera_api_result_t apiResult;
    702     int32_t ret = hw->processAPI(QCAMERA_SM_EVT_STOP_RECORDING, NULL);
    703     if (ret == NO_ERROR) {
    704         hw->waitAPIResult(QCAMERA_SM_EVT_STOP_RECORDING, &apiResult);
    705     }
    706     hw->unlockAPI();
    707     LOGI("[KPI Perf]: X ret = %d", ret);
    708 }
    709 
    710 /*===========================================================================
    711  * FUNCTION   : recording_enabled
    712  *
    713  * DESCRIPTION: if recording is running
    714  *
    715  * PARAMETERS :
    716  *   @device  : ptr to camera device struct
    717  *
    718  * RETURN     : 1 -- running
    719  *              0 -- not running
    720  *==========================================================================*/
    721 int QCamera2HardwareInterface::recording_enabled(struct camera_device *device)
    722 {
    723     ATRACE_CALL();
    724     int ret = NO_ERROR;
    725     QCamera2HardwareInterface *hw =
    726         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    727     if (!hw) {
    728         LOGE("NULL camera device");
    729         return BAD_VALUE;
    730     }
    731     LOGD("E camera id %d", hw->getCameraId());
    732     hw->lockAPI();
    733     qcamera_api_result_t apiResult;
    734     ret = hw->processAPI(QCAMERA_SM_EVT_RECORDING_ENABLED, NULL);
    735     if (ret == NO_ERROR) {
    736         hw->waitAPIResult(QCAMERA_SM_EVT_RECORDING_ENABLED, &apiResult);
    737         ret = apiResult.enabled;
    738     }
    739     hw->unlockAPI();
    740     LOGD("X camera id %d", hw->getCameraId());
    741 
    742     return ret;
    743 }
    744 
    745 /*===========================================================================
    746  * FUNCTION   : release_recording_frame
    747  *
    748  * DESCRIPTION: return recording frame back
    749  *
    750  * PARAMETERS :
    751  *   @device  : ptr to camera device struct
    752  *   @opaque  : ptr to frame to be returned
    753  *
    754  * RETURN     : none
    755  *==========================================================================*/
    756 void QCamera2HardwareInterface::release_recording_frame(
    757             struct camera_device *device, const void *opaque)
    758 {
    759     ATRACE_CALL();
    760     int32_t ret = NO_ERROR;
    761     QCamera2HardwareInterface *hw =
    762         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    763     if (!hw) {
    764         LOGE("NULL camera device");
    765         return;
    766     }
    767     if (!opaque) {
    768         LOGE("Error!! Frame info is NULL");
    769         return;
    770     }
    771     LOGD("E camera id %d", hw->getCameraId());
    772 
    773     //Close and delete duplicated native handle and FD's.
    774     if (hw->mVideoMem != NULL) {
    775         ret = hw->mVideoMem->closeNativeHandle(opaque,
    776                 hw->mStoreMetaDataInFrame > 0);
    777         if (ret != NO_ERROR) {
    778             LOGE("Invalid video metadata");
    779             return;
    780         }
    781     } else {
    782         LOGW("Possible FD leak. Release recording called after stop");
    783     }
    784 
    785     hw->lockAPI();
    786     qcamera_api_result_t apiResult;
    787     ret = hw->processAPI(QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME, (void *)opaque);
    788     if (ret == NO_ERROR) {
    789         hw->waitAPIResult(QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME, &apiResult);
    790     }
    791     hw->unlockAPI();
    792     LOGD("X camera id %d", hw->getCameraId());
    793 }
    794 
    795 /*===========================================================================
    796  * FUNCTION   : auto_focus
    797  *
    798  * DESCRIPTION: start auto focus
    799  *
    800  * PARAMETERS :
    801  *   @device  : ptr to camera device struct
    802  *
    803  * RETURN     : int32_t type of status
    804  *              NO_ERROR  -- success
    805  *              none-zero failure code
    806  *==========================================================================*/
    807 int QCamera2HardwareInterface::auto_focus(struct camera_device *device)
    808 {
    809     KPI_ATRACE_INT("Camera:AutoFocus", 1);
    810     int ret = NO_ERROR;
    811     QCamera2HardwareInterface *hw =
    812         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    813     if (!hw) {
    814         LOGE("NULL camera device");
    815         return BAD_VALUE;
    816     }
    817     LOGH("[KPI Perf] : E PROFILE_AUTO_FOCUS camera id %d",
    818              hw->getCameraId());
    819     hw->lockAPI();
    820     qcamera_api_result_t apiResult;
    821     ret = hw->processAPI(QCAMERA_SM_EVT_START_AUTO_FOCUS, NULL);
    822     if (ret == NO_ERROR) {
    823         hw->waitAPIResult(QCAMERA_SM_EVT_START_AUTO_FOCUS, &apiResult);
    824         ret = apiResult.status;
    825     }
    826     hw->unlockAPI();
    827     LOGH("[KPI Perf] : X ret = %d", ret);
    828 
    829     return ret;
    830 }
    831 
    832 /*===========================================================================
    833  * FUNCTION   : cancel_auto_focus
    834  *
    835  * DESCRIPTION: cancel auto focus
    836  *
    837  * PARAMETERS :
    838  *   @device  : ptr to camera device struct
    839  *
    840  * RETURN     : int32_t type of status
    841  *              NO_ERROR  -- success
    842  *              none-zero failure code
    843  *==========================================================================*/
    844 int QCamera2HardwareInterface::cancel_auto_focus(struct camera_device *device)
    845 {
    846     ATRACE_CALL();
    847     int ret = NO_ERROR;
    848     QCamera2HardwareInterface *hw =
    849         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    850     if (!hw) {
    851         LOGE("NULL camera device");
    852         return BAD_VALUE;
    853     }
    854     LOGH("[KPI Perf] : E PROFILE_CANCEL_AUTO_FOCUS camera id %d",
    855              hw->getCameraId());
    856     hw->lockAPI();
    857     qcamera_api_result_t apiResult;
    858     ret = hw->processAPI(QCAMERA_SM_EVT_STOP_AUTO_FOCUS, NULL);
    859     if (ret == NO_ERROR) {
    860         hw->waitAPIResult(QCAMERA_SM_EVT_STOP_AUTO_FOCUS, &apiResult);
    861         ret = apiResult.status;
    862     }
    863     hw->unlockAPI();
    864     LOGH("[KPI Perf] : X ret = %d", ret);
    865     return ret;
    866 }
    867 
    868 /*===========================================================================
    869  * FUNCTION   : pre_take_picture
    870  *
    871  * DESCRIPTION: pre take picture, restart preview if necessary.
    872  *
    873  * PARAMETERS :
    874  *   @device  : ptr to camera device struct
    875  *
    876  * RETURN     : int32_t type of status
    877  *              NO_ERROR  -- success
    878  *              none-zero failure code
    879  *==========================================================================*/
    880 int QCamera2HardwareInterface::pre_take_picture(struct camera_device *device)
    881 {
    882     ATRACE_CALL();
    883     int ret = NO_ERROR;
    884     QCamera2HardwareInterface *hw =
    885         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    886     if (!hw) {
    887         LOGE("NULL camera device");
    888         return BAD_VALUE;
    889     }
    890     LOGH("[KPI Perf]: E PROFILE_PRE_TAKE_PICTURE camera id %d",
    891           hw->getCameraId());
    892     hw->lockAPI();
    893     qcamera_api_result_t apiResult;
    894     ret = hw->processAPI(QCAMERA_SM_EVT_PRE_TAKE_PICTURE, NULL);
    895     if (ret == NO_ERROR) {
    896         hw->waitAPIResult(QCAMERA_SM_EVT_PRE_TAKE_PICTURE, &apiResult);
    897         ret = apiResult.status;
    898     }
    899     hw->unlockAPI();
    900     LOGH("[KPI Perf]: X");
    901     return ret;
    902 }
    903 
    904 /*===========================================================================
    905  * FUNCTION   : take_picture
    906  *
    907  * DESCRIPTION: take picture
    908  *
    909  * PARAMETERS :
    910  *   @device  : ptr to camera device struct
    911  *
    912  * RETURN     : int32_t type of status
    913  *              NO_ERROR  -- success
    914  *              none-zero failure code
    915  *==========================================================================*/
    916 int QCamera2HardwareInterface::take_picture(struct camera_device *device)
    917 {
    918     KPI_ATRACE_CALL();
    919     int ret = NO_ERROR;
    920     QCamera2HardwareInterface *hw =
    921         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
    922     if (!hw) {
    923         LOGE("NULL camera device");
    924         return BAD_VALUE;
    925     }
    926     LOGI("[KPI Perf]: E PROFILE_TAKE_PICTURE camera id %d",
    927              hw->getCameraId());
    928     if (!hw->mLongshotEnabled) {
    929         hw->m_perfLock.lock_acq();
    930     }
    931     qcamera_api_result_t apiResult;
    932 
    933    /** Added support for Retro-active Frames:
    934      *  takePicture() is called before preparing Snapshot to indicate the
    935      *  mm-camera-channel to pick up legacy frames even
    936      *  before LED estimation is triggered.
    937      */
    938 
    939     LOGH("isLiveSnap %d, isZSL %d, isHDR %d longshot = %d",
    940            hw->isLiveSnapshot(), hw->isZSLMode(), hw->isHDRMode(),
    941            hw->isLongshotEnabled());
    942 
    943     // Check for Retro-active Frames
    944     if ((hw->mParameters.getNumOfRetroSnapshots() > 0) &&
    945         !hw->isLiveSnapshot() && hw->isZSLMode() &&
    946         !hw->isHDRMode() && !hw->isLongshotEnabled()) {
    947         // Set Retro Picture Mode
    948         hw->setRetroPicture(1);
    949         hw->m_bLedAfAecLock = 0;
    950         LOGL("Retro Enabled");
    951 
    952         // Give HWI control to call pre_take_picture in single camera mode.
    953         // In dual-cam mode, this control belongs to muxer.
    954         if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
    955             ret = pre_take_picture(device);
    956             if (ret != NO_ERROR) {
    957                 LOGE("pre_take_picture failed with ret = %d",ret);
    958                 return ret;
    959             }
    960         }
    961 
    962         /* Call take Picture for total number of snapshots required.
    963              This includes the number of retro frames and normal frames */
    964         hw->lockAPI();
    965         ret = hw->processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
    966         if (ret == NO_ERROR) {
    967           // Wait for retro frames, before calling prepare snapshot
    968           LOGD("Wait for Retro frames to be done");
    969           hw->waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
    970             ret = apiResult.status;
    971         }
    972         /* Unlock API since it is acquired in prepare snapshot seperately */
    973         hw->unlockAPI();
    974 
    975         /* Prepare snapshot in case LED needs to be flashed */
    976         LOGD("Start Prepare Snapshot");
    977         ret = hw->prepare_snapshot(device);
    978     }
    979     else {
    980         hw->setRetroPicture(0);
    981         // Check if prepare snapshot is done
    982         if (!hw->mPrepSnapRun) {
    983             // Ignore the status from prepare_snapshot
    984             hw->prepare_snapshot(device);
    985         }
    986 
    987         // Give HWI control to call pre_take_picture in single camera mode.
    988         // In dual-cam mode, this control belongs to muxer.
    989         if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
    990             ret = pre_take_picture(device);
    991             if (ret != NO_ERROR) {
    992                 LOGE("pre_take_picture failed with ret = %d",ret);
    993                 return ret;
    994             }
    995         }
    996 
    997         // Regardless what the result value for prepare_snapshot,
    998         // go ahead with capture anyway. Just like the way autofocus
    999         // is handled in capture case
   1000         /* capture */
   1001         LOGL("Capturing normal frames");
   1002         hw->lockAPI();
   1003         ret = hw->processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
   1004         if (ret == NO_ERROR) {
   1005           hw->waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
   1006             ret = apiResult.status;
   1007         }
   1008         hw->unlockAPI();
   1009         if (!hw->isLongshotEnabled()){
   1010             // For longshot mode, we prepare snapshot only once
   1011             hw->mPrepSnapRun = false;
   1012          }
   1013     }
   1014     LOGI("[KPI Perf]: X ret = %d", ret);
   1015     return ret;
   1016 }
   1017 
   1018 /*===========================================================================
   1019  * FUNCTION   : cancel_picture
   1020  *
   1021  * DESCRIPTION: cancel current take picture request
   1022  *
   1023  * PARAMETERS :
   1024  *   @device  : ptr to camera device struct
   1025  *
   1026  * RETURN     : int32_t type of status
   1027  *              NO_ERROR  -- success
   1028  *              none-zero failure code
   1029  *==========================================================================*/
   1030 int QCamera2HardwareInterface::cancel_picture(struct camera_device *device)
   1031 {
   1032     ATRACE_CALL();
   1033     int ret = NO_ERROR;
   1034     QCamera2HardwareInterface *hw =
   1035         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1036     if (!hw) {
   1037         LOGE("NULL camera device");
   1038         return BAD_VALUE;
   1039     }
   1040     LOGI("[KPI Perf]: E PROFILE_CANCEL_PICTURE camera id %d",
   1041              hw->getCameraId());
   1042     hw->lockAPI();
   1043     qcamera_api_result_t apiResult;
   1044     ret = hw->processAPI(QCAMERA_SM_EVT_CANCEL_PICTURE, NULL);
   1045     if (ret == NO_ERROR) {
   1046         hw->waitAPIResult(QCAMERA_SM_EVT_CANCEL_PICTURE, &apiResult);
   1047         ret = apiResult.status;
   1048     }
   1049     hw->unlockAPI();
   1050     LOGI("[KPI Perf]: X camera id %d ret = %d", hw->getCameraId(), ret);
   1051 
   1052     return ret;
   1053 }
   1054 
   1055 /*===========================================================================
   1056  * FUNCTION   : set_parameters
   1057  *
   1058  * DESCRIPTION: set camera parameters
   1059  *
   1060  * PARAMETERS :
   1061  *   @device  : ptr to camera device struct
   1062  *   @parms   : string of packed parameters
   1063  *
   1064  * RETURN     : int32_t type of status
   1065  *              NO_ERROR  -- success
   1066  *              none-zero failure code
   1067  *==========================================================================*/
   1068 int QCamera2HardwareInterface::set_parameters(struct camera_device *device,
   1069                                               const char *parms)
   1070 {
   1071     ATRACE_CALL();
   1072     int ret = NO_ERROR;
   1073     QCamera2HardwareInterface *hw =
   1074         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1075     if (!hw) {
   1076         LOGE("NULL camera device");
   1077         return BAD_VALUE;
   1078     }
   1079     LOGD("E camera id %d", hw->getCameraId());
   1080     hw->lockAPI();
   1081     qcamera_api_result_t apiResult;
   1082     ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS, (void *)parms);
   1083     if (ret == NO_ERROR) {
   1084         hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS, &apiResult);
   1085         ret = apiResult.status;
   1086     }
   1087 
   1088     // Give HWI control to restart (if necessary) after set params
   1089     // in single camera mode. In dual-cam mode, this control belongs to muxer.
   1090     if (hw->getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
   1091         if ((ret == NO_ERROR) && hw->getNeedRestart()) {
   1092             LOGD("stopping after param change");
   1093             ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_STOP, NULL);
   1094             if (ret == NO_ERROR) {
   1095                 hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_STOP, &apiResult);
   1096                 ret = apiResult.status;
   1097             }
   1098         }
   1099 
   1100         if (ret == NO_ERROR) {
   1101             LOGD("committing param change");
   1102             ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, NULL);
   1103             if (ret == NO_ERROR) {
   1104                 hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, &apiResult);
   1105                 ret = apiResult.status;
   1106             }
   1107         }
   1108 
   1109         if ((ret == NO_ERROR) && hw->getNeedRestart()) {
   1110             LOGD("restarting after param change");
   1111             ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_RESTART, NULL);
   1112             if (ret == NO_ERROR) {
   1113                 hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_RESTART, &apiResult);
   1114                 ret = apiResult.status;
   1115             }
   1116         }
   1117     }
   1118 
   1119     hw->unlockAPI();
   1120     LOGD("X camera id %d ret %d", hw->getCameraId(), ret);
   1121 
   1122     return ret;
   1123 }
   1124 
   1125 /*===========================================================================
   1126  * FUNCTION   : stop_after_set_params
   1127  *
   1128  * DESCRIPTION: stop after a set param call, if necessary
   1129  *
   1130  * PARAMETERS :
   1131  *   @device  : ptr to camera device struct
   1132  *
   1133  * RETURN     : int32_t type of status
   1134  *              NO_ERROR  -- success
   1135  *              none-zero failure code
   1136  *==========================================================================*/
   1137 int QCamera2HardwareInterface::stop_after_set_params(struct camera_device *device)
   1138 {
   1139     ATRACE_CALL();
   1140     int ret = NO_ERROR;
   1141     QCamera2HardwareInterface *hw =
   1142         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1143     if (!hw) {
   1144         LOGE("NULL camera device");
   1145         return BAD_VALUE;
   1146     }
   1147     LOGD("E camera id %d", hw->getCameraId());
   1148     hw->lockAPI();
   1149     qcamera_api_result_t apiResult;
   1150 
   1151     if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
   1152         ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_STOP, NULL);
   1153         if (ret == NO_ERROR) {
   1154             hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_STOP, &apiResult);
   1155             ret = apiResult.status;
   1156         }
   1157     } else {
   1158         LOGE("is not supposed to be called in single-camera mode");
   1159         ret = INVALID_OPERATION;
   1160     }
   1161 
   1162     hw->unlockAPI();
   1163     LOGD("X camera id %d", hw->getCameraId());
   1164 
   1165     return ret;
   1166 }
   1167 
   1168 /*===========================================================================
   1169  * FUNCTION   : commit_params
   1170  *
   1171  * DESCRIPTION: commit after a set param call
   1172  *
   1173  * PARAMETERS :
   1174  *   @device  : ptr to camera device struct
   1175  *
   1176  * RETURN     : int32_t type of status
   1177  *              NO_ERROR  -- success
   1178  *              none-zero failure code
   1179  *==========================================================================*/
   1180 int QCamera2HardwareInterface::commit_params(struct camera_device *device)
   1181 {
   1182     ATRACE_CALL();
   1183     int ret = NO_ERROR;
   1184     QCamera2HardwareInterface *hw =
   1185         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1186     if (!hw) {
   1187         LOGE("NULL camera device");
   1188         return BAD_VALUE;
   1189     }
   1190     LOGD("E camera id %d", hw->getCameraId());
   1191     hw->lockAPI();
   1192     qcamera_api_result_t apiResult;
   1193 
   1194     if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
   1195         ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, NULL);
   1196         if (ret == NO_ERROR) {
   1197             hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_COMMIT, &apiResult);
   1198             ret = apiResult.status;
   1199         }
   1200     } else {
   1201         LOGE("is not supposed to be called in single-camera mode");
   1202         ret = INVALID_OPERATION;
   1203     }
   1204 
   1205     hw->unlockAPI();
   1206     LOGD("X camera id %d", hw->getCameraId());
   1207 
   1208     return ret;
   1209 }
   1210 
   1211 /*===========================================================================
   1212  * FUNCTION   : restart_after_set_params
   1213  *
   1214  * DESCRIPTION: restart after a set param call, if necessary
   1215  *
   1216  * PARAMETERS :
   1217  *   @device  : ptr to camera device struct
   1218  *
   1219  * RETURN     : int32_t type of status
   1220  *              NO_ERROR  -- success
   1221  *              none-zero failure code
   1222  *==========================================================================*/
   1223 int QCamera2HardwareInterface::restart_after_set_params(struct camera_device *device)
   1224 {
   1225     ATRACE_CALL();
   1226     int ret = NO_ERROR;
   1227     QCamera2HardwareInterface *hw =
   1228         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1229     if (!hw) {
   1230         LOGE("NULL camera device");
   1231         return BAD_VALUE;
   1232     }
   1233     LOGD("E camera id %d", hw->getCameraId());
   1234     hw->lockAPI();
   1235     qcamera_api_result_t apiResult;
   1236 
   1237     if (hw->getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
   1238         ret = hw->processAPI(QCAMERA_SM_EVT_SET_PARAMS_RESTART, NULL);
   1239         if (ret == NO_ERROR) {
   1240             hw->waitAPIResult(QCAMERA_SM_EVT_SET_PARAMS_RESTART, &apiResult);
   1241             ret = apiResult.status;
   1242         }
   1243     } else {
   1244         LOGE("is not supposed to be called in single-camera mode");
   1245         ret = INVALID_OPERATION;
   1246     }
   1247 
   1248     hw->unlockAPI();
   1249     LOGD("X camera id %d", hw->getCameraId());
   1250     return ret;
   1251 }
   1252 
   1253 /*===========================================================================
   1254  * FUNCTION   : get_parameters
   1255  *
   1256  * DESCRIPTION: query camera parameters
   1257  *
   1258  * PARAMETERS :
   1259  *   @device  : ptr to camera device struct
   1260  *
   1261  * RETURN     : packed parameters in a string
   1262  *==========================================================================*/
   1263 char* QCamera2HardwareInterface::get_parameters(struct camera_device *device)
   1264 {
   1265     ATRACE_CALL();
   1266     char *ret = NULL;
   1267     QCamera2HardwareInterface *hw =
   1268         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1269     if (!hw) {
   1270         LOGE("NULL camera device");
   1271         return NULL;
   1272     }
   1273     LOGD("E camera id %d", hw->getCameraId());
   1274     hw->lockAPI();
   1275     qcamera_api_result_t apiResult;
   1276     int32_t rc = hw->processAPI(QCAMERA_SM_EVT_GET_PARAMS, NULL);
   1277     if (rc == NO_ERROR) {
   1278         hw->waitAPIResult(QCAMERA_SM_EVT_GET_PARAMS, &apiResult);
   1279         ret = apiResult.params;
   1280     }
   1281     hw->unlockAPI();
   1282     LOGD("E camera id %d", hw->getCameraId());
   1283 
   1284     return ret;
   1285 }
   1286 
   1287 /*===========================================================================
   1288  * FUNCTION   : put_parameters
   1289  *
   1290  * DESCRIPTION: return camera parameters string back to HAL
   1291  *
   1292  * PARAMETERS :
   1293  *   @device  : ptr to camera device struct
   1294  *   @parm    : ptr to parameter string to be returned
   1295  *
   1296  * RETURN     : none
   1297  *==========================================================================*/
   1298 void QCamera2HardwareInterface::put_parameters(struct camera_device *device,
   1299                                                char *parm)
   1300 {
   1301     ATRACE_CALL();
   1302     QCamera2HardwareInterface *hw =
   1303         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1304     if (!hw) {
   1305         LOGE("NULL camera device");
   1306         return;
   1307     }
   1308     LOGD("E camera id %d", hw->getCameraId());
   1309     hw->lockAPI();
   1310     qcamera_api_result_t apiResult;
   1311     int32_t ret = hw->processAPI(QCAMERA_SM_EVT_PUT_PARAMS, (void *)parm);
   1312     if (ret == NO_ERROR) {
   1313         hw->waitAPIResult(QCAMERA_SM_EVT_PUT_PARAMS, &apiResult);
   1314     }
   1315     hw->unlockAPI();
   1316     LOGD("E camera id %d", hw->getCameraId());
   1317 }
   1318 
   1319 /*===========================================================================
   1320  * FUNCTION   : send_command
   1321  *
   1322  * DESCRIPTION: command to be executed
   1323  *
   1324  * PARAMETERS :
   1325  *   @device  : ptr to camera device struct
   1326  *   @cmd     : cmd to be executed
   1327  *   @arg1    : ptr to optional argument1
   1328  *   @arg2    : ptr to optional argument2
   1329  *
   1330  * RETURN     : int32_t type of status
   1331  *              NO_ERROR  -- success
   1332  *              none-zero failure code
   1333  *==========================================================================*/
   1334 int QCamera2HardwareInterface::send_command(struct camera_device *device,
   1335                                             int32_t cmd,
   1336                                             int32_t arg1,
   1337                                             int32_t arg2)
   1338 {
   1339     ATRACE_CALL();
   1340     int ret = NO_ERROR;
   1341     QCamera2HardwareInterface *hw =
   1342         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1343     if (!hw) {
   1344         LOGE("NULL camera device");
   1345         return BAD_VALUE;
   1346     }
   1347     LOGD("E camera id %d", hw->getCameraId());
   1348 
   1349     qcamera_sm_evt_command_payload_t payload;
   1350     memset(&payload, 0, sizeof(qcamera_sm_evt_command_payload_t));
   1351     payload.cmd = cmd;
   1352     payload.arg1 = arg1;
   1353     payload.arg2 = arg2;
   1354     hw->lockAPI();
   1355     qcamera_api_result_t apiResult;
   1356     ret = hw->processAPI(QCAMERA_SM_EVT_SEND_COMMAND, (void *)&payload);
   1357     if (ret == NO_ERROR) {
   1358         hw->waitAPIResult(QCAMERA_SM_EVT_SEND_COMMAND, &apiResult);
   1359         ret = apiResult.status;
   1360     }
   1361     hw->unlockAPI();
   1362     LOGD("E camera id %d", hw->getCameraId());
   1363 
   1364     return ret;
   1365 }
   1366 
   1367 /*===========================================================================
   1368  * FUNCTION   : send_command_restart
   1369  *
   1370  * DESCRIPTION: restart if necessary after a send_command
   1371  *
   1372  * PARAMETERS :
   1373  *   @device  : ptr to camera device struct
   1374  *   @cmd     : cmd to be executed
   1375  *   @arg1    : ptr to optional argument1
   1376  *   @arg2    : ptr to optional argument2
   1377  *
   1378  * RETURN     : int32_t type of status
   1379  *              NO_ERROR  -- success
   1380  *              none-zero failure code
   1381  *==========================================================================*/
   1382 int QCamera2HardwareInterface::send_command_restart(struct camera_device *device,
   1383         int32_t cmd,
   1384         int32_t arg1,
   1385         int32_t arg2)
   1386 {
   1387     ATRACE_CALL();
   1388     int ret = NO_ERROR;
   1389     QCamera2HardwareInterface *hw =
   1390             reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1391     if (!hw) {
   1392         LOGE("NULL camera device");
   1393         return BAD_VALUE;
   1394     }
   1395 
   1396     qcamera_sm_evt_command_payload_t payload;
   1397     memset(&payload, 0, sizeof(qcamera_sm_evt_command_payload_t));
   1398     payload.cmd = cmd;
   1399     payload.arg1 = arg1;
   1400     payload.arg2 = arg2;
   1401     hw->lockAPI();
   1402     qcamera_api_result_t apiResult;
   1403     ret = hw->processAPI(QCAMERA_SM_EVT_SEND_COMMAND_RESTART, (void *)&payload);
   1404     if (ret == NO_ERROR) {
   1405         hw->waitAPIResult(QCAMERA_SM_EVT_SEND_COMMAND_RESTART, &apiResult);
   1406         ret = apiResult.status;
   1407     }
   1408     hw->unlockAPI();
   1409     LOGD("E camera id %d", hw->getCameraId());
   1410 
   1411     return ret;
   1412 }
   1413 
   1414 /*===========================================================================
   1415  * FUNCTION   : release
   1416  *
   1417  * DESCRIPTION: release camera resource
   1418  *
   1419  * PARAMETERS :
   1420  *   @device  : ptr to camera device struct
   1421  *
   1422  * RETURN     : none
   1423  *==========================================================================*/
   1424 void QCamera2HardwareInterface::release(struct camera_device *device)
   1425 {
   1426     ATRACE_CALL();
   1427     QCamera2HardwareInterface *hw =
   1428         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1429     if (!hw) {
   1430         LOGE("NULL camera device");
   1431         return;
   1432     }
   1433     LOGD("E camera id %d", hw->getCameraId());
   1434     hw->lockAPI();
   1435     qcamera_api_result_t apiResult;
   1436     int32_t ret = hw->processAPI(QCAMERA_SM_EVT_RELEASE, NULL);
   1437     if (ret == NO_ERROR) {
   1438         hw->waitAPIResult(QCAMERA_SM_EVT_RELEASE, &apiResult);
   1439     }
   1440     hw->unlockAPI();
   1441     LOGD("E camera id %d", hw->getCameraId());
   1442 }
   1443 
   1444 /*===========================================================================
   1445  * FUNCTION   : dump
   1446  *
   1447  * DESCRIPTION: dump camera status
   1448  *
   1449  * PARAMETERS :
   1450  *   @device  : ptr to camera device struct
   1451  *   @fd      : fd for status to be dumped to
   1452  *
   1453  * RETURN     : int32_t type of status
   1454  *              NO_ERROR  -- success
   1455  *              none-zero failure code
   1456  *==========================================================================*/
   1457 int QCamera2HardwareInterface::dump(struct camera_device *device, int fd)
   1458 {
   1459     int ret = NO_ERROR;
   1460 
   1461     //Log level property is read when "adb shell dumpsys media.camera" is
   1462     //called so that the log level can be controlled without restarting
   1463     //media server
   1464     getLogLevel();
   1465     QCamera2HardwareInterface *hw =
   1466         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1467     if (!hw) {
   1468         LOGE("NULL camera device");
   1469         return BAD_VALUE;
   1470     }
   1471     LOGD("E camera id %d", hw->getCameraId());
   1472     hw->lockAPI();
   1473     qcamera_api_result_t apiResult;
   1474     ret = hw->processAPI(QCAMERA_SM_EVT_DUMP, (void *)&fd);
   1475     if (ret == NO_ERROR) {
   1476         hw->waitAPIResult(QCAMERA_SM_EVT_DUMP, &apiResult);
   1477         ret = apiResult.status;
   1478     }
   1479     hw->unlockAPI();
   1480     LOGD("E camera id %d", hw->getCameraId());
   1481 
   1482     return ret;
   1483 }
   1484 
   1485 /*===========================================================================
   1486  * FUNCTION   : close_camera_device
   1487  *
   1488  * DESCRIPTION: close camera device
   1489  *
   1490  * PARAMETERS :
   1491  *   @device  : ptr to camera device struct
   1492  *
   1493  * RETURN     : int32_t type of status
   1494  *              NO_ERROR  -- success
   1495  *              none-zero failure code
   1496  *==========================================================================*/
   1497 int QCamera2HardwareInterface::close_camera_device(hw_device_t *hw_dev)
   1498 {
   1499     KPI_ATRACE_CALL();
   1500     int ret = NO_ERROR;
   1501 
   1502     QCamera2HardwareInterface *hw =
   1503         reinterpret_cast<QCamera2HardwareInterface *>(
   1504             reinterpret_cast<camera_device_t *>(hw_dev)->priv);
   1505     if (!hw) {
   1506         LOGE("NULL camera device");
   1507         return BAD_VALUE;
   1508     }
   1509     LOGI("[KPI Perf]: E camera id %d", hw->getCameraId());
   1510     delete hw;
   1511     LOGI("[KPI Perf]: X");
   1512     return ret;
   1513 }
   1514 
   1515 /*===========================================================================
   1516  * FUNCTION   : register_face_image
   1517  *
   1518  * DESCRIPTION: register a face image into imaging lib for face authenticatio/
   1519  *              face recognition
   1520  *
   1521  * PARAMETERS :
   1522  *   @device  : ptr to camera device struct
   1523  *   @img_ptr : ptr to image buffer
   1524  *   @config  : ptr to config about input image, i.e., format, dimension, and etc.
   1525  *
   1526  * RETURN     : >=0 unique ID of face registerd.
   1527  *              <0  failure.
   1528  *==========================================================================*/
   1529 int QCamera2HardwareInterface::register_face_image(struct camera_device *device,
   1530                                                    void *img_ptr,
   1531                                                    cam_pp_offline_src_config_t *config)
   1532 {
   1533     ATRACE_CALL();
   1534     int ret = NO_ERROR;
   1535     QCamera2HardwareInterface *hw =
   1536         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1537     if (!hw) {
   1538         LOGE("NULL camera device");
   1539         return BAD_VALUE;
   1540     }
   1541     LOGD("E camera id %d", hw->getCameraId());
   1542     qcamera_sm_evt_reg_face_payload_t payload;
   1543     memset(&payload, 0, sizeof(qcamera_sm_evt_reg_face_payload_t));
   1544     payload.img_ptr = img_ptr;
   1545     payload.config = config;
   1546     hw->lockAPI();
   1547     qcamera_api_result_t apiResult;
   1548     ret = hw->processAPI(QCAMERA_SM_EVT_REG_FACE_IMAGE, (void *)&payload);
   1549     if (ret == NO_ERROR) {
   1550         hw->waitAPIResult(QCAMERA_SM_EVT_REG_FACE_IMAGE, &apiResult);
   1551         ret = apiResult.handle;
   1552     }
   1553     hw->unlockAPI();
   1554     LOGD("E camera id %d", hw->getCameraId());
   1555 
   1556     return ret;
   1557 }
   1558 
   1559 /*===========================================================================
   1560  * FUNCTION   : prepare_snapshot
   1561  *
   1562  * DESCRIPTION: prepares hardware for snapshot
   1563  *
   1564  * PARAMETERS :
   1565  *   @device  : ptr to camera device struct
   1566  *
   1567  * RETURN     : int32_t type of status
   1568  *              NO_ERROR  -- success
   1569  *              none-zero failure code
   1570  *==========================================================================*/
   1571 int QCamera2HardwareInterface::prepare_snapshot(struct camera_device *device)
   1572 {
   1573     ATRACE_CALL();
   1574     int ret = NO_ERROR;
   1575     QCamera2HardwareInterface *hw =
   1576         reinterpret_cast<QCamera2HardwareInterface *>(device->priv);
   1577     if (!hw) {
   1578         LOGE("NULL camera device");
   1579         return BAD_VALUE;
   1580     }
   1581     if (hw->isLongshotEnabled() && hw->mPrepSnapRun == true) {
   1582         // For longshot mode, we prepare snapshot only once
   1583         LOGH("prepare snapshot only once ");
   1584         return NO_ERROR;
   1585     }
   1586     LOGH("[KPI Perf]: E PROFILE_PREPARE_SNAPSHOT camera id %d",
   1587              hw->getCameraId());
   1588     hw->lockAPI();
   1589     qcamera_api_result_t apiResult;
   1590 
   1591     /* Prepare snapshot in case LED needs to be flashed */
   1592     if (hw->mFlashNeeded || hw->mParameters.isChromaFlashEnabled()) {
   1593         /* Prepare snapshot in case LED needs to be flashed */
   1594         ret = hw->processAPI(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, NULL);
   1595         if (ret == NO_ERROR) {
   1596           hw->waitAPIResult(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, &apiResult);
   1597             ret = apiResult.status;
   1598         }
   1599         hw->mPrepSnapRun = true;
   1600     }
   1601     hw->unlockAPI();
   1602     LOGH("[KPI Perf]: X, ret: %d", ret);
   1603     return ret;
   1604 }
   1605 
   1606 /*===========================================================================
   1607  * FUNCTION   : QCamera2HardwareInterface
   1608  *
   1609  * DESCRIPTION: constructor of QCamera2HardwareInterface
   1610  *
   1611  * PARAMETERS :
   1612  *   @cameraId  : camera ID
   1613  *
   1614  * RETURN     : none
   1615  *==========================================================================*/
   1616 QCamera2HardwareInterface::QCamera2HardwareInterface(uint32_t cameraId)
   1617     : mCameraId(cameraId),
   1618       mCameraHandle(NULL),
   1619       mCameraOpened(false),
   1620       m_bRelCamCalibValid(false),
   1621       mPreviewWindow(NULL),
   1622       mMsgEnabled(0),
   1623       mStoreMetaDataInFrame(0),
   1624       mJpegCb(NULL),
   1625       mCallbackCookie(NULL),
   1626       mJpegCallbackCookie(NULL),
   1627       m_bMpoEnabled(TRUE),
   1628       m_stateMachine(this),
   1629       m_smThreadActive(true),
   1630       m_postprocessor(this),
   1631       m_thermalAdapter(QCameraThermalAdapter::getInstance()),
   1632       m_cbNotifier(this),
   1633       m_bPreviewStarted(false),
   1634       m_bRecordStarted(false),
   1635       m_currentFocusState(CAM_AF_STATE_INACTIVE),
   1636       mDumpFrmCnt(0U),
   1637       mDumpSkipCnt(0U),
   1638       mThermalLevel(QCAMERA_THERMAL_NO_ADJUSTMENT),
   1639       mActiveAF(false),
   1640       m_HDRSceneEnabled(false),
   1641       mLongshotEnabled(false),
   1642       mLiveSnapshotThread(0),
   1643       mIntPicThread(0),
   1644       mFlashNeeded(false),
   1645       mDeviceRotation(0U),
   1646       mCaptureRotation(0U),
   1647       mJpegExifRotation(0U),
   1648       mUseJpegExifRotation(false),
   1649       mIs3ALocked(false),
   1650       mPrepSnapRun(false),
   1651       mZoomLevel(0),
   1652       mPreviewRestartNeeded(false),
   1653       mVFrameCount(0),
   1654       mVLastFrameCount(0),
   1655       mVLastFpsTime(0),
   1656       mVFps(0),
   1657       mPFrameCount(0),
   1658       mPLastFrameCount(0),
   1659       mPLastFpsTime(0),
   1660       mPFps(0),
   1661       mInstantAecFrameCount(0),
   1662       m_bIntJpegEvtPending(false),
   1663       m_bIntRawEvtPending(false),
   1664       mReprocJob(0),
   1665       mJpegJob(0),
   1666       mMetadataAllocJob(0),
   1667       mInitPProcJob(0),
   1668       mParamAllocJob(0),
   1669       mParamInitJob(0),
   1670       mOutputCount(0),
   1671       mInputCount(0),
   1672       mAdvancedCaptureConfigured(false),
   1673       mHDRBracketingEnabled(false),
   1674       mNumPreviewFaces(-1),
   1675       mJpegClientHandle(0),
   1676       mJpegHandleOwner(false),
   1677       mMetadataMem(NULL),
   1678       mVideoMem(NULL),
   1679       mCACDoneReceived(false),
   1680       m_bNeedRestart(false)
   1681 {
   1682 #ifdef TARGET_TS_MAKEUP
   1683     memset(&mFaceRect, -1, sizeof(mFaceRect));
   1684 #endif
   1685     getLogLevel();
   1686     ATRACE_CALL();
   1687     mCameraDevice.common.tag = HARDWARE_DEVICE_TAG;
   1688     mCameraDevice.common.version = HARDWARE_DEVICE_API_VERSION(1, 0);
   1689     mCameraDevice.common.close = close_camera_device;
   1690     mCameraDevice.ops = &mCameraOps;
   1691     mCameraDevice.priv = this;
   1692 
   1693     pthread_mutex_init(&m_lock, NULL);
   1694     pthread_cond_init(&m_cond, NULL);
   1695 
   1696     m_apiResultList = NULL;
   1697 
   1698     pthread_mutex_init(&m_evtLock, NULL);
   1699     pthread_cond_init(&m_evtCond, NULL);
   1700     memset(&m_evtResult, 0, sizeof(qcamera_api_result_t));
   1701 
   1702 
   1703     pthread_mutex_init(&m_int_lock, NULL);
   1704     pthread_cond_init(&m_int_cond, NULL);
   1705 
   1706     memset(m_channels, 0, sizeof(m_channels));
   1707 
   1708     memset(&mExifParams, 0, sizeof(mm_jpeg_exif_params_t));
   1709 
   1710     memset(m_BackendFileName, 0, QCAMERA_MAX_FILEPATH_LENGTH);
   1711 
   1712     memset(mDefOngoingJobs, 0, sizeof(mDefOngoingJobs));
   1713     memset(&mJpegMetadata, 0, sizeof(mJpegMetadata));
   1714     memset(&mJpegHandle, 0, sizeof(mJpegHandle));
   1715     memset(&mJpegMpoHandle, 0, sizeof(mJpegMpoHandle));
   1716 
   1717     mDeferredWorkThread.launch(deferredWorkRoutine, this);
   1718     mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
   1719     m_perfLock.lock_init();
   1720 
   1721     pthread_mutex_init(&mGrallocLock, NULL);
   1722     mEnqueuedBuffers = 0;
   1723     mFrameSkipStart = 0;
   1724     mFrameSkipEnd = 0;
   1725     mLastPreviewFrameID = 0;
   1726 
   1727     //Load and read GPU library.
   1728     lib_surface_utils = NULL;
   1729     LINK_get_surface_pixel_alignment = NULL;
   1730     mSurfaceStridePadding = CAM_PAD_TO_32;
   1731     lib_surface_utils = dlopen("libadreno_utils.so", RTLD_NOW);
   1732     if (lib_surface_utils) {
   1733         *(void **)&LINK_get_surface_pixel_alignment =
   1734                 dlsym(lib_surface_utils, "get_gpu_pixel_alignment");
   1735          if (LINK_get_surface_pixel_alignment) {
   1736              mSurfaceStridePadding = LINK_get_surface_pixel_alignment();
   1737          }
   1738          dlclose(lib_surface_utils);
   1739     }
   1740 }
   1741 
   1742 /*===========================================================================
   1743  * FUNCTION   : ~QCamera2HardwareInterface
   1744  *
   1745  * DESCRIPTION: destructor of QCamera2HardwareInterface
   1746  *
   1747  * PARAMETERS : none
   1748  *
   1749  * RETURN     : none
   1750  *==========================================================================*/
   1751 QCamera2HardwareInterface::~QCamera2HardwareInterface()
   1752 {
   1753     LOGH("E");
   1754 
   1755     mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
   1756     mDeferredWorkThread.exit();
   1757 
   1758     if (mMetadataMem != NULL) {
   1759         delete mMetadataMem;
   1760         mMetadataMem = NULL;
   1761     }
   1762 
   1763     m_perfLock.lock_acq();
   1764     lockAPI();
   1765     m_smThreadActive = false;
   1766     unlockAPI();
   1767     m_stateMachine.releaseThread();
   1768     closeCamera();
   1769     m_perfLock.lock_rel();
   1770     m_perfLock.lock_deinit();
   1771     pthread_mutex_destroy(&m_lock);
   1772     pthread_cond_destroy(&m_cond);
   1773     pthread_mutex_destroy(&m_evtLock);
   1774     pthread_cond_destroy(&m_evtCond);
   1775     pthread_mutex_destroy(&m_int_lock);
   1776     pthread_cond_destroy(&m_int_cond);
   1777     pthread_mutex_destroy(&mGrallocLock);
   1778     LOGH("X");
   1779 }
   1780 
   1781 /*===========================================================================
   1782  * FUNCTION   : deferPPInit
   1783  *
   1784  * DESCRIPTION: Queue postproc init task to deferred thread
   1785  *
   1786  * PARAMETERS : none
   1787  *
   1788  * RETURN     : uint32_t job id of pproc init job
   1789  *              0  -- failure
   1790  *==========================================================================*/
   1791 uint32_t QCamera2HardwareInterface::deferPPInit()
   1792 {
   1793     // init pproc
   1794     DeferWorkArgs args;
   1795     DeferPProcInitArgs pprocInitArgs;
   1796 
   1797     memset(&args, 0, sizeof(DeferWorkArgs));
   1798     memset(&pprocInitArgs, 0, sizeof(DeferPProcInitArgs));
   1799 
   1800     pprocInitArgs.jpeg_cb = jpegEvtHandle;
   1801     pprocInitArgs.user_data = this;
   1802     args.pprocInitArgs = pprocInitArgs;
   1803 
   1804     return queueDeferredWork(CMD_DEF_PPROC_INIT,
   1805             args);
   1806 }
   1807 
   1808 /*===========================================================================
   1809  * FUNCTION   : openCamera
   1810  *
   1811  * DESCRIPTION: open camera
   1812  *
   1813  * PARAMETERS :
   1814  *   @hw_device  : double ptr for camera device struct
   1815  *
   1816  * RETURN     : int32_t type of status
   1817  *              NO_ERROR  -- success
   1818  *              none-zero failure code
   1819  *==========================================================================*/
   1820 int QCamera2HardwareInterface::openCamera(struct hw_device_t **hw_device)
   1821 {
   1822     KPI_ATRACE_CALL();
   1823     int rc = NO_ERROR;
   1824     if (mCameraOpened) {
   1825         *hw_device = NULL;
   1826         LOGE("Permission Denied");
   1827         return PERMISSION_DENIED;
   1828     }
   1829     LOGI("[KPI Perf]: E PROFILE_OPEN_CAMERA camera id %d",
   1830             mCameraId);
   1831     m_perfLock.lock_acq_timed(CAMERA_OPEN_PERF_TIME_OUT);
   1832     rc = openCamera();
   1833     if (rc == NO_ERROR){
   1834         *hw_device = &mCameraDevice.common;
   1835         if (m_thermalAdapter.init(this) != 0) {
   1836           LOGW("Init thermal adapter failed");
   1837         }
   1838     }
   1839     else
   1840         *hw_device = NULL;
   1841 
   1842     LOGI("[KPI Perf]: X PROFILE_OPEN_CAMERA camera id %d, rc: %d",
   1843             mCameraId, rc);
   1844 
   1845     return rc;
   1846 }
   1847 
   1848 /*===========================================================================
   1849  * FUNCTION   : openCamera
   1850  *
   1851  * DESCRIPTION: open camera
   1852  *
   1853  * PARAMETERS : none
   1854  *
   1855  * RETURN     : int32_t type of status
   1856  *              NO_ERROR  -- success
   1857  *              none-zero failure code
   1858  *==========================================================================*/
   1859 int QCamera2HardwareInterface::openCamera()
   1860 {
   1861     int32_t rc = NO_ERROR;
   1862     char value[PROPERTY_VALUE_MAX];
   1863 
   1864     if (mCameraHandle) {
   1865         LOGE("Failure: Camera already opened");
   1866         return ALREADY_EXISTS;
   1867     }
   1868 
   1869     rc = QCameraFlash::getInstance().reserveFlashForCamera(mCameraId);
   1870     if (rc < 0) {
   1871         LOGE("Failed to reserve flash for camera id: %d",
   1872                 mCameraId);
   1873         return UNKNOWN_ERROR;
   1874     }
   1875 
   1876     // alloc param buffer
   1877     DeferWorkArgs args;
   1878     memset(&args, 0, sizeof(args));
   1879     mParamAllocJob = queueDeferredWork(CMD_DEF_PARAM_ALLOC, args);
   1880     if (mParamAllocJob == 0) {
   1881         LOGE("Failed queueing PARAM_ALLOC job");
   1882         return -ENOMEM;
   1883     }
   1884 
   1885     if (gCamCapability[mCameraId] != NULL) {
   1886         // allocate metadata buffers
   1887         DeferWorkArgs args;
   1888         DeferMetadataAllocArgs metadataAllocArgs;
   1889 
   1890         memset(&args, 0, sizeof(args));
   1891         memset(&metadataAllocArgs, 0, sizeof(metadataAllocArgs));
   1892 
   1893         uint32_t padding =
   1894                 gCamCapability[mCameraId]->padding_info.plane_padding;
   1895         metadataAllocArgs.size = PAD_TO_SIZE(sizeof(metadata_buffer_t),
   1896                 padding);
   1897         metadataAllocArgs.bufferCnt = CAMERA_MIN_METADATA_BUFFERS;
   1898         args.metadataAllocArgs = metadataAllocArgs;
   1899 
   1900         mMetadataAllocJob = queueDeferredWork(CMD_DEF_METADATA_ALLOC, args);
   1901         if (mMetadataAllocJob == 0) {
   1902             LOGE("Failed to allocate metadata buffer");
   1903             rc = -ENOMEM;
   1904             goto error_exit1;
   1905         }
   1906 
   1907         rc = camera_open((uint8_t)mCameraId, &mCameraHandle);
   1908         if (rc) {
   1909             LOGE("camera_open failed. rc = %d, mCameraHandle = %p",
   1910                      rc, mCameraHandle);
   1911             goto error_exit2;
   1912         }
   1913 
   1914         mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
   1915                 camEvtHandle,
   1916                 (void *) this);
   1917     } else {
   1918         LOGH("Capabilities not inited, initializing now.");
   1919 
   1920         rc = camera_open((uint8_t)mCameraId, &mCameraHandle);
   1921         if (rc) {
   1922             LOGE("camera_open failed. rc = %d, mCameraHandle = %p",
   1923                      rc, mCameraHandle);
   1924             goto error_exit2;
   1925         }
   1926 
   1927         if(NO_ERROR != initCapabilities(mCameraId,mCameraHandle)) {
   1928             LOGE("initCapabilities failed.");
   1929             rc = UNKNOWN_ERROR;
   1930             goto error_exit3;
   1931         }
   1932 
   1933         mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
   1934                 camEvtHandle,
   1935                 (void *) this);
   1936     }
   1937 
   1938     // Init params in the background
   1939     // 1. It's safe to queue init job, even if alloc job is not yet complete.
   1940     // It will be queued to the same thread, so the alloc is guaranteed to
   1941     // finish first.
   1942     // 2. However, it is not safe to begin param init until after camera is
   1943     // open. That is why we wait until after camera open completes to schedule
   1944     // this task.
   1945     memset(&args, 0, sizeof(args));
   1946     mParamInitJob = queueDeferredWork(CMD_DEF_PARAM_INIT, args);
   1947     if (mParamInitJob == 0) {
   1948         LOGE("Failed queuing PARAM_INIT job");
   1949         rc = -ENOMEM;
   1950         goto error_exit3;
   1951     }
   1952 
   1953     mCameraOpened = true;
   1954 
   1955     //Notify display HAL that a camera session is active.
   1956     //But avoid calling the same during bootup because camera service might open/close
   1957     //cameras at boot time during its initialization and display service will also internally
   1958     //wait for camera service to initialize first while calling this display API, resulting in a
   1959     //deadlock situation. Since boot time camera open/close calls are made only to fetch
   1960     //capabilities, no need of this display bw optimization.
   1961     //Use "service.bootanim.exit" property to know boot status.
   1962     property_get("service.bootanim.exit", value, "0");
   1963     if (atoi(value) == 1) {
   1964         pthread_mutex_lock(&gCamLock);
   1965         if (gNumCameraSessions++ == 0) {
   1966             setCameraLaunchStatus(true);
   1967         }
   1968         pthread_mutex_unlock(&gCamLock);
   1969     }
   1970 
   1971     return NO_ERROR;
   1972 
   1973 error_exit3:
   1974     if(mJpegClientHandle) {
   1975         deinitJpegHandle();
   1976     }
   1977     mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
   1978     mCameraHandle = NULL;
   1979 error_exit2:
   1980     waitDeferredWork(mMetadataAllocJob);
   1981 error_exit1:
   1982     waitDeferredWork(mParamAllocJob);
   1983     return rc;
   1984 
   1985 }
   1986 
   1987 /*===========================================================================
   1988  * FUNCTION   : bundleRelatedCameras
   1989  *
   1990  * DESCRIPTION: bundle cameras to enable syncing of cameras
   1991  *
   1992  * PARAMETERS :
   1993  *   @sync        :indicates whether syncing is On or Off
   1994  *   @sessionid  :session id for other camera session
   1995  *
   1996  * RETURN     : int32_t type of status
   1997  *              NO_ERROR  -- success
   1998  *              none-zero failure code
   1999  *==========================================================================*/
   2000 int QCamera2HardwareInterface::bundleRelatedCameras(bool syncOn,
   2001             uint32_t sessionid)
   2002 {
   2003     LOGD("bundleRelatedCameras sync %d with sessionid %d",
   2004             syncOn, sessionid);
   2005 
   2006     int32_t rc = mParameters.bundleRelatedCameras(syncOn, sessionid);
   2007     if (rc != NO_ERROR) {
   2008         LOGE("bundleRelatedCameras failed %d", rc);
   2009         return rc;
   2010     }
   2011     return rc;
   2012 }
   2013 
   2014 /*===========================================================================
   2015  * FUNCTION   : getCameraSessionId
   2016  *
   2017  * DESCRIPTION: gets the backend session Id of this HWI instance
   2018  *
   2019  * PARAMETERS :
   2020  *   @sessionid  : pointer to the output session id
   2021  *
   2022  * RETURN     : int32_t type of status
   2023  *              NO_ERROR  -- success
   2024  *              none-zero failure code
   2025  *==========================================================================*/
   2026 int QCamera2HardwareInterface::getCameraSessionId(uint32_t* session_id)
   2027 {
   2028     int32_t rc = NO_ERROR;
   2029 
   2030     if(session_id != NULL) {
   2031         rc = mCameraHandle->ops->get_session_id(mCameraHandle->camera_handle,
   2032                 session_id);
   2033         LOGD("Getting Camera Session Id %d", *session_id);
   2034     } else {
   2035         LOGE("Session Id is Null");
   2036         return UNKNOWN_ERROR;
   2037     }
   2038     return rc;
   2039 }
   2040 
   2041 /*===========================================================================
   2042  * FUNCTION   : isFrameSyncEnabled
   2043  *
   2044  * DESCRIPTION: returns whether frame sync is enabled
   2045  *
   2046  * PARAMETERS : none
   2047  *
   2048  * RETURN     : bool indicating whether frame sync is enabled
   2049  *==========================================================================*/
   2050 bool QCamera2HardwareInterface::isFrameSyncEnabled(void)
   2051 {
   2052     return mParameters.isFrameSyncEnabled();
   2053 }
   2054 
   2055 /*===========================================================================
   2056  * FUNCTION   : setFrameSyncEnabled
   2057  *
   2058  * DESCRIPTION: sets whether frame sync is enabled
   2059  *
   2060  * PARAMETERS :
   2061  *   @enable  : flag whether to enable or disable frame sync
   2062  *
   2063  * RETURN     : int32_t type of status
   2064  *              NO_ERROR  -- success
   2065  *              none-zero failure code
   2066  *==========================================================================*/
   2067 int32_t QCamera2HardwareInterface::setFrameSyncEnabled(bool enable)
   2068 {
   2069     return mParameters.setFrameSyncEnabled(enable);
   2070 }
   2071 
   2072 /*===========================================================================
   2073  * FUNCTION   : getRelatedCamSyncInfo
   2074  *
   2075  * DESCRIPTION:returns the related cam sync info for this HWI instance
   2076  *
   2077  * PARAMETERS :none
   2078  *
   2079  * RETURN     : const pointer to cam_sync_related_sensors_event_info_t
   2080  *==========================================================================*/
   2081 const cam_sync_related_sensors_event_info_t*
   2082         QCamera2HardwareInterface::getRelatedCamSyncInfo(void)
   2083 {
   2084     return mParameters.getRelatedCamSyncInfo();
   2085 }
   2086 
   2087 /*===========================================================================
   2088  * FUNCTION   : setRelatedCamSyncInfo
   2089  *
   2090  * DESCRIPTION:sets the related cam sync info for this HWI instance
   2091  *
   2092  * PARAMETERS :
   2093  *   @info  : ptr to related cam info parameters
   2094  *
   2095  * RETURN     : int32_t type of status
   2096  *              NO_ERROR  -- success
   2097  *              none-zero failure code
   2098  *==========================================================================*/
   2099 int32_t QCamera2HardwareInterface::setRelatedCamSyncInfo(
   2100         cam_sync_related_sensors_event_info_t* info)
   2101 {
   2102     if(info) {
   2103         return mParameters.setRelatedCamSyncInfo(info);
   2104     } else {
   2105         return BAD_TYPE;
   2106     }
   2107 }
   2108 
   2109 /*===========================================================================
   2110  * FUNCTION   : getMpoComposition
   2111  *
   2112  * DESCRIPTION:function to retrieve whether Mpo composition should be enabled
   2113  *                    or not
   2114  *
   2115  * PARAMETERS :none
   2116  *
   2117  * RETURN     : bool indicates whether mpo composition is enabled or not
   2118  *==========================================================================*/
   2119 bool QCamera2HardwareInterface::getMpoComposition(void)
   2120 {
   2121     LOGH("MpoComposition:%d ", m_bMpoEnabled);
   2122     return m_bMpoEnabled;
   2123 }
   2124 
   2125 /*===========================================================================
   2126  * FUNCTION   : setMpoComposition
   2127  *
   2128  * DESCRIPTION:set if Mpo composition should be enabled for this HWI instance
   2129  *
   2130  * PARAMETERS :
   2131  *   @enable  : indicates whether Mpo composition enabled or not
   2132  *
   2133  * RETURN     : int32_t type of status
   2134  *              NO_ERROR  -- success
   2135  *              none-zero failure code
   2136  *==========================================================================*/
   2137 int32_t QCamera2HardwareInterface::setMpoComposition(bool enable)
   2138 {
   2139     // By default set Mpo composition to disable
   2140     m_bMpoEnabled = false;
   2141 
   2142     // Enable Mpo composition only if
   2143     // 1) frame sync is ON between two cameras and
   2144     // 2) any advanced features are not enabled (AOST features) and
   2145     // 3) not in recording mode (for liveshot case)
   2146     // 4) flash is not needed
   2147     if ((getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) &&
   2148             !mParameters.isAdvCamFeaturesEnabled() &&
   2149             !mParameters.getRecordingHintValue() &&
   2150             !mFlashNeeded &&
   2151             !isLongshotEnabled()) {
   2152         m_bMpoEnabled = enable;
   2153         LOGH("MpoComposition:%d ", m_bMpoEnabled);
   2154         return NO_ERROR;
   2155     } else {
   2156         return BAD_TYPE;
   2157     }
   2158 }
   2159 
   2160 /*===========================================================================
   2161  * FUNCTION   : getRecordingHintValue
   2162  *
   2163  * DESCRIPTION:function to retrieve recording hint value
   2164  *
   2165  * PARAMETERS :none
   2166  *
   2167  * RETURN     : bool indicates whether recording hint is enabled or not
   2168  *==========================================================================*/
   2169 bool QCamera2HardwareInterface::getRecordingHintValue(void)
   2170 {
   2171     return mParameters.getRecordingHintValue();
   2172 }
   2173 
   2174 /*===========================================================================
   2175  * FUNCTION   : setRecordingHintValue
   2176  *
   2177  * DESCRIPTION:set recording hint value
   2178  *
   2179  * PARAMETERS :
   2180  *   @enable  : video hint value
   2181  *
   2182  * RETURN     : int32_t type of status
   2183  *              NO_ERROR  -- success
   2184  *              none-zero failure code
   2185  *==========================================================================*/
   2186 int32_t QCamera2HardwareInterface::setRecordingHintValue(int32_t value)
   2187 {
   2188     return mParameters.updateRecordingHintValue(value);
   2189 }
   2190 
   2191 /*===========================================================================
   2192  * FUNCTION   : closeCamera
   2193  *
   2194  * DESCRIPTION: close camera
   2195  *
   2196  * PARAMETERS : none
   2197  *
   2198  * RETURN     : int32_t type of status
   2199  *              NO_ERROR  -- success
   2200  *              none-zero failure code
   2201  *==========================================================================*/
   2202 int QCamera2HardwareInterface::closeCamera()
   2203 {
   2204     int rc = NO_ERROR;
   2205     int i;
   2206     char value[PROPERTY_VALUE_MAX];
   2207     LOGI("E");
   2208     if (!mCameraOpened) {
   2209         return NO_ERROR;
   2210     }
   2211     LOGI("[KPI Perf]: E PROFILE_CLOSE_CAMERA camera id %d",
   2212              mCameraId);
   2213 
   2214     // set open flag to false
   2215     mCameraOpened = false;
   2216 
   2217     // Reset Stream config info
   2218     mParameters.setStreamConfigure(false, false, true);
   2219 
   2220     // deinit Parameters
   2221     mParameters.deinit();
   2222 
   2223     // exit notifier
   2224     m_cbNotifier.exit();
   2225 
   2226     // stop and deinit postprocessor
   2227     waitDeferredWork(mReprocJob);
   2228     // Close the JPEG session
   2229     waitDeferredWork(mJpegJob);
   2230     m_postprocessor.stop();
   2231     deinitJpegHandle();
   2232     m_postprocessor.deinit();
   2233     mInitPProcJob = 0; // reset job id, so pproc can be reinited later
   2234 
   2235     m_thermalAdapter.deinit();
   2236 
   2237     // delete all channels if not already deleted
   2238     for (i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
   2239         if (m_channels[i] != NULL) {
   2240             m_channels[i]->stop();
   2241             delete m_channels[i];
   2242             m_channels[i] = NULL;
   2243         }
   2244     }
   2245 
   2246     //free all pending api results here
   2247     if(m_apiResultList != NULL) {
   2248         api_result_list *apiResultList = m_apiResultList;
   2249         api_result_list *apiResultListNext;
   2250         while (apiResultList != NULL) {
   2251             apiResultListNext = apiResultList->next;
   2252             free(apiResultList);
   2253             apiResultList = apiResultListNext;
   2254         }
   2255     }
   2256 
   2257     rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
   2258     mCameraHandle = NULL;
   2259 
   2260     //Notify display HAL that there is no active camera session
   2261     //but avoid calling the same during bootup. Refer to openCamera
   2262     //for more details.
   2263     property_get("service.bootanim.exit", value, "0");
   2264     if (atoi(value) == 1) {
   2265         pthread_mutex_lock(&gCamLock);
   2266         if (--gNumCameraSessions == 0) {
   2267             setCameraLaunchStatus(false);
   2268         }
   2269         pthread_mutex_unlock(&gCamLock);
   2270     }
   2271 
   2272     if (mExifParams.debug_params) {
   2273         free(mExifParams.debug_params);
   2274         mExifParams.debug_params = NULL;
   2275     }
   2276 
   2277     if (QCameraFlash::getInstance().releaseFlashFromCamera(mCameraId) != 0) {
   2278         LOGD("Failed to release flash for camera id: %d",
   2279                 mCameraId);
   2280     }
   2281 
   2282     LOGI("[KPI Perf]: X PROFILE_CLOSE_CAMERA camera id %d, rc: %d",
   2283          mCameraId, rc);
   2284 
   2285     return rc;
   2286 }
   2287 
   2288 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
   2289 
   2290 /*===========================================================================
   2291  * FUNCTION   : initCapabilities
   2292  *
   2293  * DESCRIPTION: initialize camera capabilities in static data struct
   2294  *
   2295  * PARAMETERS :
   2296  *   @cameraId  : camera Id
   2297  *
   2298  * RETURN     : int32_t type of status
   2299  *              NO_ERROR  -- success
   2300  *              none-zero failure code
   2301  *==========================================================================*/
   2302 int QCamera2HardwareInterface::initCapabilities(uint32_t cameraId,
   2303         mm_camera_vtbl_t *cameraHandle)
   2304 {
   2305     ATRACE_CALL();
   2306     int rc = NO_ERROR;
   2307     QCameraHeapMemory *capabilityHeap = NULL;
   2308 
   2309     /* Allocate memory for capability buffer */
   2310     capabilityHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
   2311     rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), NON_SECURE);
   2312     if(rc != OK) {
   2313         LOGE("No memory for cappability");
   2314         goto allocate_failed;
   2315     }
   2316 
   2317     /* Map memory for capability buffer */
   2318     memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t));
   2319 
   2320     cam_buf_map_type_list bufMapList;
   2321     rc = QCameraBufferMaps::makeSingletonBufMapList(
   2322             CAM_MAPPING_BUF_TYPE_CAPABILITY,
   2323             0 /*stream id*/, 0 /*buffer index*/, -1 /*plane index*/,
   2324             0 /*cookie*/, capabilityHeap->getFd(0), sizeof(cam_capability_t),
   2325             bufMapList, capabilityHeap->getPtr(0));
   2326 
   2327     if (rc == NO_ERROR) {
   2328         rc = cameraHandle->ops->map_bufs(cameraHandle->camera_handle,
   2329                 &bufMapList);
   2330     }
   2331 
   2332     if(rc < 0) {
   2333         LOGE("failed to map capability buffer");
   2334         goto map_failed;
   2335     }
   2336 
   2337     /* Query Capability */
   2338     rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle);
   2339     if(rc < 0) {
   2340         LOGE("failed to query capability");
   2341         goto query_failed;
   2342     }
   2343     gCamCapability[cameraId] =
   2344             (cam_capability_t *)malloc(sizeof(cam_capability_t));
   2345 
   2346     if (!gCamCapability[cameraId]) {
   2347         LOGE("out of memory");
   2348         goto query_failed;
   2349     }
   2350     memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0),
   2351                                         sizeof(cam_capability_t));
   2352 
   2353     int index;
   2354     for (index = 0; index < CAM_ANALYSIS_INFO_MAX; index++) {
   2355         cam_analysis_info_t *p_analysis_info =
   2356                 &gCamCapability[cameraId]->analysis_info[index];
   2357         p_analysis_info->analysis_padding_info.offset_info.offset_x = 0;
   2358         p_analysis_info->analysis_padding_info.offset_info.offset_y = 0;
   2359     }
   2360 
   2361     rc = NO_ERROR;
   2362 
   2363 query_failed:
   2364     cameraHandle->ops->unmap_buf(cameraHandle->camera_handle,
   2365                             CAM_MAPPING_BUF_TYPE_CAPABILITY);
   2366 map_failed:
   2367     capabilityHeap->deallocate();
   2368     delete capabilityHeap;
   2369 allocate_failed:
   2370     return rc;
   2371 }
   2372 
   2373 /*===========================================================================
   2374  * FUNCTION   : getCapabilities
   2375  *
   2376  * DESCRIPTION: query camera capabilities
   2377  *
   2378  * PARAMETERS :
   2379  *   @cameraId  : camera Id
   2380  *   @info      : camera info struct to be filled in with camera capabilities
   2381  *
   2382  * RETURN     : int type of status
   2383  *              NO_ERROR  -- success
   2384  *              none-zero failure code
   2385  *==========================================================================*/
   2386 int QCamera2HardwareInterface::getCapabilities(uint32_t cameraId,
   2387         struct camera_info *info, cam_sync_type_t *p_cam_type)
   2388 {
   2389     ATRACE_CALL();
   2390     int rc = NO_ERROR;
   2391     struct  camera_info *p_info = NULL;
   2392     pthread_mutex_lock(&gCamLock);
   2393     p_info = get_cam_info(cameraId, p_cam_type);
   2394     p_info->device_version = CAMERA_DEVICE_API_VERSION_1_0;
   2395     p_info->static_camera_characteristics = NULL;
   2396     memcpy(info, p_info, sizeof (struct camera_info));
   2397     pthread_mutex_unlock(&gCamLock);
   2398     return rc;
   2399 }
   2400 
   2401 /*===========================================================================
   2402  * FUNCTION   : getCamHalCapabilities
   2403  *
   2404  * DESCRIPTION: get the HAL capabilities structure
   2405  *
   2406  * PARAMETERS :
   2407  *   @cameraId  : camera Id
   2408  *
   2409  * RETURN     : capability structure of respective camera
   2410  *
   2411  *==========================================================================*/
   2412 cam_capability_t* QCamera2HardwareInterface::getCamHalCapabilities()
   2413 {
   2414     return gCamCapability[mCameraId];
   2415 }
   2416 
   2417 /*===========================================================================
   2418  * FUNCTION   : getBufNumRequired
   2419  *
   2420  * DESCRIPTION: return number of stream buffers needed for given stream type
   2421  *
   2422  * PARAMETERS :
   2423  *   @stream_type  : type of stream
   2424  *
   2425  * RETURN     : number of buffers needed
   2426  *==========================================================================*/
   2427 uint8_t QCamera2HardwareInterface::getBufNumRequired(cam_stream_type_t stream_type)
   2428 {
   2429     int bufferCnt = 0;
   2430     int minCaptureBuffers = mParameters.getNumOfSnapshots();
   2431     char value[PROPERTY_VALUE_MAX];
   2432     bool raw_yuv = false;
   2433     int persist_cnt = 0;
   2434 
   2435     int zslQBuffers = mParameters.getZSLQueueDepth();
   2436 
   2437     int minCircularBufNum = mParameters.getMaxUnmatchedFramesInQueue() +
   2438                             CAMERA_MIN_JPEG_ENCODING_BUFFERS;
   2439 
   2440     int maxStreamBuf = minCaptureBuffers + mParameters.getMaxUnmatchedFramesInQueue() +
   2441                        mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2442                        mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2443                        mParameters.getNumOfExtraBuffersForImageProc() +
   2444                        EXTRA_ZSL_PREVIEW_STREAM_BUF;
   2445 
   2446     int minUndequeCount = 0;
   2447     if (!isNoDisplayMode()) {
   2448         if(mPreviewWindow != NULL) {
   2449             if (mPreviewWindow->get_min_undequeued_buffer_count(mPreviewWindow,&minUndequeCount)
   2450                 != 0) {
   2451                 LOGW("get_min_undequeued_buffer_count  failed");
   2452                 //TODO: hardcoded because MIN_UNDEQUEUED_BUFFERS not defined
   2453                 //minUndequeCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS;
   2454                 minUndequeCount = MIN_UNDEQUEUED_BUFFERS;
   2455             }
   2456         } else {
   2457             //preview window might not be set at this point. So, query directly
   2458             //from BufferQueue implementation of gralloc buffers.
   2459             //minUndequeCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS;
   2460             //hardcoded because MIN_UNDEQUEUED_BUFFERS not defined. REVISIT
   2461             minUndequeCount = MIN_UNDEQUEUED_BUFFERS;
   2462         }
   2463         if (minUndequeCount != MIN_UNDEQUEUED_BUFFERS) {
   2464             // minUndequeCount from valid preview window != hardcoded MIN_UNDEQUEUED_BUFFERS
   2465             // and so change the MACRO as per minUndequeCount
   2466             LOGW("WARNING : minUndequeCount(%d) != hardcoded value(%d)",
   2467                      minUndequeCount, MIN_UNDEQUEUED_BUFFERS);
   2468         }
   2469     }
   2470 
   2471     LOGD("minCaptureBuffers = %d zslQBuffers = %d minCircularBufNum = %d"
   2472             "maxStreamBuf = %d minUndequeCount = %d",
   2473             minCaptureBuffers, zslQBuffers, minCircularBufNum,
   2474             maxStreamBuf, minUndequeCount);
   2475     // Get buffer count for the particular stream type
   2476     switch (stream_type) {
   2477     case CAM_STREAM_TYPE_PREVIEW:
   2478         {
   2479             if (mParameters.isZSLMode()) {
   2480                 // We need to add two extra streming buffers to add
   2481                 // flexibility in forming matched super buf in ZSL queue.
   2482                 // with number being 'zslQBuffers + minCircularBufNum'
   2483                 // we see preview buffers sometimes get dropped at CPP
   2484                 // and super buf is not forming in ZSL Q for long time.
   2485 
   2486                 bufferCnt = zslQBuffers + minCircularBufNum +
   2487                         mParameters.getNumOfExtraBuffersForImageProc() +
   2488                         mParameters.getNumOfExtraBuffersForPreview() +
   2489                         mParameters.getNumOfExtraHDRInBufsIfNeeded();
   2490             } else {
   2491                 bufferCnt = CAMERA_MIN_STREAMING_BUFFERS +
   2492                         mParameters.getMaxUnmatchedFramesInQueue() +
   2493                         mParameters.getNumOfExtraBuffersForPreview();
   2494             }
   2495             // ISP allocates native preview buffers and so reducing same from HAL allocation
   2496             if (bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS )
   2497                 bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
   2498 
   2499             if (mParameters.getRecordingHintValue() == true)
   2500                 bufferCnt += EXTRA_ZSL_PREVIEW_STREAM_BUF;
   2501 
   2502             // Add the display minUndequeCount count on top of camera requirement
   2503             bufferCnt += minUndequeCount;
   2504 
   2505             property_get("persist.camera.preview_yuv", value, "0");
   2506             persist_cnt = atoi(value);
   2507             if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
   2508                     && (bufferCnt < persist_cnt)) {
   2509                 bufferCnt = persist_cnt;
   2510             }
   2511         }
   2512         break;
   2513     case CAM_STREAM_TYPE_POSTVIEW:
   2514         {
   2515             bufferCnt = minCaptureBuffers +
   2516                         mParameters.getMaxUnmatchedFramesInQueue() +
   2517                         mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2518                         mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2519                         mParameters.getNumOfExtraBuffersForImageProc();
   2520 
   2521             if (bufferCnt > maxStreamBuf) {
   2522                 bufferCnt = maxStreamBuf;
   2523             }
   2524             bufferCnt += minUndequeCount;
   2525         }
   2526         break;
   2527     case CAM_STREAM_TYPE_SNAPSHOT:
   2528         {
   2529             if (mParameters.isZSLMode() || mLongshotEnabled) {
   2530                 if ((minCaptureBuffers == 1 || mParameters.isUbiRefocus()) &&
   2531                         !mLongshotEnabled) {
   2532                     // Single ZSL snapshot case
   2533                     bufferCnt = zslQBuffers + CAMERA_MIN_STREAMING_BUFFERS +
   2534                             mParameters.getNumOfExtraBuffersForImageProc();
   2535                 }
   2536                 else {
   2537                     // ZSL Burst or Longshot case
   2538                     bufferCnt = zslQBuffers + minCircularBufNum +
   2539                             mParameters.getNumOfExtraBuffersForImageProc();
   2540                 }
   2541                 if (getSensorType() == CAM_SENSOR_YUV && bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS) {
   2542                     //ISP allocates native buffers in YUV case
   2543                     bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
   2544                 }
   2545             } else {
   2546                 bufferCnt = minCaptureBuffers +
   2547                             mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2548                             mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2549                             mParameters.getNumOfExtraBuffersForImageProc();
   2550 
   2551                 if (bufferCnt > maxStreamBuf) {
   2552                     bufferCnt = maxStreamBuf;
   2553                 }
   2554             }
   2555         }
   2556         break;
   2557     case CAM_STREAM_TYPE_RAW:
   2558         property_get("persist.camera.raw_yuv", value, "0");
   2559         raw_yuv = atoi(value) > 0 ? true : false;
   2560 
   2561         if (isRdiMode() || raw_yuv) {
   2562             bufferCnt = zslQBuffers + minCircularBufNum;
   2563         } else if (mParameters.isZSLMode()) {
   2564             bufferCnt = zslQBuffers + minCircularBufNum;
   2565             if (getSensorType() == CAM_SENSOR_YUV && bufferCnt > CAMERA_ISP_PING_PONG_BUFFERS) {
   2566                 //ISP allocates native buffers in YUV case
   2567                 bufferCnt -= CAMERA_ISP_PING_PONG_BUFFERS;
   2568             }
   2569 
   2570         } else {
   2571             bufferCnt = minCaptureBuffers +
   2572                         mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2573                         mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2574                         mParameters.getNumOfExtraBuffersForImageProc();
   2575 
   2576             if (bufferCnt > maxStreamBuf) {
   2577                 bufferCnt = maxStreamBuf;
   2578             }
   2579         }
   2580 
   2581         property_get("persist.camera.preview_raw", value, "0");
   2582         persist_cnt = atoi(value);
   2583         if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
   2584                 && (bufferCnt < persist_cnt)) {
   2585             bufferCnt = persist_cnt;
   2586         }
   2587         property_get("persist.camera.video_raw", value, "0");
   2588         persist_cnt = atoi(value);
   2589         if ((persist_cnt < CAM_MAX_NUM_BUFS_PER_STREAM)
   2590                 && (bufferCnt < persist_cnt)) {
   2591             bufferCnt = persist_cnt;
   2592         }
   2593 
   2594         break;
   2595     case CAM_STREAM_TYPE_VIDEO:
   2596         {
   2597             if (mParameters.getBufBatchCount()) {
   2598                 //Video Buffer in case of HFR or camera batching..
   2599                 bufferCnt = CAMERA_MIN_CAMERA_BATCH_BUFFERS;
   2600             } else if (mParameters.getVideoBatchSize()) {
   2601                 //Video Buffer count only for HAL to HAL batching.
   2602                 bufferCnt = (CAMERA_MIN_VIDEO_BATCH_BUFFERS
   2603                         * mParameters.getVideoBatchSize());
   2604                 if (bufferCnt < CAMERA_MIN_VIDEO_BUFFERS) {
   2605                     bufferCnt = CAMERA_MIN_VIDEO_BUFFERS;
   2606                 }
   2607             } else {
   2608                 // No batching enabled.
   2609                 bufferCnt = CAMERA_MIN_VIDEO_BUFFERS;
   2610             }
   2611 
   2612             bufferCnt += mParameters.getNumOfExtraBuffersForVideo();
   2613             //if its 4K encoding usecase, then add extra buffer
   2614             cam_dimension_t dim;
   2615             mParameters.getStreamDimension(CAM_STREAM_TYPE_VIDEO, dim);
   2616             if (is4k2kResolution(&dim)) {
   2617                  //get additional buffer count
   2618                  property_get("vidc.enc.dcvs.extra-buff-count", value, "0");
   2619                  bufferCnt += atoi(value);
   2620             }
   2621         }
   2622         break;
   2623     case CAM_STREAM_TYPE_METADATA:
   2624         {
   2625             if (mParameters.isZSLMode()) {
   2626                 // MetaData buffers should be >= (Preview buffers-minUndequeCount)
   2627                 bufferCnt = zslQBuffers + minCircularBufNum +
   2628                             mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2629                             mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2630                             mParameters.getNumOfExtraBuffersForImageProc() +
   2631                             EXTRA_ZSL_PREVIEW_STREAM_BUF;
   2632             } else {
   2633                 bufferCnt = minCaptureBuffers +
   2634                             mParameters.getNumOfExtraHDRInBufsIfNeeded() -
   2635                             mParameters.getNumOfExtraHDROutBufsIfNeeded() +
   2636                             mParameters.getMaxUnmatchedFramesInQueue() +
   2637                             CAMERA_MIN_STREAMING_BUFFERS +
   2638                             mParameters.getNumOfExtraBuffersForImageProc();
   2639 
   2640                 if (bufferCnt > zslQBuffers + minCircularBufNum) {
   2641                     bufferCnt = zslQBuffers + minCircularBufNum;
   2642                 }
   2643             }
   2644             if (CAMERA_MIN_METADATA_BUFFERS > bufferCnt) {
   2645                 bufferCnt = CAMERA_MIN_METADATA_BUFFERS;
   2646             }
   2647         }
   2648         break;
   2649     case CAM_STREAM_TYPE_OFFLINE_PROC:
   2650         {
   2651             bufferCnt = minCaptureBuffers;
   2652             // One of the ubifocus buffers is miscellaneous buffer
   2653             if (mParameters.isUbiRefocus()) {
   2654                 bufferCnt -= 1;
   2655             }
   2656             if (mLongshotEnabled) {
   2657                 bufferCnt = mParameters.getLongshotStages();
   2658             }
   2659         }
   2660         break;
   2661     case CAM_STREAM_TYPE_CALLBACK:
   2662         bufferCnt = CAMERA_MIN_CALLBACK_BUFFERS;
   2663         break;
   2664     case CAM_STREAM_TYPE_ANALYSIS:
   2665     case CAM_STREAM_TYPE_DEFAULT:
   2666     case CAM_STREAM_TYPE_MAX:
   2667     default:
   2668         bufferCnt = 0;
   2669         break;
   2670     }
   2671 
   2672     LOGH("Buffer count = %d for stream type = %d", bufferCnt, stream_type);
   2673     if (CAM_MAX_NUM_BUFS_PER_STREAM < bufferCnt) {
   2674         LOGW("Buffer count %d for stream type %d exceeds limit %d",
   2675                  bufferCnt, stream_type, CAM_MAX_NUM_BUFS_PER_STREAM);
   2676         return CAM_MAX_NUM_BUFS_PER_STREAM;
   2677     }
   2678 
   2679     return (uint8_t)bufferCnt;
   2680 }
   2681 
   2682 /*===========================================================================
   2683  * FUNCTION   : allocateStreamBuf
   2684  *
   2685  * DESCRIPTION: alocate stream buffers
   2686  *
   2687  * PARAMETERS :
   2688  *   @stream_type  : type of stream
   2689  *   @size         : size of buffer
   2690  *   @stride       : stride of buffer
   2691  *   @scanline     : scanline of buffer
   2692  *   @bufferCnt    : [IN/OUT] minimum num of buffers to be allocated.
   2693  *                   could be modified during allocation if more buffers needed
   2694  *
   2695  * RETURN     : ptr to a memory obj that holds stream buffers.
   2696  *              NULL if failed
   2697  *==========================================================================*/
   2698 QCameraMemory *QCamera2HardwareInterface::allocateStreamBuf(
   2699         cam_stream_type_t stream_type, size_t size, int stride, int scanline,
   2700         uint8_t &bufferCnt)
   2701 {
   2702     int rc = NO_ERROR;
   2703     QCameraMemory *mem = NULL;
   2704     bool bCachedMem = QCAMERA_ION_USE_CACHE;
   2705     bool bPoolMem = false;
   2706     char value[PROPERTY_VALUE_MAX];
   2707     property_get("persist.camera.mem.usepool", value, "1");
   2708     if (atoi(value) == 1) {
   2709         bPoolMem = true;
   2710     }
   2711 
   2712     // Allocate stream buffer memory object
   2713     switch (stream_type) {
   2714     case CAM_STREAM_TYPE_PREVIEW:
   2715         {
   2716             if (isNoDisplayMode()) {
   2717                 mem = new QCameraStreamMemory(mGetMemory,
   2718                         bCachedMem,
   2719                         (bPoolMem) ? &m_memoryPool : NULL,
   2720                         stream_type);
   2721             } else {
   2722                 cam_dimension_t dim;
   2723                 int minFPS, maxFPS;
   2724                 QCameraGrallocMemory *grallocMemory =
   2725                     new QCameraGrallocMemory(mGetMemory);
   2726 
   2727                 mParameters.getStreamDimension(stream_type, dim);
   2728                 /* we are interested only in maxfps here */
   2729                 mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
   2730                 int usage = 0;
   2731                 if(mParameters.isUBWCEnabled()) {
   2732                     cam_format_t fmt;
   2733                     mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW,fmt);
   2734                     if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
   2735                         usage = GRALLOC_USAGE_PRIVATE_ALLOC_UBWC ;
   2736                     }
   2737                 }
   2738                 if (grallocMemory) {
   2739                     grallocMemory->setMappable(
   2740                             CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS);
   2741                     grallocMemory->setWindowInfo(mPreviewWindow,
   2742                             dim.width,dim.height, stride, scanline,
   2743                             mParameters.getPreviewHalPixelFormat(),
   2744                             maxFPS, usage);
   2745                     pthread_mutex_lock(&mGrallocLock);
   2746                     if (bufferCnt > CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS) {
   2747                         mEnqueuedBuffers = (bufferCnt -
   2748                                 CAMERA_INITIAL_MAPPABLE_PREVIEW_BUFFERS);
   2749                     } else {
   2750                         mEnqueuedBuffers = 0;
   2751                     }
   2752                     pthread_mutex_unlock(&mGrallocLock);
   2753                 }
   2754                 mem = grallocMemory;
   2755             }
   2756         }
   2757         break;
   2758     case CAM_STREAM_TYPE_POSTVIEW:
   2759         {
   2760             if (isNoDisplayMode() || isPreviewRestartEnabled()) {
   2761                 mem = new QCameraStreamMemory(mGetMemory, bCachedMem);
   2762             } else {
   2763                 cam_dimension_t dim;
   2764                 int minFPS, maxFPS;
   2765                 QCameraGrallocMemory *grallocMemory =
   2766                         new QCameraGrallocMemory(mGetMemory);
   2767 
   2768                 mParameters.getStreamDimension(stream_type, dim);
   2769                 /* we are interested only in maxfps here */
   2770                 mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
   2771                 if (grallocMemory) {
   2772                     grallocMemory->setWindowInfo(mPreviewWindow, dim.width,
   2773                             dim.height, stride, scanline,
   2774                             mParameters.getPreviewHalPixelFormat(), maxFPS);
   2775                 }
   2776                 mem = grallocMemory;
   2777             }
   2778         }
   2779         break;
   2780     case CAM_STREAM_TYPE_ANALYSIS:
   2781     case CAM_STREAM_TYPE_SNAPSHOT:
   2782     case CAM_STREAM_TYPE_RAW:
   2783     case CAM_STREAM_TYPE_OFFLINE_PROC:
   2784         mem = new QCameraStreamMemory(mGetMemory,
   2785                 bCachedMem,
   2786                 (bPoolMem) ? &m_memoryPool : NULL,
   2787                 stream_type);
   2788         break;
   2789     case CAM_STREAM_TYPE_METADATA:
   2790         {
   2791             if (mMetadataMem == NULL) {
   2792                 mem = new QCameraMetadataStreamMemory(QCAMERA_ION_USE_CACHE);
   2793             } else {
   2794                 mem = mMetadataMem;
   2795                 mMetadataMem = NULL;
   2796 
   2797                 int32_t numAdditionalBuffers = bufferCnt - mem->getCnt();
   2798                 if (numAdditionalBuffers > 0) {
   2799                     rc = mem->allocateMore(numAdditionalBuffers, size);
   2800                     if (rc != NO_ERROR) {
   2801                         LOGE("Failed to allocate additional buffers, "
   2802                                 "but attempting to proceed.");
   2803                     }
   2804                 }
   2805                 bufferCnt = mem->getCnt();
   2806                 // The memory is already allocated  and initialized, so
   2807                 // simply return here.
   2808                 return mem;
   2809             }
   2810         }
   2811         break;
   2812     case CAM_STREAM_TYPE_VIDEO:
   2813         {
   2814             //Use uncached allocation by default
   2815             if (mParameters.isVideoBuffersCached() || mParameters.isSeeMoreEnabled() ||
   2816                     mParameters.isHighQualityNoiseReductionMode()) {
   2817                 bCachedMem = QCAMERA_ION_USE_CACHE;
   2818             }
   2819             else {
   2820                 bCachedMem = QCAMERA_ION_USE_NOCACHE;
   2821             }
   2822 
   2823             QCameraVideoMemory *videoMemory = NULL;
   2824             if (mParameters.getVideoBatchSize()) {
   2825                 videoMemory = new QCameraVideoMemory(
   2826                         mGetMemory, FALSE, QCAMERA_MEM_TYPE_BATCH);
   2827                 if (videoMemory == NULL) {
   2828                     LOGE("Out of memory for video batching obj");
   2829                     return NULL;
   2830                 }
   2831                 /*
   2832                 *   numFDs = BATCH size
   2833                 *  numInts = 5  // OFFSET, SIZE, USAGE, TIMESTAMP, FORMAT
   2834                 */
   2835                 rc = videoMemory->allocateMeta(
   2836                         CAMERA_MIN_VIDEO_BATCH_BUFFERS,
   2837                         mParameters.getVideoBatchSize(),
   2838                         VIDEO_METADATA_NUM_INTS);
   2839                 if (rc < 0) {
   2840                     delete videoMemory;
   2841                     return NULL;
   2842                 }
   2843             } else {
   2844                 videoMemory =
   2845                         new QCameraVideoMemory(mGetMemory, bCachedMem);
   2846                 if (videoMemory == NULL) {
   2847                     LOGE("Out of memory for video obj");
   2848                     return NULL;
   2849                 }
   2850             }
   2851 
   2852             int usage = 0;
   2853             cam_format_t fmt;
   2854             mParameters.getStreamFormat(CAM_STREAM_TYPE_VIDEO,fmt);
   2855             if (mParameters.isUBWCEnabled() && (fmt == CAM_FORMAT_YUV_420_NV12_UBWC)) {
   2856                 usage = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
   2857             }
   2858             videoMemory->setVideoInfo(usage, fmt);
   2859             mem = videoMemory;
   2860             mVideoMem = videoMemory;
   2861         }
   2862         break;
   2863     case CAM_STREAM_TYPE_CALLBACK:
   2864         mem = new QCameraStreamMemory(mGetMemory,
   2865                 bCachedMem,
   2866                 (bPoolMem) ? &m_memoryPool : NULL,
   2867                 stream_type);
   2868         break;
   2869     case CAM_STREAM_TYPE_DEFAULT:
   2870     case CAM_STREAM_TYPE_MAX:
   2871     default:
   2872         break;
   2873     }
   2874     if (!mem) {
   2875         return NULL;
   2876     }
   2877 
   2878     if (bufferCnt > 0) {
   2879         if (mParameters.isSecureMode() &&
   2880             (stream_type == CAM_STREAM_TYPE_RAW) &&
   2881             (mParameters.isRdiMode())) {
   2882             LOGD("Allocating %d secure buffers of size %d ", bufferCnt, size);
   2883             rc = mem->allocate(bufferCnt, size, SECURE);
   2884         } else {
   2885             rc = mem->allocate(bufferCnt, size, NON_SECURE);
   2886         }
   2887         if (rc < 0) {
   2888             delete mem;
   2889             return NULL;
   2890         }
   2891         bufferCnt = mem->getCnt();
   2892     }
   2893     LOGH("rc = %d type = %d count = %d size = %d cache = %d, pool = %d",
   2894             rc, stream_type, bufferCnt, size, bCachedMem, bPoolMem);
   2895     return mem;
   2896 }
   2897 
   2898 /*===========================================================================
   2899  * FUNCTION   : allocateMoreStreamBuf
   2900  *
   2901  * DESCRIPTION: alocate more stream buffers from the memory object
   2902  *
   2903  * PARAMETERS :
   2904  *   @mem_obj      : memory object ptr
   2905  *   @size         : size of buffer
   2906  *   @bufferCnt    : [IN/OUT] additional number of buffers to be allocated.
   2907  *                   output will be the number of total buffers
   2908  *
   2909  * RETURN     : int32_t type of status
   2910  *              NO_ERROR  -- success
   2911  *              none-zero failure code
   2912  *==========================================================================*/
   2913 int32_t QCamera2HardwareInterface::allocateMoreStreamBuf(
   2914         QCameraMemory *mem_obj, size_t size, uint8_t &bufferCnt)
   2915 {
   2916     int rc = NO_ERROR;
   2917 
   2918     if (bufferCnt > 0) {
   2919         rc = mem_obj->allocateMore(bufferCnt, size);
   2920         bufferCnt = mem_obj->getCnt();
   2921     }
   2922     return rc;
   2923 }
   2924 
   2925 /*===========================================================================
   2926  * FUNCTION   : allocateMiscBuf
   2927  *
   2928  * DESCRIPTION: alocate miscellaneous buffer
   2929  *
   2930  * PARAMETERS :
   2931  *   @streamInfo  : stream info
   2932  *
   2933  * RETURN     : ptr to a memory obj that holds stream info buffer.
   2934  *              NULL if failed
   2935  *==========================================================================*/
   2936 QCameraHeapMemory *QCamera2HardwareInterface::allocateMiscBuf(
   2937         cam_stream_info_t *streamInfo)
   2938 {
   2939     int rc = NO_ERROR;
   2940     uint8_t bufNum = 0;
   2941     size_t bufSize = 0;
   2942     QCameraHeapMemory *miscBuf = NULL;
   2943     cam_feature_mask_t feature_mask =
   2944             streamInfo->reprocess_config.pp_feature_config.feature_mask;
   2945 
   2946     switch (streamInfo->stream_type) {
   2947     case CAM_STREAM_TYPE_OFFLINE_PROC:
   2948         if (CAM_QCOM_FEATURE_TRUEPORTRAIT & feature_mask) {
   2949             bufNum = 1;
   2950             bufSize = mParameters.getTPMaxMetaSize();
   2951         } else if (CAM_QCOM_FEATURE_REFOCUS & feature_mask) {
   2952             bufNum = 1;
   2953             bufSize = mParameters.getRefocusMaxMetaSize();
   2954         }
   2955         break;
   2956     default:
   2957         break;
   2958     }
   2959 
   2960     if (bufNum && bufSize) {
   2961         miscBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
   2962 
   2963         if (!miscBuf) {
   2964             LOGE("Unable to allocate miscBuf object");
   2965             return NULL;
   2966         }
   2967 
   2968         rc = miscBuf->allocate(bufNum, bufSize, NON_SECURE);
   2969         if (rc < 0) {
   2970             LOGE("Failed to allocate misc buffer memory");
   2971             delete miscBuf;
   2972             return NULL;
   2973         }
   2974     }
   2975 
   2976     return miscBuf;
   2977 }
   2978 
   2979 /*===========================================================================
   2980  * FUNCTION   : allocateStreamInfoBuf
   2981  *
   2982  * DESCRIPTION: alocate stream info buffer
   2983  *
   2984  * PARAMETERS :
   2985  *   @stream_type  : type of stream
   2986  *
   2987  * RETURN     : ptr to a memory obj that holds stream info buffer.
   2988  *              NULL if failed
   2989  *==========================================================================*/
   2990 QCameraHeapMemory *QCamera2HardwareInterface::allocateStreamInfoBuf(
   2991         cam_stream_type_t stream_type)
   2992 {
   2993     int rc = NO_ERROR;
   2994     char value[PROPERTY_VALUE_MAX];
   2995     bool raw_yuv = false;
   2996 
   2997     QCameraHeapMemory *streamInfoBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
   2998     if (!streamInfoBuf) {
   2999         LOGE("allocateStreamInfoBuf: Unable to allocate streamInfo object");
   3000         return NULL;
   3001     }
   3002 
   3003     rc = streamInfoBuf->allocate(1, sizeof(cam_stream_info_t), NON_SECURE);
   3004     if (rc < 0) {
   3005         LOGE("allocateStreamInfoBuf: Failed to allocate stream info memory");
   3006         delete streamInfoBuf;
   3007         return NULL;
   3008     }
   3009 
   3010     cam_stream_info_t *streamInfo = (cam_stream_info_t *)streamInfoBuf->getPtr(0);
   3011     memset(streamInfo, 0, sizeof(cam_stream_info_t));
   3012     streamInfo->stream_type = stream_type;
   3013     rc = mParameters.getStreamFormat(stream_type, streamInfo->fmt);
   3014     rc = mParameters.getStreamDimension(stream_type, streamInfo->dim);
   3015     rc = mParameters.getStreamRotation(stream_type, streamInfo->pp_config, streamInfo->dim);
   3016     streamInfo->num_bufs = getBufNumRequired(stream_type);
   3017     streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
   3018     streamInfo->is_secure = NON_SECURE;
   3019 
   3020     switch (stream_type) {
   3021     case CAM_STREAM_TYPE_SNAPSHOT:
   3022         if ((mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) ||
   3023             mLongshotEnabled) {
   3024             streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
   3025         } else {
   3026             streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
   3027             streamInfo->num_of_burst = (uint8_t)
   3028                     (mParameters.getNumOfSnapshots()
   3029                         + mParameters.getNumOfExtraHDRInBufsIfNeeded()
   3030                         - mParameters.getNumOfExtraHDROutBufsIfNeeded()
   3031                         + mParameters.getNumOfExtraBuffersForImageProc());
   3032         }
   3033         break;
   3034     case CAM_STREAM_TYPE_RAW:
   3035         property_get("persist.camera.raw_yuv", value, "0");
   3036         raw_yuv = atoi(value) > 0 ? true : false;
   3037         if ((mParameters.isZSLMode()) || (isRdiMode()) || (raw_yuv)) {
   3038             streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
   3039         } else {
   3040             streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
   3041             streamInfo->num_of_burst = mParameters.getNumOfSnapshots();
   3042         }
   3043         if (mParameters.isSecureMode() && mParameters.isRdiMode()) {
   3044             streamInfo->is_secure = SECURE;
   3045         } else {
   3046             streamInfo->is_secure = NON_SECURE;
   3047         }
   3048         break;
   3049     case CAM_STREAM_TYPE_POSTVIEW:
   3050         if (mLongshotEnabled) {
   3051             streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
   3052         } else {
   3053             streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
   3054             streamInfo->num_of_burst = (uint8_t)(mParameters.getNumOfSnapshots()
   3055                 + mParameters.getNumOfExtraHDRInBufsIfNeeded()
   3056                 - mParameters.getNumOfExtraHDROutBufsIfNeeded()
   3057                 + mParameters.getNumOfExtraBuffersForImageProc());
   3058         }
   3059         break;
   3060     case CAM_STREAM_TYPE_VIDEO:
   3061         streamInfo->dis_enable = mParameters.isDISEnabled();
   3062         if (mParameters.getBufBatchCount()) {
   3063             //Update stream info structure with batch mode info
   3064             streamInfo->streaming_mode = CAM_STREAMING_MODE_BATCH;
   3065             streamInfo->user_buf_info.frame_buf_cnt = mParameters.getBufBatchCount();
   3066             streamInfo->user_buf_info.size =
   3067                     (uint32_t)(sizeof(struct msm_camera_user_buf_cont_t));
   3068             cam_fps_range_t pFpsRange;
   3069             mParameters.getHfrFps(pFpsRange);
   3070             streamInfo->user_buf_info.frameInterval =
   3071                     (long)((1000/pFpsRange.video_max_fps) * 1000);
   3072             LOGH("Video Batch Count = %d, interval = %d",
   3073                     streamInfo->user_buf_info.frame_buf_cnt,
   3074                     streamInfo->user_buf_info.frameInterval);
   3075         }
   3076     case CAM_STREAM_TYPE_PREVIEW:
   3077         if (mParameters.getRecordingHintValue()) {
   3078             if(mParameters.isDISEnabled()) {
   3079                 streamInfo->is_type = mParameters.getISType();
   3080             } else {
   3081                 streamInfo->is_type = IS_TYPE_NONE;
   3082             }
   3083         }
   3084         if (mParameters.isSecureMode()) {
   3085             streamInfo->is_secure = SECURE;
   3086         }
   3087         break;
   3088     case CAM_STREAM_TYPE_ANALYSIS:
   3089         streamInfo->noFrameExpected = 1;
   3090         break;
   3091     default:
   3092         break;
   3093     }
   3094 
   3095     // Update feature mask
   3096     mParameters.updatePpFeatureMask(stream_type);
   3097 
   3098     // Get feature mask
   3099     mParameters.getStreamPpMask(stream_type, streamInfo->pp_config.feature_mask);
   3100 
   3101     // Update pp config
   3102     if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_FLIP) {
   3103         int flipMode = mParameters.getFlipMode(stream_type);
   3104         if (flipMode > 0) {
   3105             streamInfo->pp_config.flip = (uint32_t)flipMode;
   3106         }
   3107     }
   3108     if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_SHARPNESS) {
   3109         streamInfo->pp_config.sharpness = mParameters.getSharpness();
   3110     }
   3111     if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_EFFECT) {
   3112         streamInfo->pp_config.effect = mParameters.getEffectValue();
   3113     }
   3114 
   3115     if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_DENOISE2D) {
   3116         streamInfo->pp_config.denoise2d.denoise_enable = 1;
   3117         streamInfo->pp_config.denoise2d.process_plates =
   3118                 mParameters.getDenoiseProcessPlate(CAM_INTF_PARM_WAVELET_DENOISE);
   3119     }
   3120 
   3121     if (!((needReprocess()) && (CAM_STREAM_TYPE_SNAPSHOT == stream_type ||
   3122             CAM_STREAM_TYPE_RAW == stream_type))) {
   3123         if (gCamCapability[mCameraId]->qcom_supported_feature_mask &
   3124                 CAM_QCOM_FEATURE_CROP)
   3125             streamInfo->pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
   3126         if (gCamCapability[mCameraId]->qcom_supported_feature_mask &
   3127                 CAM_QCOM_FEATURE_SCALE)
   3128             streamInfo->pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
   3129     }
   3130 
   3131     LOGH("type %d, fmt %d, dim %dx%d, num_bufs %d mask = 0x%x\n",
   3132            stream_type, streamInfo->fmt, streamInfo->dim.width,
   3133            streamInfo->dim.height, streamInfo->num_bufs,
   3134            streamInfo->pp_config.feature_mask);
   3135 
   3136     return streamInfoBuf;
   3137 }
   3138 
   3139 /*===========================================================================
   3140  * FUNCTION   : allocateStreamUserBuf
   3141  *
   3142  * DESCRIPTION: allocate user ptr for stream buffers
   3143  *
   3144  * PARAMETERS :
   3145  *   @streamInfo  : stream info structure
   3146  *
   3147  * RETURN     : ptr to a memory obj that holds stream info buffer.
   3148  *                    NULL if failed
   3149 
   3150  *==========================================================================*/
   3151 QCameraMemory *QCamera2HardwareInterface::allocateStreamUserBuf(
   3152         cam_stream_info_t *streamInfo)
   3153 {
   3154     int rc = NO_ERROR;
   3155     QCameraMemory *mem = NULL;
   3156     int size = 0;
   3157 
   3158     if (streamInfo->streaming_mode != CAM_STREAMING_MODE_BATCH) {
   3159         LOGE("Stream is not in BATCH mode. Invalid Stream");
   3160         return NULL;
   3161     }
   3162 
   3163     // Allocate stream user buffer memory object
   3164     switch (streamInfo->stream_type) {
   3165     case CAM_STREAM_TYPE_VIDEO: {
   3166         QCameraVideoMemory *video_mem = new QCameraVideoMemory(
   3167                 mGetMemory, FALSE, QCAMERA_MEM_TYPE_BATCH);
   3168         if (video_mem == NULL) {
   3169             LOGE("Out of memory for video obj");
   3170             return NULL;
   3171         }
   3172         /*
   3173         *   numFDs = BATCH size
   3174         *  numInts = 5  // OFFSET, SIZE, USAGE, TIMESTAMP, FORMAT
   3175         */
   3176         rc = video_mem->allocateMeta(streamInfo->num_bufs,
   3177                 mParameters.getBufBatchCount(), VIDEO_METADATA_NUM_INTS);
   3178         if (rc < 0) {
   3179             LOGE("allocateMeta failed");
   3180             delete video_mem;
   3181             return NULL;
   3182         }
   3183         int usage = 0;
   3184         cam_format_t fmt;
   3185         mParameters.getStreamFormat(CAM_STREAM_TYPE_VIDEO, fmt);
   3186         if(mParameters.isUBWCEnabled() && (fmt == CAM_FORMAT_YUV_420_NV12_UBWC)) {
   3187             usage = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
   3188         }
   3189         video_mem->setVideoInfo(usage, fmt);
   3190         mem = static_cast<QCameraMemory *>(video_mem);
   3191         mVideoMem = video_mem;
   3192     }
   3193     break;
   3194 
   3195     case CAM_STREAM_TYPE_PREVIEW:
   3196     case CAM_STREAM_TYPE_POSTVIEW:
   3197     case CAM_STREAM_TYPE_ANALYSIS:
   3198     case CAM_STREAM_TYPE_SNAPSHOT:
   3199     case CAM_STREAM_TYPE_RAW:
   3200     case CAM_STREAM_TYPE_METADATA:
   3201     case CAM_STREAM_TYPE_OFFLINE_PROC:
   3202     case CAM_STREAM_TYPE_CALLBACK:
   3203         LOGE("Stream type Not supported.for BATCH processing");
   3204     break;
   3205 
   3206     case CAM_STREAM_TYPE_DEFAULT:
   3207     case CAM_STREAM_TYPE_MAX:
   3208     default:
   3209         break;
   3210     }
   3211     if (!mem) {
   3212         LOGE("Failed to allocate mem");
   3213         return NULL;
   3214     }
   3215 
   3216     /*Size of this buffer will be number of batch buffer */
   3217     size = PAD_TO_SIZE((streamInfo->num_bufs * streamInfo->user_buf_info.size),
   3218             CAM_PAD_TO_4K);
   3219 
   3220     LOGH("Allocating BATCH Buffer count = %d", streamInfo->num_bufs);
   3221 
   3222     if (size > 0) {
   3223         // Allocating one buffer for all batch buffers
   3224         rc = mem->allocate(1, size, NON_SECURE);
   3225         if (rc < 0) {
   3226             delete mem;
   3227             return NULL;
   3228         }
   3229     }
   3230     return mem;
   3231 }
   3232 
   3233 
   3234 /*===========================================================================
   3235  * FUNCTION   : waitForDeferredAlloc
   3236  *
   3237  * DESCRIPTION: Wait for deferred allocation, if applicable
   3238  *              (applicable only for metadata buffers so far)
   3239  *
   3240  * PARAMETERS :
   3241  *   @stream_type  : type of stream to (possibly) wait for
   3242  *
   3243  * RETURN     : None
   3244  *==========================================================================*/
   3245 void QCamera2HardwareInterface::waitForDeferredAlloc(cam_stream_type_t stream_type)
   3246 {
   3247     if (stream_type == CAM_STREAM_TYPE_METADATA) {
   3248         waitDeferredWork(mMetadataAllocJob);
   3249     }
   3250 }
   3251 
   3252 
   3253 /*===========================================================================
   3254  * FUNCTION   : setPreviewWindow
   3255  *
   3256  * DESCRIPTION: set preview window impl
   3257  *
   3258  * PARAMETERS :
   3259  *   @window  : ptr to window ops table struct
   3260  *
   3261  * RETURN     : int32_t type of status
   3262  *              NO_ERROR  -- success
   3263  *              none-zero failure code
   3264  *==========================================================================*/
   3265 int QCamera2HardwareInterface::setPreviewWindow(
   3266         struct preview_stream_ops *window)
   3267 {
   3268     mPreviewWindow = window;
   3269     return NO_ERROR;
   3270 }
   3271 
   3272 /*===========================================================================
   3273  * FUNCTION   : setCallBacks
   3274  *
   3275  * DESCRIPTION: set callbacks impl
   3276  *
   3277  * PARAMETERS :
   3278  *   @notify_cb  : notify cb
   3279  *   @data_cb    : data cb
   3280  *   @data_cb_timestamp : data cb with time stamp
   3281  *   @get_memory : request memory ops table
   3282  *   @user       : user data ptr
   3283  *
   3284  * RETURN     : int32_t type of status
   3285  *              NO_ERROR  -- success
   3286  *              none-zero failure code
   3287  *==========================================================================*/
   3288 int QCamera2HardwareInterface::setCallBacks(camera_notify_callback notify_cb,
   3289                                             camera_data_callback data_cb,
   3290                                             camera_data_timestamp_callback data_cb_timestamp,
   3291                                             camera_request_memory get_memory,
   3292                                             void *user)
   3293 {
   3294     mNotifyCb        = notify_cb;
   3295     mDataCb          = data_cb;
   3296     mDataCbTimestamp = data_cb_timestamp;
   3297     mGetMemory       = get_memory;
   3298     mCallbackCookie  = user;
   3299     m_cbNotifier.setCallbacks(notify_cb, data_cb, data_cb_timestamp, user);
   3300     return NO_ERROR;
   3301 }
   3302 
   3303 /*===========================================================================
   3304  * FUNCTION   : setJpegCallBacks
   3305  *
   3306  * DESCRIPTION: set JPEG callbacks impl
   3307  *
   3308  * PARAMETERS :
   3309  *   @jpegCb  : Jpeg callback method
   3310  *   @callbackCookie    : callback cookie
   3311  *
   3312  * RETURN     : int32_t type of status
   3313  *              NO_ERROR  -- success
   3314  *              none-zero failure code
   3315  *==========================================================================*/
   3316 void QCamera2HardwareInterface::setJpegCallBacks(jpeg_data_callback jpegCb,
   3317                                             void *callbackCookie)
   3318 {
   3319     LOGH("camera id %d", getCameraId());
   3320     mJpegCb        = jpegCb;
   3321     mJpegCallbackCookie  = callbackCookie;
   3322     m_cbNotifier.setJpegCallBacks(mJpegCb, mJpegCallbackCookie);
   3323 }
   3324 
   3325 /*===========================================================================
   3326  * FUNCTION   : enableMsgType
   3327  *
   3328  * DESCRIPTION: enable msg type impl
   3329  *
   3330  * PARAMETERS :
   3331  *   @msg_type  : msg type mask to be enabled
   3332  *
   3333  * RETURN     : int32_t type of status
   3334  *              NO_ERROR  -- success
   3335  *              none-zero failure code
   3336  *==========================================================================*/
   3337 int QCamera2HardwareInterface::enableMsgType(int32_t msg_type)
   3338 {
   3339     int32_t rc = NO_ERROR;
   3340 
   3341     if (mParameters.isUBWCEnabled()) {
   3342         /*Need Special CALLBACK stream incase application requesting for
   3343               Preview callback  in UBWC case*/
   3344         if (!(msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) &&
   3345                 (msg_type & CAMERA_MSG_PREVIEW_FRAME)) {
   3346             // Start callback channel only when preview/zsl channel is active
   3347             QCameraChannel* previewCh = NULL;
   3348             if (isZSLMode() && (getRecordingHintValue() != true)) {
   3349                 previewCh = m_channels[QCAMERA_CH_TYPE_ZSL];
   3350             } else {
   3351                 previewCh = m_channels[QCAMERA_CH_TYPE_PREVIEW];
   3352             }
   3353             QCameraChannel* callbackCh = m_channels[QCAMERA_CH_TYPE_CALLBACK];
   3354             if ((callbackCh != NULL) &&
   3355                     (previewCh != NULL) && previewCh->isActive()) {
   3356                 rc = startChannel(QCAMERA_CH_TYPE_CALLBACK);
   3357                 if (rc != NO_ERROR) {
   3358                     LOGE("START Callback Channel failed");
   3359                 }
   3360             }
   3361         }
   3362     }
   3363     mMsgEnabled |= msg_type;
   3364     LOGH("(0x%x) : mMsgEnabled = 0x%x rc = %d", msg_type , mMsgEnabled, rc);
   3365     return rc;
   3366 }
   3367 
   3368 /*===========================================================================
   3369  * FUNCTION   : disableMsgType
   3370  *
   3371  * DESCRIPTION: disable msg type impl
   3372  *
   3373  * PARAMETERS :
   3374  *   @msg_type  : msg type mask to be disabled
   3375  *
   3376  * RETURN     : int32_t type of status
   3377  *              NO_ERROR  -- success
   3378  *              none-zero failure code
   3379  *==========================================================================*/
   3380 int QCamera2HardwareInterface::disableMsgType(int32_t msg_type)
   3381 {
   3382     int32_t rc = NO_ERROR;
   3383 
   3384     if (mParameters.isUBWCEnabled()) {
   3385         /*STOP CALLBACK STREAM*/
   3386         if ((msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) &&
   3387                 (msg_type & CAMERA_MSG_PREVIEW_FRAME)) {
   3388             // Stop callback channel only if it is active
   3389             if ((m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL) &&
   3390                    (m_channels[QCAMERA_CH_TYPE_CALLBACK]->isActive())) {
   3391                 rc = stopChannel(QCAMERA_CH_TYPE_CALLBACK);
   3392                 if (rc != NO_ERROR) {
   3393                     LOGE("STOP Callback Channel failed");
   3394                 }
   3395             }
   3396         }
   3397     }
   3398     mMsgEnabled &= ~msg_type;
   3399     LOGH("(0x%x) : mMsgEnabled = 0x%x rc = %d", msg_type , mMsgEnabled, rc);
   3400     return rc;
   3401 }
   3402 
   3403 /*===========================================================================
   3404  * FUNCTION   : msgTypeEnabled
   3405  *
   3406  * DESCRIPTION: impl to determine if certain msg_type is enabled
   3407  *
   3408  * PARAMETERS :
   3409  *   @msg_type  : msg type mask
   3410  *
   3411  * RETURN     : 0 -- not enabled
   3412  *              none 0 -- enabled
   3413  *==========================================================================*/
   3414 int QCamera2HardwareInterface::msgTypeEnabled(int32_t msg_type)
   3415 {
   3416     return (mMsgEnabled & msg_type);
   3417 }
   3418 
   3419 /*===========================================================================
   3420  * FUNCTION   : msgTypeEnabledWithLock
   3421  *
   3422  * DESCRIPTION: impl to determine if certain msg_type is enabled with lock
   3423  *
   3424  * PARAMETERS :
   3425  *   @msg_type  : msg type mask
   3426  *
   3427  * RETURN     : 0 -- not enabled
   3428  *              none 0 -- enabled
   3429  *==========================================================================*/
   3430 int QCamera2HardwareInterface::msgTypeEnabledWithLock(int32_t msg_type)
   3431 {
   3432     int enabled = 0;
   3433     lockAPI();
   3434     enabled = mMsgEnabled & msg_type;
   3435     unlockAPI();
   3436     return enabled;
   3437 }
   3438 
   3439 /*===========================================================================
   3440  * FUNCTION   : startPreview
   3441  *
   3442  * DESCRIPTION: start preview impl
   3443  *
   3444  * PARAMETERS : none
   3445  *
   3446  * RETURN     : int32_t type of status
   3447  *              NO_ERROR  -- success
   3448  *              none-zero failure code
   3449  *==========================================================================*/
   3450 int QCamera2HardwareInterface::startPreview()
   3451 {
   3452     KPI_ATRACE_CALL();
   3453     int32_t rc = NO_ERROR;
   3454 
   3455     LOGI("E ZSL = %d Recording Hint = %d", mParameters.isZSLMode(),
   3456             mParameters.getRecordingHintValue());
   3457 
   3458     m_perfLock.lock_acq();
   3459 
   3460     updateThermalLevel((void *)&mThermalLevel);
   3461 
   3462     setDisplayFrameSkip();
   3463 
   3464     // start preview stream
   3465     if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) {
   3466         rc = startChannel(QCAMERA_CH_TYPE_ZSL);
   3467     } else {
   3468         rc = startChannel(QCAMERA_CH_TYPE_PREVIEW);
   3469     }
   3470 
   3471     if (rc != NO_ERROR) {
   3472         LOGE("failed to start channels");
   3473         m_perfLock.lock_rel();
   3474         return rc;
   3475     }
   3476 
   3477     if ((msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME))
   3478             && (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL)) {
   3479         rc = startChannel(QCAMERA_CH_TYPE_CALLBACK);
   3480         if (rc != NO_ERROR) {
   3481             LOGE("failed to start callback stream");
   3482             stopChannel(QCAMERA_CH_TYPE_ZSL);
   3483             stopChannel(QCAMERA_CH_TYPE_PREVIEW);
   3484             m_perfLock.lock_rel();
   3485             return rc;
   3486         }
   3487     }
   3488 
   3489     updatePostPreviewParameters();
   3490     m_stateMachine.setPreviewCallbackNeeded(true);
   3491 
   3492     // if job id is non-zero, that means the postproc init job is already
   3493     // pending or complete
   3494     if (mInitPProcJob == 0) {
   3495         mInitPProcJob = deferPPInit();
   3496         if (mInitPProcJob == 0) {
   3497             LOGE("Unable to initialize postprocessor, mCameraHandle = %p",
   3498                      mCameraHandle);
   3499             rc = -ENOMEM;
   3500             m_perfLock.lock_rel();
   3501             return rc;
   3502         }
   3503     }
   3504     m_perfLock.lock_rel();
   3505 
   3506     if (rc == NO_ERROR) {
   3507         if (!mParameters.isSeeMoreEnabled()) {
   3508             // Set power Hint for preview
   3509             m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, true);
   3510         }
   3511     }
   3512 
   3513     LOGI("X rc = %d", rc);
   3514     return rc;
   3515 }
   3516 
   3517 int32_t QCamera2HardwareInterface::updatePostPreviewParameters() {
   3518     // Enable OIS only in Camera mode and 4k2k camcoder mode
   3519     int32_t rc = NO_ERROR;
   3520     rc = mParameters.updateOisValue(1);
   3521     return NO_ERROR;
   3522 }
   3523 
   3524 /*===========================================================================
   3525  * FUNCTION   : stopPreview
   3526  *
   3527  * DESCRIPTION: stop preview impl
   3528  *
   3529  * PARAMETERS : none
   3530  *
   3531  * RETURN     : int32_t type of status
   3532  *              NO_ERROR  -- success
   3533  *              none-zero failure code
   3534  *==========================================================================*/
   3535 int QCamera2HardwareInterface::stopPreview()
   3536 {
   3537     KPI_ATRACE_CALL();
   3538     LOGI("E");
   3539     mNumPreviewFaces = -1;
   3540     mActiveAF = false;
   3541 
   3542     // Disable power Hint for preview
   3543     m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, false);
   3544 
   3545     m_perfLock.lock_acq();
   3546 
   3547     // stop preview stream
   3548     stopChannel(QCAMERA_CH_TYPE_CALLBACK);
   3549     stopChannel(QCAMERA_CH_TYPE_ZSL);
   3550     stopChannel(QCAMERA_CH_TYPE_PREVIEW);
   3551     stopChannel(QCAMERA_CH_TYPE_RAW);
   3552 
   3553     m_cbNotifier.flushPreviewNotifications();
   3554     //add for ts makeup
   3555 #ifdef TARGET_TS_MAKEUP
   3556     ts_makeup_finish();
   3557 #endif
   3558     // delete all channels from preparePreview
   3559     unpreparePreview();
   3560 
   3561     m_perfLock.lock_rel();
   3562 
   3563     LOGI("X");
   3564     return NO_ERROR;
   3565 }
   3566 
   3567 /*===========================================================================
   3568  * FUNCTION   : storeMetaDataInBuffers
   3569  *
   3570  * DESCRIPTION: enable store meta data in buffers for video frames impl
   3571  *
   3572  * PARAMETERS :
   3573  *   @enable  : flag if need enable
   3574  *
   3575  * RETURN     : int32_t type of status
   3576  *              NO_ERROR  -- success
   3577  *              none-zero failure code
   3578  *==========================================================================*/
   3579 int QCamera2HardwareInterface::storeMetaDataInBuffers(int enable)
   3580 {
   3581     mStoreMetaDataInFrame = enable;
   3582     return NO_ERROR;
   3583 }
   3584 
   3585 /*===========================================================================
   3586  * FUNCTION   : preStartRecording
   3587  *
   3588  * DESCRIPTION: Prepare start recording impl
   3589  *
   3590  * PARAMETERS : none
   3591  *
   3592  * RETURN     : int32_t type of status
   3593  *              NO_ERROR  -- success
   3594  *              none-zero failure code
   3595  *==========================================================================*/
   3596 int QCamera2HardwareInterface::preStartRecording()
   3597 {
   3598     int32_t rc = NO_ERROR;
   3599     LOGH("E");
   3600     if (mParameters.getRecordingHintValue() == false) {
   3601 
   3602         // Give HWI control to restart preview only in single camera mode.
   3603         // In dual-cam mode, this control belongs to muxer.
   3604         if (getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
   3605             LOGH("start recording when hint is false, stop preview first");
   3606             stopPreview();
   3607 
   3608             // Set recording hint to TRUE
   3609             mParameters.updateRecordingHintValue(TRUE);
   3610             rc = preparePreview();
   3611             if (rc == NO_ERROR) {
   3612                 rc = startPreview();
   3613             }
   3614         }
   3615         else
   3616         {
   3617             // For dual cam mode, update the flag mPreviewRestartNeeded to true
   3618             // Restart control will be handled by muxer.
   3619             mPreviewRestartNeeded = true;
   3620         }
   3621     }
   3622 
   3623     LOGH("X rc = %d", rc);
   3624     return rc;
   3625 }
   3626 
   3627 /*===========================================================================
   3628  * FUNCTION   : startRecording
   3629  *
   3630  * DESCRIPTION: start recording impl
   3631  *
   3632  * PARAMETERS : none
   3633  *
   3634  * RETURN     : int32_t type of status
   3635  *              NO_ERROR  -- success
   3636  *              none-zero failure code
   3637  *==========================================================================*/
   3638 int QCamera2HardwareInterface::startRecording()
   3639 {
   3640     int32_t rc = NO_ERROR;
   3641 
   3642     LOGI("E");
   3643     mVideoMem = NULL;
   3644     //link meta stream with video channel if low power mode.
   3645     if (isLowPowerMode()) {
   3646         // Find and try to link a metadata stream from preview channel
   3647         QCameraChannel *pMetaChannel = NULL;
   3648         QCameraStream *pMetaStream = NULL;
   3649         QCameraChannel *pVideoChannel = m_channels[QCAMERA_CH_TYPE_VIDEO];
   3650 
   3651         if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
   3652             pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
   3653             uint32_t streamNum = pMetaChannel->getNumOfStreams();
   3654             QCameraStream *pStream = NULL;
   3655             for (uint32_t i = 0 ; i < streamNum ; i++ ) {
   3656                 pStream = pMetaChannel->getStreamByIndex(i);
   3657                 if ((NULL != pStream) &&
   3658                         (CAM_STREAM_TYPE_METADATA == pStream->getMyType())) {
   3659                     pMetaStream = pStream;
   3660                     break;
   3661                 }
   3662             }
   3663         }
   3664 
   3665         if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
   3666             rc = pVideoChannel->linkStream(pMetaChannel, pMetaStream);
   3667             if (NO_ERROR != rc) {
   3668                 LOGW("Metadata stream link failed %d", rc);
   3669             }
   3670         }
   3671     }
   3672 
   3673     if (rc == NO_ERROR) {
   3674         rc = startChannel(QCAMERA_CH_TYPE_VIDEO);
   3675     }
   3676 
   3677     if (mParameters.isTNRSnapshotEnabled() && !isLowPowerMode()) {
   3678         QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
   3679         if (!mParameters.is4k2kVideoResolution()) {
   3680             // Find and try to link a metadata stream from preview channel
   3681             QCameraChannel *pMetaChannel = NULL;
   3682             QCameraStream *pMetaStream = NULL;
   3683 
   3684             if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
   3685                 pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
   3686                 uint32_t streamNum = pMetaChannel->getNumOfStreams();
   3687                 QCameraStream *pStream = NULL;
   3688                 for (uint32_t i = 0 ; i < streamNum ; i++ ) {
   3689                     pStream = pMetaChannel->getStreamByIndex(i);
   3690                     if ((NULL != pStream) &&
   3691                             (CAM_STREAM_TYPE_METADATA ==
   3692                             pStream->getMyType())) {
   3693                         pMetaStream = pStream;
   3694                         break;
   3695                     }
   3696                 }
   3697             }
   3698 
   3699             if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
   3700                 rc = pChannel->linkStream(pMetaChannel, pMetaStream);
   3701                 if (NO_ERROR != rc) {
   3702                     LOGW("Metadata stream link failed %d", rc);
   3703                 }
   3704             }
   3705         }
   3706         LOGH("START snapshot Channel for TNR processing");
   3707         rc = pChannel->start();
   3708     }
   3709 
   3710     if (rc == NO_ERROR) {
   3711         if (!mParameters.isSeeMoreEnabled()) {
   3712             // Set power Hint for video encoding
   3713             m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, true);
   3714         }
   3715     }
   3716 
   3717     LOGI("X rc = %d", rc);
   3718     return rc;
   3719 }
   3720 
   3721 /*===========================================================================
   3722  * FUNCTION   : stopRecording
   3723  *
   3724  * DESCRIPTION: stop recording impl
   3725  *
   3726  * PARAMETERS : none
   3727  *
   3728  * RETURN     : int32_t type of status
   3729  *              NO_ERROR  -- success
   3730  *              none-zero failure code
   3731  *==========================================================================*/
   3732 int QCamera2HardwareInterface::stopRecording()
   3733 {
   3734     LOGI("E");
   3735     // stop snapshot channel
   3736     if (mParameters.isTNRSnapshotEnabled()) {
   3737         LOGH("STOP snapshot Channel for TNR processing");
   3738         stopChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   3739     }
   3740     int rc = stopChannel(QCAMERA_CH_TYPE_VIDEO);
   3741 
   3742     m_cbNotifier.flushVideoNotifications();
   3743     // Disable power hint for video encoding
   3744     m_perfLock.powerHint(POWER_HINT_VIDEO_ENCODE, false);
   3745     mVideoMem = NULL;
   3746     LOGI("X rc = %d", rc);
   3747     return rc;
   3748 }
   3749 
   3750 /*===========================================================================
   3751  * FUNCTION   : releaseRecordingFrame
   3752  *
   3753  * DESCRIPTION: return video frame impl
   3754  *
   3755  * PARAMETERS :
   3756  *   @opaque  : ptr to video frame to be returned
   3757  *
   3758  * RETURN     : int32_t type of status
   3759  *              NO_ERROR  -- success
   3760  *              none-zero failure code
   3761  *==========================================================================*/
   3762 int QCamera2HardwareInterface::releaseRecordingFrame(const void * opaque)
   3763 {
   3764     int32_t rc = UNKNOWN_ERROR;
   3765     QCameraVideoChannel *pChannel =
   3766             (QCameraVideoChannel *)m_channels[QCAMERA_CH_TYPE_VIDEO];
   3767     LOGD("opaque data = %p",opaque);
   3768 
   3769     if(pChannel != NULL) {
   3770         rc = pChannel->releaseFrame(opaque, mStoreMetaDataInFrame > 0);
   3771     }
   3772     return rc;
   3773 }
   3774 
   3775 /*===========================================================================
   3776  * FUNCTION   : autoFocus
   3777  *
   3778  * DESCRIPTION: start auto focus impl
   3779  *
   3780  * PARAMETERS : none
   3781  *
   3782  * RETURN     : int32_t type of status
   3783  *              NO_ERROR  -- success
   3784  *              none-zero failure code
   3785  *==========================================================================*/
   3786 int QCamera2HardwareInterface::autoFocus()
   3787 {
   3788     int rc = NO_ERROR;
   3789     cam_focus_mode_type focusMode = mParameters.getFocusMode();
   3790     LOGH("E");
   3791 
   3792     switch (focusMode) {
   3793     case CAM_FOCUS_MODE_AUTO:
   3794     case CAM_FOCUS_MODE_MACRO:
   3795     case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
   3796     case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
   3797         mActiveAF = true;
   3798         LOGI("Send AUTO FOCUS event. focusMode=%d, m_currentFocusState=%d",
   3799                 focusMode, m_currentFocusState);
   3800         rc = mCameraHandle->ops->do_auto_focus(mCameraHandle->camera_handle);
   3801         break;
   3802     case CAM_FOCUS_MODE_INFINITY:
   3803     case CAM_FOCUS_MODE_FIXED:
   3804     case CAM_FOCUS_MODE_EDOF:
   3805     default:
   3806         LOGI("No ops in focusMode (%d)", focusMode);
   3807         rc = sendEvtNotify(CAMERA_MSG_FOCUS, true, 0);
   3808         break;
   3809     }
   3810 
   3811     if (NO_ERROR != rc) {
   3812         mActiveAF = false;
   3813     }
   3814     LOGH("X rc = %d", rc);
   3815     return rc;
   3816 }
   3817 
   3818 /*===========================================================================
   3819  * FUNCTION   : cancelAutoFocus
   3820  *
   3821  * DESCRIPTION: cancel auto focus impl
   3822  *
   3823  * PARAMETERS : none
   3824  *
   3825  * RETURN     : int32_t type of status
   3826  *              NO_ERROR  -- success
   3827  *              none-zero failure code
   3828  *==========================================================================*/
   3829 int QCamera2HardwareInterface::cancelAutoFocus()
   3830 {
   3831     int rc = NO_ERROR;
   3832     cam_focus_mode_type focusMode = mParameters.getFocusMode();
   3833 
   3834     switch (focusMode) {
   3835     case CAM_FOCUS_MODE_AUTO:
   3836     case CAM_FOCUS_MODE_MACRO:
   3837     case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
   3838     case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
   3839         mActiveAF = false;
   3840         rc = mCameraHandle->ops->cancel_auto_focus(mCameraHandle->camera_handle);
   3841         break;
   3842     case CAM_FOCUS_MODE_INFINITY:
   3843     case CAM_FOCUS_MODE_FIXED:
   3844     case CAM_FOCUS_MODE_EDOF:
   3845     default:
   3846         LOGD("No ops in focusMode (%d)", focusMode);
   3847         break;
   3848     }
   3849     return rc;
   3850 }
   3851 
   3852 /*===========================================================================
   3853  * FUNCTION   : processUFDumps
   3854  *
   3855  * DESCRIPTION: process UF jpeg dumps for refocus support
   3856  *
   3857  * PARAMETERS :
   3858  *   @evt     : payload of jpeg event, including information about jpeg encoding
   3859  *              status, jpeg size and so on.
   3860  *
   3861  * RETURN     : int32_t type of status
   3862  *              NO_ERROR  -- success
   3863  *              none-zero failure code
   3864  *
   3865  * NOTE       : none
   3866  *==========================================================================*/
   3867 bool QCamera2HardwareInterface::processUFDumps(qcamera_jpeg_evt_payload_t *evt)
   3868 {
   3869    bool ret = true;
   3870    if (mParameters.isUbiRefocus()) {
   3871        int index = (int)getOutputImageCount();
   3872        bool allFocusImage = (index == ((int)mParameters.getRefocusOutputCount() - 1));
   3873        char name[FILENAME_MAX];
   3874 
   3875        camera_memory_t *jpeg_mem = NULL;
   3876        omx_jpeg_ouput_buf_t *jpeg_out = NULL;
   3877        size_t dataLen;
   3878        uint8_t *dataPtr;
   3879        if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
   3880            LOGE("Init PProc Deferred work failed");
   3881            return false;
   3882        }
   3883        if (!m_postprocessor.getJpegMemOpt()) {
   3884            dataLen = evt->out_data.buf_filled_len;
   3885            dataPtr = evt->out_data.buf_vaddr;
   3886        } else {
   3887            jpeg_out  = (omx_jpeg_ouput_buf_t*) evt->out_data.buf_vaddr;
   3888            if (!jpeg_out) {
   3889               LOGE("Null pointer detected");
   3890               return false;
   3891            }
   3892            jpeg_mem = (camera_memory_t *)jpeg_out->mem_hdl;
   3893            if (!jpeg_mem) {
   3894               LOGE("Null pointer detected");
   3895               return false;
   3896            }
   3897            dataPtr = (uint8_t *)jpeg_mem->data;
   3898            dataLen = jpeg_mem->size;
   3899        }
   3900 
   3901        if (allFocusImage)  {
   3902            snprintf(name, sizeof(name), "AllFocusImage");
   3903            index = -1;
   3904        } else {
   3905            snprintf(name, sizeof(name), "%d", 0);
   3906        }
   3907        CAM_DUMP_TO_FILE(QCAMERA_DUMP_FRM_LOCATION"ubifocus", name, index, "jpg",
   3908            dataPtr, dataLen);
   3909        LOGD("Dump the image %d %d allFocusImage %d",
   3910            getOutputImageCount(), index, allFocusImage);
   3911        setOutputImageCount(getOutputImageCount() + 1);
   3912        if (!allFocusImage) {
   3913            ret = false;
   3914        }
   3915    }
   3916    return ret;
   3917 }
   3918 
   3919 /*===========================================================================
   3920  * FUNCTION   : unconfigureAdvancedCapture
   3921  *
   3922  * DESCRIPTION: unconfigure Advanced Capture.
   3923  *
   3924  * PARAMETERS : none
   3925  *
   3926  * RETURN     : int32_t type of status
   3927  *              NO_ERROR  -- success
   3928  *              none-zero failure code
   3929  *==========================================================================*/
   3930 int32_t QCamera2HardwareInterface::unconfigureAdvancedCapture()
   3931 {
   3932     int32_t rc = NO_ERROR;
   3933 
   3934     if (mAdvancedCaptureConfigured) {
   3935 
   3936         mAdvancedCaptureConfigured = false;
   3937 
   3938         if(mIs3ALocked) {
   3939             mParameters.set3ALock(false);
   3940             mIs3ALocked = false;
   3941         }
   3942         if (mParameters.isHDREnabled() || mParameters.isAEBracketEnabled()) {
   3943             rc = mParameters.setToneMapMode(true, true);
   3944             if (rc != NO_ERROR) {
   3945                 LOGW("Failed to enable tone map during HDR/AEBracketing");
   3946             }
   3947             mHDRBracketingEnabled = false;
   3948             rc = mParameters.stopAEBracket();
   3949         } else if ((mParameters.isChromaFlashEnabled())
   3950                 || (mFlashNeeded && !mLongshotEnabled)
   3951                 || (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
   3952                 || (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
   3953             rc = mParameters.resetFrameCapture(TRUE);
   3954         } else if (mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
   3955             rc = configureAFBracketing(false);
   3956         } else if (mParameters.isOptiZoomEnabled()) {
   3957             rc = mParameters.setAndCommitZoom(mZoomLevel);
   3958             setDisplaySkip(FALSE, CAMERA_MAX_PARAM_APPLY_DELAY);
   3959         } else if (mParameters.isStillMoreEnabled()) {
   3960             cam_still_more_t stillmore_config = mParameters.getStillMoreSettings();
   3961             stillmore_config.burst_count = 0;
   3962             mParameters.setStillMoreSettings(stillmore_config);
   3963 
   3964             /* If SeeMore is running, it will handle re-enabling tone map */
   3965             if (!mParameters.isSeeMoreEnabled() && !mParameters.isLTMForSeeMoreEnabled()) {
   3966                 rc = mParameters.setToneMapMode(true, true);
   3967                 if (rc != NO_ERROR) {
   3968                     LOGW("Failed to enable tone map during StillMore");
   3969                 }
   3970             }
   3971 
   3972             /* Re-enable Tintless */
   3973             mParameters.setTintless(true);
   3974         } else {
   3975             LOGW("No Advanced Capture feature enabled!!");
   3976             rc = BAD_VALUE;
   3977         }
   3978     }
   3979 
   3980     return rc;
   3981 }
   3982 
   3983 /*===========================================================================
   3984  * FUNCTION   : configureAdvancedCapture
   3985  *
   3986  * DESCRIPTION: configure Advanced Capture.
   3987  *
   3988  * PARAMETERS : none
   3989  *
   3990  * RETURN     : int32_t type of status
   3991  *              NO_ERROR  -- success
   3992  *              none-zero failure code
   3993  *==========================================================================*/
   3994 int32_t QCamera2HardwareInterface::configureAdvancedCapture()
   3995 {
   3996     LOGH("E");
   3997     int32_t rc = NO_ERROR;
   3998 
   3999     rc = mParameters.checkFeatureConcurrency();
   4000     if (rc != NO_ERROR) {
   4001         LOGE("Cannot support Advanced capture modes");
   4002         return rc;
   4003     }
   4004 
   4005     setOutputImageCount(0);
   4006     mInputCount = 0;
   4007     mAdvancedCaptureConfigured = true;
   4008     /* Display should be disabled for advanced modes */
   4009     bool bSkipDisplay = true;
   4010 
   4011     if (getRelatedCamSyncInfo()->mode == CAM_MODE_SECONDARY) {
   4012         // no Advance capture settings for Aux camera
   4013         LOGH("X Secondary Camera, no need to process!! ");
   4014         return rc;
   4015     }
   4016 
   4017     /* Do not stop display if in stillmore livesnapshot */
   4018     if (mParameters.isStillMoreEnabled() &&
   4019             mParameters.isSeeMoreEnabled()) {
   4020         bSkipDisplay = false;
   4021     }
   4022     if (mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
   4023         rc = configureAFBracketing();
   4024     } else if (mParameters.isOptiZoomEnabled()) {
   4025         rc = configureOptiZoom();
   4026     } else if(mParameters.isHDREnabled()) {
   4027         rc = configureHDRBracketing();
   4028         if (mHDRBracketingEnabled) {
   4029             rc = mParameters.setToneMapMode(false, true);
   4030             if (rc != NO_ERROR) {
   4031                 LOGW("Failed to disable tone map during HDR");
   4032             }
   4033         }
   4034     } else if (mParameters.isAEBracketEnabled()) {
   4035         rc = mParameters.setToneMapMode(false, true);
   4036         if (rc != NO_ERROR) {
   4037             LOGW("Failed to disable tone map during AEBracketing");
   4038         }
   4039         rc = configureAEBracketing();
   4040     } else if (mParameters.isStillMoreEnabled()) {
   4041         rc = configureStillMore();
   4042     } else if ((mParameters.isChromaFlashEnabled())
   4043             || (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
   4044             || (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
   4045         rc = mParameters.configFrameCapture(TRUE);
   4046     } else if (mFlashNeeded && !mLongshotEnabled) {
   4047         rc = mParameters.configFrameCapture(TRUE);
   4048         bSkipDisplay = false;
   4049     } else {
   4050         LOGH("Advanced Capture feature not enabled!! ");
   4051         mAdvancedCaptureConfigured = false;
   4052         bSkipDisplay = false;
   4053     }
   4054 
   4055     LOGH("Stop preview temporarily for advanced captures");
   4056     setDisplaySkip(bSkipDisplay);
   4057 
   4058     LOGH("X rc = %d", rc);
   4059     return rc;
   4060 }
   4061 
   4062 /*===========================================================================
   4063  * FUNCTION   : configureAFBracketing
   4064  *
   4065  * DESCRIPTION: configure AF Bracketing.
   4066  *
   4067  * PARAMETERS : none
   4068  *
   4069  * RETURN     : int32_t type of status
   4070  *              NO_ERROR  -- success
   4071  *              none-zero failure code
   4072  *==========================================================================*/
   4073 int32_t QCamera2HardwareInterface::configureAFBracketing(bool enable)
   4074 {
   4075     LOGH("E");
   4076     int32_t rc = NO_ERROR;
   4077     cam_af_bracketing_t *af_bracketing_need;
   4078 
   4079     if (mParameters.isUbiRefocus()) {
   4080         af_bracketing_need =
   4081                 &gCamCapability[mCameraId]->refocus_af_bracketing_need;
   4082     } else {
   4083         af_bracketing_need =
   4084                 &gCamCapability[mCameraId]->ubifocus_af_bracketing_need;
   4085     }
   4086 
   4087     //Enable AF Bracketing.
   4088     cam_af_bracketing_t afBracket;
   4089     memset(&afBracket, 0, sizeof(cam_af_bracketing_t));
   4090     afBracket.enable = enable;
   4091     afBracket.burst_count = af_bracketing_need->burst_count;
   4092 
   4093     for(int8_t i = 0; i < MAX_AF_BRACKETING_VALUES; i++) {
   4094         afBracket.focus_steps[i] = af_bracketing_need->focus_steps[i];
   4095         LOGH("focus_step[%d] = %d", i, afBracket.focus_steps[i]);
   4096     }
   4097     //Send cmd to backend to set AF Bracketing for Ubi Focus.
   4098     rc = mParameters.commitAFBracket(afBracket);
   4099     if ( NO_ERROR != rc ) {
   4100         LOGE("cannot configure AF bracketing");
   4101         return rc;
   4102     }
   4103     if (enable) {
   4104         mParameters.set3ALock(true);
   4105         mIs3ALocked = true;
   4106     }
   4107     LOGH("X rc = %d", rc);
   4108     return rc;
   4109 }
   4110 
   4111 /*===========================================================================
   4112  * FUNCTION   : configureHDRBracketing
   4113  *
   4114  * DESCRIPTION: configure HDR Bracketing.
   4115  *
   4116  * PARAMETERS : none
   4117  *
   4118  * RETURN     : int32_t type of status
   4119  *              NO_ERROR  -- success
   4120  *              none-zero failure code
   4121  *==========================================================================*/
   4122 int32_t QCamera2HardwareInterface::configureHDRBracketing()
   4123 {
   4124     LOGH("E");
   4125     int32_t rc = NO_ERROR;
   4126 
   4127     cam_hdr_bracketing_info_t& hdrBracketingSetting =
   4128             gCamCapability[mCameraId]->hdr_bracketing_setting;
   4129 
   4130     // 'values' should be in "idx1,idx2,idx3,..." format
   4131     uint32_t hdrFrameCount =
   4132             hdrBracketingSetting.num_frames;
   4133     LOGH("HDR values %d, %d frame count: %u",
   4134           (int8_t) hdrBracketingSetting.exp_val.values[0],
   4135           (int8_t) hdrBracketingSetting.exp_val.values[1],
   4136           hdrFrameCount);
   4137 
   4138     // Enable AE Bracketing for HDR
   4139     cam_exp_bracketing_t aeBracket;
   4140     memset(&aeBracket, 0, sizeof(cam_exp_bracketing_t));
   4141     aeBracket.mode =
   4142         hdrBracketingSetting.exp_val.mode;
   4143 
   4144     if (aeBracket.mode == CAM_EXP_BRACKETING_ON) {
   4145         mHDRBracketingEnabled = true;
   4146     }
   4147 
   4148     String8 tmp;
   4149     for (uint32_t i = 0; i < hdrFrameCount; i++) {
   4150         tmp.appendFormat("%d",
   4151             (int8_t) hdrBracketingSetting.exp_val.values[i]);
   4152         tmp.append(",");
   4153     }
   4154     if (mParameters.isHDR1xFrameEnabled()
   4155         && mParameters.isHDR1xExtraBufferNeeded()) {
   4156             tmp.appendFormat("%d", 0);
   4157             tmp.append(",");
   4158     }
   4159 
   4160     if( !tmp.isEmpty() &&
   4161         ( MAX_EXP_BRACKETING_LENGTH > tmp.length() ) ) {
   4162         //Trim last comma
   4163         memset(aeBracket.values, '\0', MAX_EXP_BRACKETING_LENGTH);
   4164         memcpy(aeBracket.values, tmp.string(), tmp.length() - 1);
   4165     }
   4166 
   4167     LOGH("HDR config values %s",
   4168           aeBracket.values);
   4169     rc = mParameters.setHDRAEBracket(aeBracket);
   4170     if ( NO_ERROR != rc ) {
   4171         LOGE("cannot configure HDR bracketing");
   4172         return rc;
   4173     }
   4174     LOGH("X rc = %d", rc);
   4175     return rc;
   4176 }
   4177 
   4178 /*===========================================================================
   4179  * FUNCTION   : configureAEBracketing
   4180  *
   4181  * DESCRIPTION: configure AE Bracketing.
   4182  *
   4183  * PARAMETERS : none
   4184  *
   4185  * RETURN     : int32_t type of status
   4186  *              NO_ERROR  -- success
   4187  *              none-zero failure code
   4188  *==========================================================================*/
   4189 int32_t QCamera2HardwareInterface::configureAEBracketing()
   4190 {
   4191     LOGH("E");
   4192     int32_t rc = NO_ERROR;
   4193 
   4194     rc = mParameters.setAEBracketing();
   4195     if ( NO_ERROR != rc ) {
   4196         LOGE("cannot configure AE bracketing");
   4197         return rc;
   4198     }
   4199     LOGH("X rc = %d", rc);
   4200     return rc;
   4201 }
   4202 
   4203 /*===========================================================================
   4204  * FUNCTION   : configureOptiZoom
   4205  *
   4206  * DESCRIPTION: configure Opti Zoom.
   4207  *
   4208  * PARAMETERS : none
   4209  *
   4210  * RETURN     : int32_t type of status
   4211  *              NO_ERROR  -- success
   4212  *              none-zero failure code
   4213  *==========================================================================*/
   4214 int32_t QCamera2HardwareInterface::configureOptiZoom()
   4215 {
   4216     int32_t rc = NO_ERROR;
   4217 
   4218     //store current zoom level.
   4219     mZoomLevel = mParameters.getParmZoomLevel();
   4220 
   4221     //set zoom level to 1x;
   4222     mParameters.setAndCommitZoom(0);
   4223 
   4224     mParameters.set3ALock(true);
   4225     mIs3ALocked = true;
   4226 
   4227     return rc;
   4228 }
   4229 
   4230 /*===========================================================================
   4231  * FUNCTION   : configureStillMore
   4232  *
   4233  * DESCRIPTION: configure StillMore.
   4234  *
   4235  * PARAMETERS : none
   4236  *
   4237  * RETURN     : int32_t type of status
   4238  *              NO_ERROR  -- success
   4239  *              none-zero failure code
   4240  *==========================================================================*/
   4241 int32_t QCamera2HardwareInterface::configureStillMore()
   4242 {
   4243     int32_t rc = NO_ERROR;
   4244     uint8_t burst_cnt = 0;
   4245     cam_still_more_t stillmore_config;
   4246     cam_still_more_t stillmore_cap;
   4247 
   4248     /* Disable Tone Map. If seemore is enabled, it will handle disabling it. */
   4249     if (!mParameters.isSeeMoreEnabled() && !mParameters.isLTMForSeeMoreEnabled()) {
   4250         rc = mParameters.setToneMapMode(false, true);
   4251         if (rc != NO_ERROR) {
   4252             LOGW("Failed to disable tone map during StillMore");
   4253         }
   4254     }
   4255 
   4256     /* Lock 3A */
   4257     mParameters.set3ALock(true);
   4258     mIs3ALocked = true;
   4259 
   4260     /* Disable Tintless */
   4261     mParameters.setTintless(false);
   4262 
   4263     /* Initialize burst count from capability */
   4264     stillmore_cap = mParameters.getStillMoreCapability();
   4265     burst_cnt = stillmore_cap.max_burst_count;
   4266 
   4267     /* Reconfigure burst count from dynamic scene data */
   4268     cam_dyn_img_data_t dynamic_img_data = mParameters.getDynamicImgData();
   4269     if (dynamic_img_data.input_count >= stillmore_cap.min_burst_count &&
   4270             dynamic_img_data.input_count <= stillmore_cap.max_burst_count) {
   4271         burst_cnt = dynamic_img_data.input_count;
   4272     }
   4273 
   4274     /* Reconfigure burst count in the case of liveshot */
   4275     if (mParameters.isSeeMoreEnabled()) {
   4276         burst_cnt = 1;
   4277     }
   4278 
   4279     /* Reconfigure burst count from user input */
   4280     char prop[PROPERTY_VALUE_MAX];
   4281     property_get("persist.camera.imglib.stillmore", prop, "0");
   4282     uint8_t burst_setprop = (uint32_t)atoi(prop);
   4283     if (burst_setprop != 0)  {
   4284        if ((burst_setprop < stillmore_cap.min_burst_count) ||
   4285                (burst_setprop > stillmore_cap.max_burst_count)) {
   4286            burst_cnt = stillmore_cap.max_burst_count;
   4287        } else {
   4288            burst_cnt = burst_setprop;
   4289        }
   4290     }
   4291 
   4292     memset(&stillmore_config, 0, sizeof(cam_still_more_t));
   4293     stillmore_config.burst_count = burst_cnt;
   4294     mParameters.setStillMoreSettings(stillmore_config);
   4295 
   4296     LOGH("Stillmore burst %d", burst_cnt);
   4297 
   4298     return rc;
   4299 }
   4300 
   4301 /*===========================================================================
   4302  * FUNCTION   : stopAdvancedCapture
   4303  *
   4304  * DESCRIPTION: stops advanced capture based on capture type
   4305  *
   4306  * PARAMETERS :
   4307  *   @pChannel : channel.
   4308  *
   4309  * RETURN     : int32_t type of status
   4310  *              NO_ERROR  -- success
   4311  *              none-zero failure code
   4312  *==========================================================================*/
   4313 int32_t QCamera2HardwareInterface::stopAdvancedCapture(
   4314         QCameraPicChannel *pChannel)
   4315 {
   4316     LOGH("stop bracketig");
   4317     int32_t rc = NO_ERROR;
   4318 
   4319     if(mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
   4320         rc = pChannel->stopAdvancedCapture(MM_CAMERA_AF_BRACKETING);
   4321     } else if (mParameters.isChromaFlashEnabled()
   4322             || (mFlashNeeded && !mLongshotEnabled)
   4323             || (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
   4324             || (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
   4325         rc = pChannel->stopAdvancedCapture(MM_CAMERA_FRAME_CAPTURE);
   4326     } else if(mParameters.isHDREnabled()
   4327             || mParameters.isAEBracketEnabled()) {
   4328         rc = pChannel->stopAdvancedCapture(MM_CAMERA_AE_BRACKETING);
   4329     } else if (mParameters.isOptiZoomEnabled()) {
   4330         rc = pChannel->stopAdvancedCapture(MM_CAMERA_ZOOM_1X);
   4331     } else if (mParameters.isStillMoreEnabled()) {
   4332         LOGH("stopAdvancedCapture not needed for StillMore");
   4333     } else {
   4334         LOGH("No Advanced Capture feature enabled!");
   4335         rc = BAD_VALUE;
   4336     }
   4337     return rc;
   4338 }
   4339 
   4340 /*===========================================================================
   4341  * FUNCTION   : startAdvancedCapture
   4342  *
   4343  * DESCRIPTION: starts advanced capture based on capture type
   4344  *
   4345  * PARAMETERS :
   4346  *   @pChannel : channel.
   4347  *
   4348  * RETURN     : int32_t type of status
   4349  *              NO_ERROR  -- success
   4350  *              none-zero failure code
   4351  *==========================================================================*/
   4352 int32_t QCamera2HardwareInterface::startAdvancedCapture(
   4353         QCameraPicChannel *pChannel)
   4354 {
   4355     LOGH("Start bracketing");
   4356     int32_t rc = NO_ERROR;
   4357 
   4358     if(mParameters.isUbiFocusEnabled() || mParameters.isUbiRefocus()) {
   4359         rc = pChannel->startAdvancedCapture(MM_CAMERA_AF_BRACKETING);
   4360     } else if (mParameters.isOptiZoomEnabled()) {
   4361         rc = pChannel->startAdvancedCapture(MM_CAMERA_ZOOM_1X);
   4362     } else if (mParameters.isStillMoreEnabled()) {
   4363         LOGH("startAdvancedCapture not needed for StillMore");
   4364     } else if (mParameters.isHDREnabled()
   4365             || mParameters.isAEBracketEnabled()) {
   4366         rc = pChannel->startAdvancedCapture(MM_CAMERA_AE_BRACKETING);
   4367     } else if (mParameters.isChromaFlashEnabled()
   4368             || (mFlashNeeded && !mLongshotEnabled)
   4369             || (mParameters.getLowLightLevel() != CAM_LOW_LIGHT_OFF)
   4370             || (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2)) {
   4371         cam_capture_frame_config_t config = mParameters.getCaptureFrameConfig();
   4372         rc = pChannel->startAdvancedCapture(MM_CAMERA_FRAME_CAPTURE, &config);
   4373     } else {
   4374         LOGE("No Advanced Capture feature enabled!");
   4375         rc = BAD_VALUE;
   4376     }
   4377     return rc;
   4378 }
   4379 
   4380 /*===========================================================================
   4381  * FUNCTION   : preTakePicture
   4382  *
   4383  * DESCRIPTION: Prepare take picture impl, Restarts preview if necessary
   4384  *
   4385  * PARAMETERS : none
   4386  *
   4387  * RETURN     : int32_t type of status
   4388  *              NO_ERROR  -- success
   4389  *              none-zero failure code
   4390  *==========================================================================*/
   4391 int QCamera2HardwareInterface::preTakePicture()
   4392 {
   4393     int32_t rc = NO_ERROR;
   4394     LOGH("E");
   4395     if (mParameters.getRecordingHintValue() == true) {
   4396 
   4397         // Give HWI control to restart preview only in single camera mode.
   4398         // In dual-cam mode, this control belongs to muxer.
   4399         if (getRelatedCamSyncInfo()->sync_control != CAM_SYNC_RELATED_SENSORS_ON) {
   4400             LOGH("restart preview if rec hint is true and preview is running");
   4401             stopPreview();
   4402             mParameters.updateRecordingHintValue(FALSE);
   4403             // start preview again
   4404             rc = preparePreview();
   4405             if (rc == NO_ERROR) {
   4406                 rc = startPreview();
   4407                 if (rc != NO_ERROR) {
   4408                     unpreparePreview();
   4409                 }
   4410             }
   4411         }
   4412         else
   4413         {
   4414             // For dual cam mode, update the flag mPreviewRestartNeeded to true
   4415             // Restart control will be handled by muxer.
   4416             mPreviewRestartNeeded = true;
   4417         }
   4418     }
   4419 
   4420     LOGH("X rc = %d", rc);
   4421     return rc;
   4422 }
   4423 
   4424 /*===========================================================================
   4425  * FUNCTION   : takePicture
   4426  *
   4427  * DESCRIPTION: take picture impl
   4428  *
   4429  * PARAMETERS : none
   4430  *
   4431  * RETURN     : int32_t type of status
   4432  *              NO_ERROR  -- success
   4433  *              none-zero failure code
   4434  *==========================================================================*/
   4435 int QCamera2HardwareInterface::takePicture()
   4436 {
   4437     int rc = NO_ERROR;
   4438 
   4439     // Get total number for snapshots (retro + regular)
   4440     uint8_t numSnapshots = mParameters.getNumOfSnapshots();
   4441     // Get number of retro-active snapshots
   4442     uint8_t numRetroSnapshots = mParameters.getNumOfRetroSnapshots();
   4443     LOGH("E");
   4444 
   4445     //Set rotation value from user settings as Jpeg rotation
   4446     //to configure back-end modules.
   4447     mParameters.setJpegRotation(mParameters.getRotation());
   4448 
   4449     // Check if retro-active snapshots are not enabled
   4450     if (!isRetroPicture() || !mParameters.isZSLMode()) {
   4451       numRetroSnapshots = 0;
   4452       LOGH("Reset retro snaphot count to zero");
   4453     }
   4454 
   4455     //Do special configure for advanced capture modes.
   4456     rc = configureAdvancedCapture();
   4457     if (rc != NO_ERROR) {
   4458         LOGE("Unsupported capture call");
   4459         return rc;
   4460     }
   4461 
   4462     if (mAdvancedCaptureConfigured) {
   4463         numSnapshots = mParameters.getBurstCountForAdvancedCapture();
   4464     }
   4465     LOGI("snap count = %d zsl = %d advanced = %d",
   4466             numSnapshots, mParameters.isZSLMode(), mAdvancedCaptureConfigured);
   4467 
   4468     if (mParameters.isZSLMode()) {
   4469         QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
   4470         QCameraPicChannel *pPicChannel = (QCameraPicChannel *)pChannel;
   4471         if (NULL != pPicChannel) {
   4472 
   4473             if (mParameters.getofflineRAW()) {
   4474                 startRAWChannel(pPicChannel);
   4475                 pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_RAW];
   4476                 if (pPicChannel == NULL) {
   4477                     LOGE("RAW Channel is NULL in Manual capture mode");
   4478                     stopRAWChannel();
   4479                     return UNKNOWN_ERROR;
   4480                 }
   4481             }
   4482 
   4483             rc = configureOnlineRotation(*pPicChannel);
   4484             if (rc != NO_ERROR) {
   4485                 LOGE("online rotation failed");
   4486                 return rc;
   4487             }
   4488 
   4489             // start postprocessor
   4490             DeferWorkArgs args;
   4491             memset(&args, 0, sizeof(DeferWorkArgs));
   4492 
   4493             args.pprocArgs = pPicChannel;
   4494 
   4495             // No need to wait for mInitPProcJob here, because it was
   4496             // queued in startPreview, and will definitely be processed before
   4497             // mReprocJob can begin.
   4498             mReprocJob = queueDeferredWork(CMD_DEF_PPROC_START,
   4499                     args);
   4500             if (mReprocJob == 0) {
   4501                 LOGE("Failure: Unable to start pproc");
   4502                 return -ENOMEM;
   4503             }
   4504 
   4505             // Check if all preview buffers are mapped before creating
   4506             // a jpeg session as preview stream buffers are queried during the same
   4507             uint8_t numStreams = pChannel->getNumOfStreams();
   4508             QCameraStream *pStream = NULL;
   4509             QCameraStream *pPreviewStream = NULL;
   4510             for (uint8_t i = 0 ; i < numStreams ; i++ ) {
   4511                 pStream = pChannel->getStreamByIndex(i);
   4512                 if (!pStream)
   4513                     continue;
   4514                 if (CAM_STREAM_TYPE_PREVIEW == pStream->getMyType()) {
   4515                     pPreviewStream = pStream;
   4516                     break;
   4517                 }
   4518             }
   4519             if (pPreviewStream != NULL) {
   4520                 Mutex::Autolock l(mMapLock);
   4521                 QCameraMemory *pMemory = pStream->getStreamBufs();
   4522                 if (!pMemory) {
   4523                     LOGE("Error!! pMemory is NULL");
   4524                     return -ENOMEM;
   4525                 }
   4526 
   4527                 uint8_t waitCnt = 2;
   4528                 while (!pMemory->checkIfAllBuffersMapped() && (waitCnt > 0)) {
   4529                     LOGL(" Waiting for preview buffers to be mapped");
   4530                     mMapCond.waitRelative(
   4531                             mMapLock, CAMERA_DEFERRED_MAP_BUF_TIMEOUT);
   4532                     LOGL("Wait completed!!");
   4533                     waitCnt--;
   4534                 }
   4535                 // If all buffers are not mapped after retries, assert
   4536                 assert(pMemory->checkIfAllBuffersMapped());
   4537             } else {
   4538                 assert(pPreviewStream);
   4539             }
   4540 
   4541             // Create JPEG session
   4542             mJpegJob = queueDeferredWork(CMD_DEF_CREATE_JPEG_SESSION,
   4543                     args);
   4544             if (mJpegJob == 0) {
   4545                 LOGE("Failed to queue CREATE_JPEG_SESSION");
   4546                 if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4547                         LOGE("Reprocess Deferred work was failed");
   4548                 }
   4549                 m_postprocessor.stop();
   4550                 return -ENOMEM;
   4551             }
   4552 
   4553             if (mAdvancedCaptureConfigured) {
   4554                 rc = startAdvancedCapture(pPicChannel);
   4555                 if (rc != NO_ERROR) {
   4556                     LOGE("cannot start zsl advanced capture");
   4557                     return rc;
   4558                 }
   4559             }
   4560             if (mLongshotEnabled && mPrepSnapRun) {
   4561                 mCameraHandle->ops->start_zsl_snapshot(
   4562                         mCameraHandle->camera_handle,
   4563                         pPicChannel->getMyHandle());
   4564             }
   4565             // If frame sync is ON and it is a SECONDARY camera,
   4566             // we do not need to send the take picture command to interface
   4567             // It will be handled along with PRIMARY camera takePicture request
   4568             mm_camera_req_buf_t buf;
   4569             memset(&buf, 0x0, sizeof(buf));
   4570             if ((!mParameters.isAdvCamFeaturesEnabled() &&
   4571                     !mFlashNeeded &&
   4572                     !isLongshotEnabled() &&
   4573                     isFrameSyncEnabled()) &&
   4574                     (getRelatedCamSyncInfo()->sync_control ==
   4575                     CAM_SYNC_RELATED_SENSORS_ON)) {
   4576                 if (getRelatedCamSyncInfo()->mode == CAM_MODE_PRIMARY) {
   4577                     buf.type = MM_CAMERA_REQ_FRAME_SYNC_BUF;
   4578                     buf.num_buf_requested = numSnapshots;
   4579                     rc = pPicChannel->takePicture(&buf);
   4580                     if (rc != NO_ERROR) {
   4581                         LOGE("FS_DBG cannot take ZSL picture, stop pproc");
   4582                         if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4583                             LOGE("Reprocess Deferred work failed");
   4584                             return UNKNOWN_ERROR;
   4585                         }
   4586                         if (NO_ERROR != waitDeferredWork(mJpegJob)) {
   4587                             LOGE("Jpeg Deferred work failed");
   4588                             return UNKNOWN_ERROR;
   4589                         }
   4590                         m_postprocessor.stop();
   4591                         return rc;
   4592                     }
   4593                     LOGI("PRIMARY camera: send frame sync takePicture!!");
   4594                 }
   4595             } else {
   4596                 buf.type = MM_CAMERA_REQ_SUPER_BUF;
   4597                 buf.num_buf_requested = numSnapshots;
   4598                 buf.num_retro_buf_requested = numRetroSnapshots;
   4599                 rc = pPicChannel->takePicture(&buf);
   4600                 if (rc != NO_ERROR) {
   4601                     LOGE("cannot take ZSL picture, stop pproc");
   4602                         if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4603                             LOGE("Reprocess Deferred work failed");
   4604                             return UNKNOWN_ERROR;
   4605                         }
   4606                         if (NO_ERROR != waitDeferredWork(mJpegJob)) {
   4607                             LOGE("Jpeg Deferred work failed");
   4608                             return UNKNOWN_ERROR;
   4609                         }
   4610                     m_postprocessor.stop();
   4611                     return rc;
   4612                 }
   4613             }
   4614         } else {
   4615             LOGE("ZSL channel is NULL");
   4616             return UNKNOWN_ERROR;
   4617         }
   4618     } else {
   4619 
   4620         // start snapshot
   4621         if (mParameters.isJpegPictureFormat() ||
   4622                 mParameters.isNV16PictureFormat() ||
   4623                 mParameters.isNV21PictureFormat()) {
   4624 
   4625             //STOP Preview for Non ZSL use case
   4626             stopPreview();
   4627 
   4628             //Config CAPTURE channels
   4629             rc = declareSnapshotStreams();
   4630             if (NO_ERROR != rc) {
   4631                 return rc;
   4632             }
   4633 
   4634             rc = addCaptureChannel();
   4635             if ((rc == NO_ERROR) &&
   4636                     (NULL != m_channels[QCAMERA_CH_TYPE_CAPTURE])) {
   4637 
   4638                 if (!mParameters.getofflineRAW()) {
   4639                     rc = configureOnlineRotation(
   4640                         *m_channels[QCAMERA_CH_TYPE_CAPTURE]);
   4641                     if (rc != NO_ERROR) {
   4642                         LOGE("online rotation failed");
   4643                         delChannel(QCAMERA_CH_TYPE_CAPTURE);
   4644                         return rc;
   4645                     }
   4646                 }
   4647 
   4648                 DeferWorkArgs args;
   4649                 memset(&args, 0, sizeof(DeferWorkArgs));
   4650 
   4651                 args.pprocArgs = m_channels[QCAMERA_CH_TYPE_CAPTURE];
   4652 
   4653                 // No need to wait for mInitPProcJob here, because it was
   4654                 // queued in startPreview, and will definitely be processed before
   4655                 // mReprocJob can begin.
   4656                 mReprocJob = queueDeferredWork(CMD_DEF_PPROC_START,
   4657                         args);
   4658                 if (mReprocJob == 0) {
   4659                     LOGE("Failure: Unable to start pproc");
   4660                     return -ENOMEM;
   4661                 }
   4662 
   4663                 // Create JPEG session
   4664                 mJpegJob = queueDeferredWork(CMD_DEF_CREATE_JPEG_SESSION,
   4665                         args);
   4666                 if (mJpegJob == 0) {
   4667                     LOGE("Failed to queue CREATE_JPEG_SESSION");
   4668                     if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4669                         LOGE("Reprocess Deferred work was failed");
   4670                     }
   4671                     m_postprocessor.stop();
   4672                     return -ENOMEM;
   4673                 }
   4674 
   4675                 // start catpure channel
   4676                 rc =  m_channels[QCAMERA_CH_TYPE_CAPTURE]->start();
   4677                 if (rc != NO_ERROR) {
   4678                     LOGE("cannot start capture channel");
   4679                     if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4680                         LOGE("Reprocess Deferred work failed");
   4681                         return UNKNOWN_ERROR;
   4682                     }
   4683                     if (NO_ERROR != waitDeferredWork(mJpegJob)) {
   4684                         LOGE("Jpeg Deferred work failed");
   4685                         return UNKNOWN_ERROR;
   4686                     }
   4687                     delChannel(QCAMERA_CH_TYPE_CAPTURE);
   4688                     return rc;
   4689                 }
   4690 
   4691                 QCameraPicChannel *pCapChannel =
   4692                     (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_CAPTURE];
   4693                 if (NULL != pCapChannel) {
   4694                     if (mParameters.isUbiFocusEnabled() ||
   4695                             mParameters.isUbiRefocus() ||
   4696                             mParameters.isChromaFlashEnabled()) {
   4697                         rc = startAdvancedCapture(pCapChannel);
   4698                         if (rc != NO_ERROR) {
   4699                             LOGE("cannot start advanced capture");
   4700                             return rc;
   4701                         }
   4702                     }
   4703                 }
   4704                 if ( mLongshotEnabled ) {
   4705                     rc = longShot();
   4706                     if (NO_ERROR != rc) {
   4707                         if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   4708                             LOGE("Reprocess Deferred work failed");
   4709                             return UNKNOWN_ERROR;
   4710                         }
   4711                         if (NO_ERROR != waitDeferredWork(mJpegJob)) {
   4712                             LOGE("Jpeg Deferred work failed");
   4713                             return UNKNOWN_ERROR;
   4714                         }
   4715                         delChannel(QCAMERA_CH_TYPE_CAPTURE);
   4716                         return rc;
   4717                     }
   4718                 }
   4719             } else {
   4720                 LOGE("cannot add capture channel");
   4721                 delChannel(QCAMERA_CH_TYPE_CAPTURE);
   4722                 return rc;
   4723             }
   4724         } else {
   4725             // Stop Preview before taking NZSL snapshot
   4726             stopPreview();
   4727 
   4728             rc = mParameters.updateRAW(gCamCapability[mCameraId]->raw_dim[0]);
   4729             if (NO_ERROR != rc) {
   4730                 LOGE("Raw dimension update failed %d", rc);
   4731                 return rc;
   4732             }
   4733 
   4734             rc = declareSnapshotStreams();
   4735             if (NO_ERROR != rc) {
   4736                 LOGE("RAW stream info configuration failed %d", rc);
   4737                 return rc;
   4738             }
   4739 
   4740             rc = addChannel(QCAMERA_CH_TYPE_RAW);
   4741             if (rc == NO_ERROR) {
   4742                 // start postprocessor
   4743                 if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
   4744                     LOGE("Reprocess Deferred work failed");
   4745                     return UNKNOWN_ERROR;
   4746                 }
   4747 
   4748                 rc = m_postprocessor.start(m_channels[QCAMERA_CH_TYPE_RAW]);
   4749                 if (rc != NO_ERROR) {
   4750                     LOGE("cannot start postprocessor");
   4751                     delChannel(QCAMERA_CH_TYPE_RAW);
   4752                     return rc;
   4753                 }
   4754 
   4755                 rc = startChannel(QCAMERA_CH_TYPE_RAW);
   4756                 if (rc != NO_ERROR) {
   4757                     LOGE("cannot start raw channel");
   4758                     m_postprocessor.stop();
   4759                     delChannel(QCAMERA_CH_TYPE_RAW);
   4760                     return rc;
   4761                 }
   4762             } else {
   4763                 LOGE("cannot add raw channel");
   4764                 return rc;
   4765             }
   4766         }
   4767     }
   4768 
   4769     //When take picture, stop sending preview callbacks to APP
   4770     m_stateMachine.setPreviewCallbackNeeded(false);
   4771     LOGI("X rc = %d", rc);
   4772     return rc;
   4773 }
   4774 
   4775 /*===========================================================================
   4776  * FUNCTION   : configureOnlineRotation
   4777  *
   4778  * DESCRIPTION: Configure backend with expected rotation for snapshot stream
   4779  *
   4780  * PARAMETERS :
   4781  *    @ch     : Channel containing a snapshot stream
   4782  *
   4783  * RETURN     : int32_t type of status
   4784  *              NO_ERROR  -- success
   4785  *              none-zero failure code
   4786  *==========================================================================*/
   4787 int32_t QCamera2HardwareInterface::configureOnlineRotation(QCameraChannel &ch)
   4788 {
   4789     int rc = NO_ERROR;
   4790     uint32_t streamId = 0;
   4791     QCameraStream *pStream = NULL;
   4792 
   4793     for (uint8_t i = 0; i < ch.getNumOfStreams(); i++) {
   4794         QCameraStream *stream = ch.getStreamByIndex(i);
   4795         if ((NULL != stream) &&
   4796                 ((CAM_STREAM_TYPE_SNAPSHOT == stream->getMyType())
   4797                 || (CAM_STREAM_TYPE_RAW == stream->getMyType()))) {
   4798             pStream = stream;
   4799             break;
   4800         }
   4801     }
   4802 
   4803     if (NULL == pStream) {
   4804         LOGE("No snapshot stream found!");
   4805         return BAD_VALUE;
   4806     }
   4807 
   4808     streamId = pStream->getMyServerID();
   4809     // Update online rotation configuration
   4810     rc = mParameters.addOnlineRotation(mParameters.getJpegRotation(), streamId,
   4811             mParameters.getDeviceRotation());
   4812     if (rc != NO_ERROR) {
   4813         LOGE("addOnlineRotation failed %d", rc);
   4814         return rc;
   4815     }
   4816 
   4817     return rc;
   4818 }
   4819 
   4820 /*===========================================================================
   4821  * FUNCTION   : declareSnapshotStreams
   4822  *
   4823  * DESCRIPTION: Configure backend with expected snapshot streams
   4824  *
   4825  * PARAMETERS : none
   4826  *
   4827  * RETURN     : int32_t type of status
   4828  *              NO_ERROR  -- success
   4829  *              none-zero failure code
   4830  *==========================================================================*/
   4831 int32_t QCamera2HardwareInterface::declareSnapshotStreams()
   4832 {
   4833     int rc = NO_ERROR;
   4834 
   4835     // Update stream info configuration
   4836     rc = mParameters.setStreamConfigure(true, mLongshotEnabled, false);
   4837     if (rc != NO_ERROR) {
   4838         LOGE("setStreamConfigure failed %d", rc);
   4839         return rc;
   4840     }
   4841 
   4842     return rc;
   4843 }
   4844 
   4845 /*===========================================================================
   4846  * FUNCTION   : longShot
   4847  *
   4848  * DESCRIPTION: Queue one more ZSL frame
   4849  *              in the longshot pipe.
   4850  *
   4851  * PARAMETERS : none
   4852  *
   4853  * RETURN     : int32_t type of status
   4854  *              NO_ERROR  -- success
   4855  *              none-zero failure code
   4856  *==========================================================================*/
   4857 int32_t QCamera2HardwareInterface::longShot()
   4858 {
   4859     int32_t rc = NO_ERROR;
   4860     uint8_t numSnapshots = mParameters.getNumOfSnapshots();
   4861     QCameraPicChannel *pChannel = NULL;
   4862 
   4863     if (mParameters.isZSLMode()) {
   4864         pChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
   4865     } else {
   4866         pChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_CAPTURE];
   4867     }
   4868 
   4869     if (NULL != pChannel) {
   4870         mm_camera_req_buf_t buf;
   4871         memset(&buf, 0x0, sizeof(buf));
   4872         buf.type = MM_CAMERA_REQ_SUPER_BUF;
   4873         buf.num_buf_requested = numSnapshots;
   4874         rc = pChannel->takePicture(&buf);
   4875     } else {
   4876         LOGE("Capture channel not initialized!");
   4877         rc = NO_INIT;
   4878         goto end;
   4879     }
   4880 
   4881 end:
   4882     return rc;
   4883 }
   4884 
   4885 /*===========================================================================
   4886  * FUNCTION   : stopCaptureChannel
   4887  *
   4888  * DESCRIPTION: Stops capture channel
   4889  *
   4890  * PARAMETERS :
   4891  *   @destroy : Set to true to stop and delete camera channel.
   4892  *              Set to false to only stop capture channel.
   4893  *
   4894  * RETURN     : int32_t type of status
   4895  *              NO_ERROR  -- success
   4896  *              none-zero failure code
   4897  *==========================================================================*/
   4898 int QCamera2HardwareInterface::stopCaptureChannel(bool destroy)
   4899 {
   4900     int rc = NO_ERROR;
   4901     if (mParameters.isJpegPictureFormat() ||
   4902         mParameters.isNV16PictureFormat() ||
   4903         mParameters.isNV21PictureFormat()) {
   4904         rc = stopChannel(QCAMERA_CH_TYPE_CAPTURE);
   4905         if (destroy && (NO_ERROR == rc)) {
   4906             // Destroy camera channel but dont release context
   4907             waitDeferredWork(mJpegJob);
   4908             rc = delChannel(QCAMERA_CH_TYPE_CAPTURE, false);
   4909         }
   4910     }
   4911 
   4912     return rc;
   4913 }
   4914 
   4915 /*===========================================================================
   4916  * FUNCTION   : cancelPicture
   4917  *
   4918  * DESCRIPTION: cancel picture impl
   4919  *
   4920  * PARAMETERS : none
   4921  *
   4922  * RETURN     : int32_t type of status
   4923  *              NO_ERROR  -- success
   4924  *              none-zero failure code
   4925  *==========================================================================*/
   4926 int QCamera2HardwareInterface::cancelPicture()
   4927 {
   4928     waitDeferredWork(mReprocJob);
   4929     waitDeferredWork(mJpegJob);
   4930 
   4931     //stop post processor
   4932     m_postprocessor.stop();
   4933 
   4934     unconfigureAdvancedCapture();
   4935     LOGH("Enable display frames again");
   4936     setDisplaySkip(FALSE);
   4937 
   4938     if (!mLongshotEnabled) {
   4939         m_perfLock.lock_rel();
   4940     }
   4941 
   4942     if (mParameters.isZSLMode()) {
   4943         QCameraPicChannel *pPicChannel = NULL;
   4944         if (mParameters.getofflineRAW()) {
   4945             pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_RAW];
   4946         } else {
   4947             pPicChannel = (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
   4948         }
   4949         if (NULL != pPicChannel) {
   4950             pPicChannel->cancelPicture();
   4951             stopRAWChannel();
   4952             stopAdvancedCapture(pPicChannel);
   4953         }
   4954     } else {
   4955 
   4956         // normal capture case
   4957         if (mParameters.isJpegPictureFormat() ||
   4958             mParameters.isNV16PictureFormat() ||
   4959             mParameters.isNV21PictureFormat()) {
   4960             stopChannel(QCAMERA_CH_TYPE_CAPTURE);
   4961             delChannel(QCAMERA_CH_TYPE_CAPTURE);
   4962         } else {
   4963             stopChannel(QCAMERA_CH_TYPE_RAW);
   4964             delChannel(QCAMERA_CH_TYPE_RAW);
   4965         }
   4966     }
   4967 
   4968     return NO_ERROR;
   4969 }
   4970 
   4971 /*===========================================================================
   4972  * FUNCTION   : captureDone
   4973  *
   4974  * DESCRIPTION: Function called when the capture is completed before encoding
   4975  *
   4976  * PARAMETERS : none
   4977  *
   4978  * RETURN     : none
   4979  *==========================================================================*/
   4980 void QCamera2HardwareInterface::captureDone()
   4981 {
   4982     qcamera_sm_internal_evt_payload_t *payload =
   4983        (qcamera_sm_internal_evt_payload_t *)
   4984        malloc(sizeof(qcamera_sm_internal_evt_payload_t));
   4985     if (NULL != payload) {
   4986         memset(payload, 0, sizeof(qcamera_sm_internal_evt_payload_t));
   4987         payload->evt_type = QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE;
   4988         int32_t rc = processEvt(QCAMERA_SM_EVT_EVT_INTERNAL, payload);
   4989         if (rc != NO_ERROR) {
   4990             LOGE("processEvt ZSL capture done failed");
   4991             free(payload);
   4992             payload = NULL;
   4993         }
   4994     } else {
   4995         LOGE("No memory for ZSL capture done event");
   4996     }
   4997 }
   4998 
   4999 /*===========================================================================
   5000  * FUNCTION   : Live_Snapshot_thread
   5001  *
   5002  * DESCRIPTION: Seperate thread for taking live snapshot during recording
   5003  *
   5004  * PARAMETERS : @data - pointer to QCamera2HardwareInterface class object
   5005  *
   5006  * RETURN     : none
   5007  *==========================================================================*/
   5008 void* Live_Snapshot_thread (void* data)
   5009 {
   5010 
   5011     QCamera2HardwareInterface *hw = reinterpret_cast<QCamera2HardwareInterface *>(data);
   5012     if (!hw) {
   5013         LOGE("take_picture_thread: NULL camera device");
   5014         return (void *)BAD_VALUE;
   5015     }
   5016     if (hw->bLiveSnapshot) {
   5017         hw->takeLiveSnapshot_internal();
   5018     } else {
   5019         hw->cancelLiveSnapshot_internal();
   5020     }
   5021     return (void* )NULL;
   5022 }
   5023 
   5024 /*===========================================================================
   5025  * FUNCTION   : Int_Pic_thread
   5026  *
   5027  * DESCRIPTION: Seperate thread for taking snapshot triggered by camera backend
   5028  *
   5029  * PARAMETERS : @data - pointer to QCamera2HardwareInterface class object
   5030  *
   5031  * RETURN     : none
   5032  *==========================================================================*/
   5033 void* Int_Pic_thread (void* data)
   5034 {
   5035     int rc = NO_ERROR;
   5036 
   5037     QCamera2HardwareInterface *hw = reinterpret_cast<QCamera2HardwareInterface *>(data);
   5038 
   5039     if (!hw) {
   5040         LOGE("take_picture_thread: NULL camera device");
   5041         return (void *)BAD_VALUE;
   5042     }
   5043 
   5044     bool JpegMemOpt = false;
   5045     char raw_format[PROPERTY_VALUE_MAX];
   5046 
   5047     memset(raw_format, 0, sizeof(raw_format));
   5048 
   5049     rc = hw->takeBackendPic_internal(&JpegMemOpt, &raw_format[0]);
   5050     if (rc == NO_ERROR) {
   5051         hw->checkIntPicPending(JpegMemOpt, &raw_format[0]);
   5052     } else {
   5053         //Snapshot attempt not successful, we need to do cleanup here
   5054         hw->clearIntPendingEvents();
   5055     }
   5056 
   5057     return (void* )NULL;
   5058 }
   5059 
   5060 /*===========================================================================
   5061  * FUNCTION   : takeLiveSnapshot
   5062  *
   5063  * DESCRIPTION: take live snapshot during recording
   5064  *
   5065  * PARAMETERS : none
   5066  *
   5067  * RETURN     : int32_t type of status
   5068  *              NO_ERROR  -- success
   5069  *              none-zero failure code
   5070  *==========================================================================*/
   5071 int QCamera2HardwareInterface::takeLiveSnapshot()
   5072 {
   5073     int rc = NO_ERROR;
   5074     if (mLiveSnapshotThread != 0) {
   5075         pthread_join(mLiveSnapshotThread,NULL);
   5076         mLiveSnapshotThread = 0;
   5077     }
   5078     bLiveSnapshot = true;
   5079     rc= pthread_create(&mLiveSnapshotThread, NULL, Live_Snapshot_thread, (void *) this);
   5080     if (!rc) {
   5081         pthread_setname_np(mLiveSnapshotThread, "CAM_liveSnap");
   5082     }
   5083     return rc;
   5084 }
   5085 
   5086 /*===========================================================================
   5087  * FUNCTION   : takePictureInternal
   5088  *
   5089  * DESCRIPTION: take snapshot triggered by backend
   5090  *
   5091  * PARAMETERS : none
   5092  *
   5093  * RETURN     : int32_t type of status
   5094  *              NO_ERROR  -- success
   5095  *              none-zero failure code
   5096  *==========================================================================*/
   5097 int QCamera2HardwareInterface::takePictureInternal()
   5098 {
   5099     int rc = NO_ERROR;
   5100     rc= pthread_create(&mIntPicThread, NULL, Int_Pic_thread, (void *) this);
   5101     if (!rc) {
   5102         pthread_setname_np(mIntPicThread, "CAM_IntPic");
   5103     }
   5104     return rc;
   5105 }
   5106 
   5107 /*===========================================================================
   5108  * FUNCTION   : checkIntPicPending
   5109  *
   5110  * DESCRIPTION: timed wait for jpeg completion event, and send
   5111  *                        back completion event to backend
   5112  *
   5113  * PARAMETERS : none
   5114  *
   5115  * RETURN     : none
   5116  *==========================================================================*/
   5117 void QCamera2HardwareInterface::checkIntPicPending(bool JpegMemOpt, char *raw_format)
   5118 {
   5119     bool bSendToBackend = true;
   5120     cam_int_evt_params_t params;
   5121     int rc = NO_ERROR;
   5122 
   5123     struct timespec   ts;
   5124     struct timeval    tp;
   5125     gettimeofday(&tp, NULL);
   5126     ts.tv_sec  = tp.tv_sec + 5;
   5127     ts.tv_nsec = tp.tv_usec * 1000;
   5128 
   5129     if (true == m_bIntJpegEvtPending ||
   5130         (true == m_bIntRawEvtPending)) {
   5131         //Waiting in HAL for snapshot taken notification
   5132         pthread_mutex_lock(&m_int_lock);
   5133         rc = pthread_cond_timedwait(&m_int_cond, &m_int_lock, &ts);
   5134         if (ETIMEDOUT == rc || 0x0 == m_BackendFileName[0]) {
   5135             //Hit a timeout, or some spurious activity
   5136             bSendToBackend = false;
   5137         }
   5138 
   5139         if (true == m_bIntJpegEvtPending) {
   5140             params.event_type = 0;
   5141             mParameters.getStreamFormat(CAM_STREAM_TYPE_SNAPSHOT, params.picture_format);
   5142         } else if (true == m_bIntRawEvtPending) {
   5143             params.event_type = 1;
   5144             mParameters.getStreamFormat(CAM_STREAM_TYPE_RAW, params.picture_format);
   5145         }
   5146         pthread_mutex_unlock(&m_int_lock);
   5147 
   5148         if (true == m_bIntJpegEvtPending) {
   5149             //Attempting to restart preview after taking JPEG snapshot
   5150             lockAPI();
   5151             rc = processAPI(QCAMERA_SM_EVT_SNAPSHOT_DONE, NULL);
   5152             unlockAPI();
   5153             m_postprocessor.setJpegMemOpt(JpegMemOpt);
   5154         } else if (true == m_bIntRawEvtPending) {
   5155             //Attempting to restart preview after taking RAW snapshot
   5156             stopChannel(QCAMERA_CH_TYPE_RAW);
   5157             delChannel(QCAMERA_CH_TYPE_RAW);
   5158             //restoring the old raw format
   5159             property_set("persist.camera.raw.format", raw_format);
   5160         }
   5161 
   5162         if (true == bSendToBackend) {
   5163             //send event back to server with the file path
   5164             params.dim = m_postprocessor.m_dst_dim;
   5165             memcpy(&params.path[0], &m_BackendFileName[0], QCAMERA_MAX_FILEPATH_LENGTH);
   5166             memset(&m_BackendFileName[0], 0x0, QCAMERA_MAX_FILEPATH_LENGTH);
   5167             params.size = mBackendFileSize;
   5168             rc = mParameters.setIntEvent(params);
   5169         }
   5170 
   5171         clearIntPendingEvents();
   5172     }
   5173 
   5174     return;
   5175 }
   5176 
   5177 /*===========================================================================
   5178  * FUNCTION   : takeBackendPic_internal
   5179  *
   5180  * DESCRIPTION: take snapshot triggered by backend
   5181  *
   5182  * PARAMETERS : none
   5183  *
   5184  * RETURN     : int32_t type of status
   5185  *              NO_ERROR  -- success
   5186  *              none-zero failure code
   5187  *==========================================================================*/
   5188 int QCamera2HardwareInterface::takeBackendPic_internal(bool *JpegMemOpt, char *raw_format)
   5189 {
   5190     int rc = NO_ERROR;
   5191     qcamera_api_result_t apiResult;
   5192 
   5193     lockAPI();
   5194     //Set rotation value from user settings as Jpeg rotation
   5195     //to configure back-end modules.
   5196     mParameters.setJpegRotation(mParameters.getRotation());
   5197 
   5198     setRetroPicture(0);
   5199     /* Prepare snapshot in case LED needs to be flashed */
   5200     if (mFlashNeeded == 1 || mParameters.isChromaFlashEnabled()) {
   5201         // Start Preparing for normal Frames
   5202         LOGH("Start Prepare Snapshot");
   5203         /* Prepare snapshot in case LED needs to be flashed */
   5204         rc = processAPI(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, NULL);
   5205         if (rc == NO_ERROR) {
   5206             waitAPIResult(QCAMERA_SM_EVT_PREPARE_SNAPSHOT, &apiResult);
   5207             rc = apiResult.status;
   5208         }
   5209         LOGH("Prep Snapshot done rc = %d", rc);
   5210         mPrepSnapRun = true;
   5211     }
   5212     unlockAPI();
   5213 
   5214     if (true == m_bIntJpegEvtPending) {
   5215         //Attempting to take JPEG snapshot
   5216         if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
   5217             LOGE("Init PProc Deferred work failed");
   5218             return UNKNOWN_ERROR;
   5219         }
   5220         *JpegMemOpt = m_postprocessor.getJpegMemOpt();
   5221         m_postprocessor.setJpegMemOpt(false);
   5222 
   5223         /* capture */
   5224         lockAPI();
   5225         LOGH("Capturing internal snapshot");
   5226         rc = processAPI(QCAMERA_SM_EVT_TAKE_PICTURE, NULL);
   5227         if (rc == NO_ERROR) {
   5228             waitAPIResult(QCAMERA_SM_EVT_TAKE_PICTURE, &apiResult);
   5229             rc = apiResult.status;
   5230         }
   5231         unlockAPI();
   5232     } else if (true == m_bIntRawEvtPending) {
   5233         //Attempting to take RAW snapshot
   5234         (void)JpegMemOpt;
   5235         stopPreview();
   5236 
   5237         //getting the existing raw format type
   5238         property_get("persist.camera.raw.format", raw_format, "17");
   5239         //setting it to a default know value for this task
   5240         property_set("persist.camera.raw.format", "18");
   5241 
   5242         rc = addChannel(QCAMERA_CH_TYPE_RAW);
   5243         if (rc == NO_ERROR) {
   5244             // start postprocessor
   5245             if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
   5246                 LOGE("Init PProc Deferred work failed");
   5247                 return UNKNOWN_ERROR;
   5248             }
   5249             rc = m_postprocessor.start(m_channels[QCAMERA_CH_TYPE_RAW]);
   5250             if (rc != NO_ERROR) {
   5251                 LOGE("cannot start postprocessor");
   5252                 delChannel(QCAMERA_CH_TYPE_RAW);
   5253                 return rc;
   5254             }
   5255 
   5256             rc = startChannel(QCAMERA_CH_TYPE_RAW);
   5257             if (rc != NO_ERROR) {
   5258                 LOGE("cannot start raw channel");
   5259                 m_postprocessor.stop();
   5260                 delChannel(QCAMERA_CH_TYPE_RAW);
   5261                 return rc;
   5262             }
   5263         } else {
   5264             LOGE("cannot add raw channel");
   5265             return rc;
   5266         }
   5267     }
   5268 
   5269     return rc;
   5270 }
   5271 
   5272 /*===========================================================================
   5273  * FUNCTION   : clearIntPendingEvents
   5274  *
   5275  * DESCRIPTION: clear internal pending events pertaining to backend
   5276  *                        snapshot requests
   5277  *
   5278  * PARAMETERS : none
   5279  *
   5280  * RETURN     : int32_t type of status
   5281  *              NO_ERROR  -- success
   5282  *              none-zero failure code
   5283  *==========================================================================*/
   5284 void QCamera2HardwareInterface::clearIntPendingEvents()
   5285 {
   5286     int rc = NO_ERROR;
   5287 
   5288     if (true == m_bIntRawEvtPending) {
   5289         preparePreview();
   5290         startPreview();
   5291     }
   5292     if (true == m_bIntJpegEvtPending) {
   5293         if (false == mParameters.isZSLMode()) {
   5294             lockAPI();
   5295             rc = processAPI(QCAMERA_SM_EVT_START_PREVIEW, NULL);
   5296             unlockAPI();
   5297         }
   5298     }
   5299 
   5300     pthread_mutex_lock(&m_int_lock);
   5301     if (true == m_bIntJpegEvtPending) {
   5302         m_bIntJpegEvtPending = false;
   5303     } else if (true == m_bIntRawEvtPending) {
   5304         m_bIntRawEvtPending = false;
   5305     }
   5306     pthread_mutex_unlock(&m_int_lock);
   5307     return;
   5308 }
   5309 
   5310 /*===========================================================================
   5311  * FUNCTION   : takeLiveSnapshot_internal
   5312  *
   5313  * DESCRIPTION: take live snapshot during recording
   5314  *
   5315  * PARAMETERS : none
   5316  *
   5317  * RETURN     : int32_t type of status
   5318  *              NO_ERROR  -- success
   5319  *              none-zero failure code
   5320  *==========================================================================*/
   5321 int QCamera2HardwareInterface::takeLiveSnapshot_internal()
   5322 {
   5323     int rc = NO_ERROR;
   5324 
   5325     QCameraChannel *pChannel = NULL;
   5326 
   5327     //Set rotation value from user settings as Jpeg rotation
   5328     //to configure back-end modules.
   5329     mParameters.setJpegRotation(mParameters.getRotation());
   5330 
   5331     // Configure advanced capture
   5332     rc = configureAdvancedCapture();
   5333     if (rc != NO_ERROR) {
   5334         LOGE("Unsupported capture call");
   5335         goto end;
   5336     }
   5337 
   5338     if (isLowPowerMode()) {
   5339         pChannel = m_channels[QCAMERA_CH_TYPE_VIDEO];
   5340     } else {
   5341         pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
   5342     }
   5343 
   5344     if (NULL == pChannel) {
   5345         LOGE("Snapshot/Video channel not initialized");
   5346         rc = NO_INIT;
   5347         goto end;
   5348     }
   5349 
   5350     DeferWorkArgs args;
   5351     memset(&args, 0, sizeof(DeferWorkArgs));
   5352 
   5353     args.pprocArgs = pChannel;
   5354 
   5355     // No need to wait for mInitPProcJob here, because it was
   5356     // queued in startPreview, and will definitely be processed before
   5357     // mReprocJob can begin.
   5358     mReprocJob = queueDeferredWork(CMD_DEF_PPROC_START,
   5359             args);
   5360     if (mReprocJob == 0) {
   5361         LOGE("Failed to queue CMD_DEF_PPROC_START");
   5362         rc = -ENOMEM;
   5363         goto end;
   5364     }
   5365 
   5366     // Create JPEG session
   5367     mJpegJob = queueDeferredWork(CMD_DEF_CREATE_JPEG_SESSION,
   5368             args);
   5369     if (mJpegJob == 0) {
   5370         LOGE("Failed to queue CREATE_JPEG_SESSION");
   5371         if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   5372             LOGE("Reprocess Deferred work was failed");
   5373         }
   5374         m_postprocessor.stop();
   5375         rc = -ENOMEM;
   5376         goto end;
   5377     }
   5378 
   5379     if (isLowPowerMode()) {
   5380         mm_camera_req_buf_t buf;
   5381         memset(&buf, 0x0, sizeof(buf));
   5382         buf.type = MM_CAMERA_REQ_SUPER_BUF;
   5383         buf.num_buf_requested = 1;
   5384         rc = ((QCameraVideoChannel*)pChannel)->takePicture(&buf);
   5385         goto end;
   5386     }
   5387 
   5388     //Disable reprocess for 4K liveshot case
   5389     if (!mParameters.is4k2kVideoResolution()) {
   5390         rc = configureOnlineRotation(*m_channels[QCAMERA_CH_TYPE_SNAPSHOT]);
   5391         if (rc != NO_ERROR) {
   5392             LOGE("online rotation failed");
   5393             if (NO_ERROR != waitDeferredWork(mReprocJob)) {
   5394                 LOGE("Reprocess Deferred work was failed");
   5395             }
   5396             if (NO_ERROR != waitDeferredWork(mJpegJob)) {
   5397                 LOGE("Jpeg Deferred work was failed");
   5398             }
   5399             m_postprocessor.stop();
   5400             return rc;
   5401         }
   5402     }
   5403 
   5404     if ((NULL != pChannel) && (mParameters.isTNRSnapshotEnabled())) {
   5405         QCameraStream *pStream = NULL;
   5406         for (uint32_t i = 0 ; i < pChannel->getNumOfStreams(); i++ ) {
   5407             pStream = pChannel->getStreamByIndex(i);
   5408             if ((NULL != pStream) &&
   5409                     (CAM_STREAM_TYPE_SNAPSHOT == pStream->getMyType())) {
   5410                 break;
   5411             }
   5412         }
   5413         if (pStream != NULL) {
   5414             LOGD("REQUEST_FRAMES event for TNR snapshot");
   5415             cam_stream_parm_buffer_t param;
   5416             memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
   5417             param.type = CAM_STREAM_PARAM_TYPE_REQUEST_FRAMES;
   5418             param.frameRequest.enableStream = 1;
   5419             rc = pStream->setParameter(param);
   5420             if (rc != NO_ERROR) {
   5421                 LOGE("Stream Event REQUEST_FRAMES failed");
   5422             }
   5423             goto end;
   5424         }
   5425     }
   5426 
   5427     // start snapshot channel
   5428     if ((rc == NO_ERROR) && (NULL != pChannel)) {
   5429         // Do not link metadata stream for 4K2k resolution
   5430         // as CPP processing would be done on snapshot stream and not
   5431         // reprocess stream
   5432         if (!mParameters.is4k2kVideoResolution()) {
   5433             // Find and try to link a metadata stream from preview channel
   5434             QCameraChannel *pMetaChannel = NULL;
   5435             QCameraStream *pMetaStream = NULL;
   5436             QCameraStream *pPreviewStream = NULL;
   5437 
   5438             if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
   5439                 pMetaChannel = m_channels[QCAMERA_CH_TYPE_PREVIEW];
   5440                 uint32_t streamNum = pMetaChannel->getNumOfStreams();
   5441                 QCameraStream *pStream = NULL;
   5442                 for (uint32_t i = 0 ; i < streamNum ; i++ ) {
   5443                     pStream = pMetaChannel->getStreamByIndex(i);
   5444                     if (NULL != pStream) {
   5445                         if (CAM_STREAM_TYPE_METADATA == pStream->getMyType()) {
   5446                             pMetaStream = pStream;
   5447                         } else if (CAM_STREAM_TYPE_PREVIEW == pStream->getMyType()) {
   5448                             pPreviewStream = pStream;
   5449                         }
   5450                     }
   5451                 }
   5452             }
   5453 
   5454             if ((NULL != pMetaChannel) && (NULL != pMetaStream)) {
   5455                 rc = pChannel->linkStream(pMetaChannel, pMetaStream);
   5456                 if (NO_ERROR != rc) {
   5457                     LOGE("Metadata stream link failed %d", rc);
   5458                 }
   5459             }
   5460             if ((NULL != pMetaChannel) && (NULL != pPreviewStream)) {
   5461                 rc = pChannel->linkStream(pMetaChannel, pPreviewStream);
   5462                 if (NO_ERROR != rc) {
   5463                     LOGE("Preview stream link failed %d", rc);
   5464                 }
   5465             }
   5466         }
   5467         rc = pChannel->start();
   5468     }
   5469 
   5470 end:
   5471     if (rc != NO_ERROR) {
   5472         rc = processAPI(QCAMERA_SM_EVT_CANCEL_PICTURE, NULL);
   5473         rc = sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
   5474     }
   5475     return rc;
   5476 }
   5477 
   5478 /*===========================================================================
   5479  * FUNCTION   : cancelLiveSnapshot
   5480  *
   5481  * DESCRIPTION: cancel current live snapshot request
   5482  *
   5483  * PARAMETERS : none
   5484  *
   5485  * RETURN     : int32_t type of status
   5486  *              NO_ERROR  -- success
   5487  *              none-zero failure code
   5488  *==========================================================================*/
   5489 int QCamera2HardwareInterface::cancelLiveSnapshot()
   5490 {
   5491     int rc = NO_ERROR;
   5492     if (mLiveSnapshotThread != 0) {
   5493         pthread_join(mLiveSnapshotThread,NULL);
   5494         mLiveSnapshotThread = 0;
   5495     }
   5496     bLiveSnapshot = false;
   5497     rc= pthread_create(&mLiveSnapshotThread, NULL, Live_Snapshot_thread, (void *) this);
   5498     if (!rc) {
   5499         pthread_setname_np(mLiveSnapshotThread, "CAM_cancel_liveSnap");
   5500     }
   5501     return rc;
   5502 }
   5503 
   5504 /*===========================================================================
   5505  * FUNCTION   : cancelLiveSnapshot_internal
   5506  *
   5507  * DESCRIPTION: cancel live snapshot during recording
   5508  *
   5509  * PARAMETERS : none
   5510  *
   5511  * RETURN     : int32_t type of status
   5512  *              NO_ERROR  -- success
   5513  *              none-zero failure code
   5514  *==========================================================================*/
   5515 int QCamera2HardwareInterface::cancelLiveSnapshot_internal() {
   5516     int rc = NO_ERROR;
   5517 
   5518     unconfigureAdvancedCapture();
   5519     LOGH("Enable display frames again");
   5520     setDisplaySkip(FALSE);
   5521 
   5522     if (!mLongshotEnabled) {
   5523         m_perfLock.lock_rel();
   5524     }
   5525 
   5526     //stop post processor
   5527     m_postprocessor.stop();
   5528 
   5529     // stop snapshot channel
   5530     if (!mParameters.isTNRSnapshotEnabled()) {
   5531         rc = stopChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   5532     } else {
   5533         QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
   5534         if (NULL != pChannel) {
   5535             QCameraStream *pStream = NULL;
   5536             for (uint32_t i = 0 ; i < pChannel->getNumOfStreams(); i++ ) {
   5537                 pStream = pChannel->getStreamByIndex(i);
   5538                 if ((NULL != pStream) &&
   5539                         (CAM_STREAM_TYPE_SNAPSHOT ==
   5540                         pStream->getMyType())) {
   5541                     break;
   5542                 }
   5543             }
   5544             if (pStream != NULL) {
   5545                 LOGD("REQUEST_FRAMES event for TNR snapshot");
   5546                 cam_stream_parm_buffer_t param;
   5547                 memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
   5548                 param.type = CAM_STREAM_PARAM_TYPE_REQUEST_FRAMES;
   5549                 param.frameRequest.enableStream = 0;
   5550                 rc = pStream->setParameter(param);
   5551                 if (rc != NO_ERROR) {
   5552                     LOGE("Stream Event REQUEST_FRAMES failed");
   5553                 }
   5554             }
   5555         }
   5556     }
   5557 
   5558     return rc;
   5559 }
   5560 
   5561 /*===========================================================================
   5562  * FUNCTION   : putParameters
   5563  *
   5564  * DESCRIPTION: put parameters string impl
   5565  *
   5566  * PARAMETERS :
   5567  *   @parms   : parameters string to be released
   5568  *
   5569  * RETURN     : int32_t type of status
   5570  *              NO_ERROR  -- success
   5571  *              none-zero failure code
   5572  *==========================================================================*/
   5573 int QCamera2HardwareInterface::putParameters(char *parms)
   5574 {
   5575     free(parms);
   5576     return NO_ERROR;
   5577 }
   5578 
   5579 /*===========================================================================
   5580  * FUNCTION   : sendCommand
   5581  *
   5582  * DESCRIPTION: send command impl
   5583  *
   5584  * PARAMETERS :
   5585  *   @command : command to be executed
   5586  *   @arg1    : optional argument 1
   5587  *   @arg2    : optional argument 2
   5588  *
   5589  * RETURN     : int32_t type of status
   5590  *              NO_ERROR  -- success
   5591  *              none-zero failure code
   5592  *==========================================================================*/
   5593 int QCamera2HardwareInterface::sendCommand(int32_t command,
   5594         __unused int32_t &arg1, __unused int32_t &arg2)
   5595 {
   5596     int rc = NO_ERROR;
   5597 
   5598     switch (command) {
   5599 #ifndef VANILLA_HAL
   5600     case CAMERA_CMD_LONGSHOT_ON:
   5601         m_perfLock.lock_acq();
   5602         arg1 = arg2 = 0;
   5603         // Longshot can only be enabled when image capture
   5604         // is not active.
   5605         if ( !m_stateMachine.isCaptureRunning() ) {
   5606             LOGI("Longshot Enabled");
   5607             mLongshotEnabled = true;
   5608             rc = mParameters.setLongshotEnable(mLongshotEnabled);
   5609 
   5610             // Due to recent buffer count optimizations
   5611             // ZSL might run with considerably less buffers
   5612             // when not in longshot mode. Preview needs to
   5613             // restart in this case.
   5614             if (isZSLMode() && m_stateMachine.isPreviewRunning()) {
   5615                 QCameraChannel *pChannel = NULL;
   5616                 QCameraStream *pSnapStream = NULL;
   5617                 pChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
   5618                 if (NULL != pChannel) {
   5619                     QCameraStream *pStream = NULL;
   5620                     for (uint32_t i = 0; i < pChannel->getNumOfStreams(); i++) {
   5621                         pStream = pChannel->getStreamByIndex(i);
   5622                         if (pStream != NULL) {
   5623                             if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
   5624                                 pSnapStream = pStream;
   5625                                 break;
   5626                             }
   5627                         }
   5628                     }
   5629                     if (NULL != pSnapStream) {
   5630                         uint8_t required = 0;
   5631                         required = getBufNumRequired(CAM_STREAM_TYPE_SNAPSHOT);
   5632                         if (pSnapStream->getBufferCount() < required) {
   5633                             // We restart here, to reset the FPS and no
   5634                             // of buffers as per the requirement of longshot usecase.
   5635                             arg1 = QCAMERA_SM_EVT_RESTART_PERVIEW;
   5636                             if (getRelatedCamSyncInfo()->sync_control ==
   5637                                     CAM_SYNC_RELATED_SENSORS_ON) {
   5638                                 arg2 = QCAMERA_SM_EVT_DELAYED_RESTART;
   5639                             }
   5640                         }
   5641                     }
   5642                 }
   5643             }
   5644             //
   5645             mPrepSnapRun = false;
   5646             mCACDoneReceived = FALSE;
   5647         } else {
   5648             rc = NO_INIT;
   5649         }
   5650         break;
   5651     case CAMERA_CMD_LONGSHOT_OFF:
   5652         m_perfLock.lock_rel();
   5653         if ( mLongshotEnabled && m_stateMachine.isCaptureRunning() ) {
   5654             cancelPicture();
   5655             processEvt(QCAMERA_SM_EVT_SNAPSHOT_DONE, NULL);
   5656             QCameraChannel *pZSLChannel = m_channels[QCAMERA_CH_TYPE_ZSL];
   5657             if (isZSLMode() && (NULL != pZSLChannel) && mPrepSnapRun) {
   5658                 mCameraHandle->ops->stop_zsl_snapshot(
   5659                         mCameraHandle->camera_handle,
   5660                         pZSLChannel->getMyHandle());
   5661             }
   5662         }
   5663         mPrepSnapRun = false;
   5664         LOGI("Longshot Disabled");
   5665         mLongshotEnabled = false;
   5666         rc = mParameters.setLongshotEnable(mLongshotEnabled);
   5667         mCACDoneReceived = FALSE;
   5668         break;
   5669     case CAMERA_CMD_HISTOGRAM_ON:
   5670     case CAMERA_CMD_HISTOGRAM_OFF:
   5671         rc = setHistogram(command == CAMERA_CMD_HISTOGRAM_ON? true : false);
   5672         LOGH("Histogram -> %s",
   5673               mParameters.isHistogramEnabled() ? "Enabled" : "Disabled");
   5674         break;
   5675 #endif
   5676     case CAMERA_CMD_START_FACE_DETECTION:
   5677     case CAMERA_CMD_STOP_FACE_DETECTION:
   5678         mParameters.setFaceDetectionOption(command == CAMERA_CMD_START_FACE_DETECTION? true : false);
   5679         rc = setFaceDetection(command == CAMERA_CMD_START_FACE_DETECTION? true : false);
   5680         LOGH("FaceDetection -> %s",
   5681               mParameters.isFaceDetectionEnabled() ? "Enabled" : "Disabled");
   5682         break;
   5683 #ifndef VANILLA_HAL
   5684     case CAMERA_CMD_HISTOGRAM_SEND_DATA:
   5685 #endif
   5686     default:
   5687         rc = NO_ERROR;
   5688         break;
   5689     }
   5690     return rc;
   5691 }
   5692 
   5693 /*===========================================================================
   5694  * FUNCTION   : registerFaceImage
   5695  *
   5696  * DESCRIPTION: register face image impl
   5697  *
   5698  * PARAMETERS :
   5699  *   @img_ptr : ptr to image buffer
   5700  *   @config  : ptr to config struct about input image info
   5701  *   @faceID  : [OUT] face ID to uniquely identifiy the registered face image
   5702  *
   5703  * RETURN     : int32_t type of status
   5704  *              NO_ERROR  -- success
   5705  *              none-zero failure code
   5706  *==========================================================================*/
   5707 int QCamera2HardwareInterface::registerFaceImage(void *img_ptr,
   5708                                                  cam_pp_offline_src_config_t *config,
   5709                                                  int32_t &faceID)
   5710 {
   5711     int rc = NO_ERROR;
   5712     faceID = -1;
   5713 
   5714     if (img_ptr == NULL || config == NULL) {
   5715         LOGE("img_ptr or config is NULL");
   5716         return BAD_VALUE;
   5717     }
   5718 
   5719     // allocate ion memory for source image
   5720     QCameraHeapMemory *imgBuf = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
   5721     if (imgBuf == NULL) {
   5722         LOGE("Unable to new heap memory obj for image buf");
   5723         return NO_MEMORY;
   5724     }
   5725 
   5726     rc = imgBuf->allocate(1, config->input_buf_planes.plane_info.frame_len, NON_SECURE);
   5727     if (rc < 0) {
   5728         LOGE("Unable to allocate heap memory for image buf");
   5729         delete imgBuf;
   5730         return NO_MEMORY;
   5731     }
   5732 
   5733     void *pBufPtr = imgBuf->getPtr(0);
   5734     if (pBufPtr == NULL) {
   5735         LOGE("image buf is NULL");
   5736         imgBuf->deallocate();
   5737         delete imgBuf;
   5738         return NO_MEMORY;
   5739     }
   5740     memcpy(pBufPtr, img_ptr, config->input_buf_planes.plane_info.frame_len);
   5741 
   5742     cam_pp_feature_config_t pp_feature;
   5743     memset(&pp_feature, 0, sizeof(cam_pp_feature_config_t));
   5744     pp_feature.feature_mask = CAM_QCOM_FEATURE_REGISTER_FACE;
   5745     QCameraReprocessChannel *pChannel =
   5746         addOfflineReprocChannel(*config, pp_feature, NULL, NULL);
   5747 
   5748     if (pChannel == NULL) {
   5749         LOGE("fail to add offline reprocess channel");
   5750         imgBuf->deallocate();
   5751         delete imgBuf;
   5752         return UNKNOWN_ERROR;
   5753     }
   5754 
   5755     rc = pChannel->start();
   5756     if (rc != NO_ERROR) {
   5757         LOGE("Cannot start reprocess channel");
   5758         imgBuf->deallocate();
   5759         delete imgBuf;
   5760         delete pChannel;
   5761         return rc;
   5762     }
   5763 
   5764     ssize_t bufSize = imgBuf->getSize(0);
   5765     if (BAD_INDEX != bufSize) {
   5766         rc = pChannel->doReprocess(imgBuf->getFd(0), imgBuf->getPtr(0),
   5767                 (size_t)bufSize, faceID);
   5768     } else {
   5769         LOGE("Failed to retrieve buffer size (bad index)");
   5770         return UNKNOWN_ERROR;
   5771     }
   5772 
   5773     // done with register face image, free imgbuf and delete reprocess channel
   5774     imgBuf->deallocate();
   5775     delete imgBuf;
   5776     imgBuf = NULL;
   5777     pChannel->stop();
   5778     delete pChannel;
   5779     pChannel = NULL;
   5780 
   5781     return rc;
   5782 }
   5783 
   5784 /*===========================================================================
   5785  * FUNCTION   : release
   5786  *
   5787  * DESCRIPTION: release camera resource impl
   5788  *
   5789  * PARAMETERS : none
   5790  *
   5791  * RETURN     : int32_t type of status
   5792  *              NO_ERROR  -- success
   5793  *              none-zero failure code
   5794  *==========================================================================*/
   5795 int QCamera2HardwareInterface::release()
   5796 {
   5797     // stop and delete all channels
   5798     for (int i = 0; i <QCAMERA_CH_TYPE_MAX ; i++) {
   5799         if (m_channels[i] != NULL) {
   5800             stopChannel((qcamera_ch_type_enum_t)i);
   5801             delChannel((qcamera_ch_type_enum_t)i);
   5802         }
   5803     }
   5804 
   5805     return NO_ERROR;
   5806 }
   5807 
   5808 /*===========================================================================
   5809  * FUNCTION   : dump
   5810  *
   5811  * DESCRIPTION: camera status dump impl
   5812  *
   5813  * PARAMETERS :
   5814  *   @fd      : fd for the buffer to be dumped with camera status
   5815  *
   5816  * RETURN     : int32_t type of status
   5817  *              NO_ERROR  -- success
   5818  *              none-zero failure code
   5819  *==========================================================================*/
   5820 int QCamera2HardwareInterface::dump(int fd)
   5821 {
   5822     dprintf(fd, "\n Camera HAL information Begin \n");
   5823     dprintf(fd, "Camera ID: %d \n", mCameraId);
   5824     dprintf(fd, "StoreMetaDataInFrame: %d \n", mStoreMetaDataInFrame);
   5825     dprintf(fd, "\n Configuration: %s", mParameters.dump().string());
   5826     dprintf(fd, "\n State Information: %s", m_stateMachine.dump().string());
   5827     dprintf(fd, "\n Camera HAL information End \n");
   5828 
   5829     /* send UPDATE_DEBUG_LEVEL to the backend so that they can read the
   5830        debug level property */
   5831     mParameters.updateDebugLevel();
   5832     return NO_ERROR;
   5833 }
   5834 
   5835 /*===========================================================================
   5836  * FUNCTION   : processAPI
   5837  *
   5838  * DESCRIPTION: process API calls from upper layer
   5839  *
   5840  * PARAMETERS :
   5841  *   @api         : API to be processed
   5842  *   @api_payload : ptr to API payload if any
   5843  *
   5844  * RETURN     : int32_t type of status
   5845  *              NO_ERROR  -- success
   5846  *              none-zero failure code
   5847  *==========================================================================*/
   5848 int QCamera2HardwareInterface::processAPI(qcamera_sm_evt_enum_t api, void *api_payload)
   5849 {
   5850     int ret = DEAD_OBJECT;
   5851 
   5852     if (m_smThreadActive) {
   5853         ret = m_stateMachine.procAPI(api, api_payload);
   5854     }
   5855 
   5856     return ret;
   5857 }
   5858 
   5859 /*===========================================================================
   5860  * FUNCTION   : processEvt
   5861  *
   5862  * DESCRIPTION: process Evt from backend via mm-camera-interface
   5863  *
   5864  * PARAMETERS :
   5865  *   @evt         : event type to be processed
   5866  *   @evt_payload : ptr to event payload if any
   5867  *
   5868  * RETURN     : int32_t type of status
   5869  *              NO_ERROR  -- success
   5870  *              none-zero failure code
   5871  *==========================================================================*/
   5872 int QCamera2HardwareInterface::processEvt(qcamera_sm_evt_enum_t evt, void *evt_payload)
   5873 {
   5874     return m_stateMachine.procEvt(evt, evt_payload);
   5875 }
   5876 
   5877 /*===========================================================================
   5878  * FUNCTION   : processSyncEvt
   5879  *
   5880  * DESCRIPTION: process synchronous Evt from backend
   5881  *
   5882  * PARAMETERS :
   5883  *   @evt         : event type to be processed
   5884  *   @evt_payload : ptr to event payload if any
   5885  *
   5886  * RETURN     : int32_t type of status
   5887  *              NO_ERROR  -- success
   5888  *              none-zero failure code
   5889  *==========================================================================*/
   5890 int QCamera2HardwareInterface::processSyncEvt(qcamera_sm_evt_enum_t evt, void *evt_payload)
   5891 {
   5892     int rc = NO_ERROR;
   5893 
   5894     pthread_mutex_lock(&m_evtLock);
   5895     rc =  processEvt(evt, evt_payload);
   5896     if (rc == NO_ERROR) {
   5897         memset(&m_evtResult, 0, sizeof(qcamera_api_result_t));
   5898         while (m_evtResult.request_api != evt) {
   5899             pthread_cond_wait(&m_evtCond, &m_evtLock);
   5900         }
   5901         rc =  m_evtResult.status;
   5902     }
   5903     pthread_mutex_unlock(&m_evtLock);
   5904 
   5905     return rc;
   5906 }
   5907 
   5908 /*===========================================================================
   5909  * FUNCTION   : evtHandle
   5910  *
   5911  * DESCRIPTION: Function registerd to mm-camera-interface to handle backend events
   5912  *
   5913  * PARAMETERS :
   5914  *   @camera_handle : event type to be processed
   5915  *   @evt           : ptr to event
   5916  *   @user_data     : user data ptr
   5917  *
   5918  * RETURN     : none
   5919  *==========================================================================*/
   5920 void QCamera2HardwareInterface::camEvtHandle(uint32_t /*camera_handle*/,
   5921                                           mm_camera_event_t *evt,
   5922                                           void *user_data)
   5923 {
   5924     QCamera2HardwareInterface *obj = (QCamera2HardwareInterface *)user_data;
   5925     if (obj && evt) {
   5926         mm_camera_event_t *payload =
   5927             (mm_camera_event_t *)malloc(sizeof(mm_camera_event_t));
   5928         if (NULL != payload) {
   5929             *payload = *evt;
   5930             //peek into the event, if this is an eztune event from server,
   5931             //then we don't need to post it to the SM Qs, we shud directly
   5932             //spawn a thread and get the job done (jpeg or raw snapshot)
   5933             switch (payload->server_event_type) {
   5934                 case CAM_EVENT_TYPE_INT_TAKE_JPEG:
   5935                     //Received JPEG trigger from eztune
   5936                     if (false == obj->m_bIntJpegEvtPending) {
   5937                         pthread_mutex_lock(&obj->m_int_lock);
   5938                         obj->m_bIntJpegEvtPending = true;
   5939                         pthread_mutex_unlock(&obj->m_int_lock);
   5940                         obj->takePictureInternal();
   5941                     }
   5942                     free(payload);
   5943                     break;
   5944                 case CAM_EVENT_TYPE_INT_TAKE_RAW:
   5945                     //Received RAW trigger from eztune
   5946                     if (false == obj->m_bIntRawEvtPending) {
   5947                         pthread_mutex_lock(&obj->m_int_lock);
   5948                         obj->m_bIntRawEvtPending = true;
   5949                         pthread_mutex_unlock(&obj->m_int_lock);
   5950                         obj->takePictureInternal();
   5951                     }
   5952                     free(payload);
   5953                     break;
   5954                 case CAM_EVENT_TYPE_DAEMON_DIED:
   5955                     {
   5956                         Mutex::Autolock l(obj->mDefLock);
   5957                         obj->mDefCond.broadcast();
   5958                         LOGH("broadcast mDefCond signal\n");
   5959                     }
   5960                 default:
   5961                     obj->processEvt(QCAMERA_SM_EVT_EVT_NOTIFY, payload);
   5962                     break;
   5963             }
   5964         }
   5965     } else {
   5966         LOGE("NULL user_data");
   5967     }
   5968 }
   5969 
   5970 /*===========================================================================
   5971  * FUNCTION   : jpegEvtHandle
   5972  *
   5973  * DESCRIPTION: Function registerd to mm-jpeg-interface to handle jpeg events
   5974  *
   5975  * PARAMETERS :
   5976  *   @status    : status of jpeg job
   5977  *   @client_hdl: jpeg client handle
   5978  *   @jobId     : jpeg job Id
   5979  *   @p_ouput   : ptr to jpeg output result struct
   5980  *   @userdata  : user data ptr
   5981  *
   5982  * RETURN     : none
   5983  *==========================================================================*/
   5984 void QCamera2HardwareInterface::jpegEvtHandle(jpeg_job_status_t status,
   5985                                               uint32_t /*client_hdl*/,
   5986                                               uint32_t jobId,
   5987                                               mm_jpeg_output_t *p_output,
   5988                                               void *userdata)
   5989 {
   5990     QCamera2HardwareInterface *obj = (QCamera2HardwareInterface *)userdata;
   5991     if (obj) {
   5992         qcamera_jpeg_evt_payload_t *payload =
   5993             (qcamera_jpeg_evt_payload_t *)malloc(sizeof(qcamera_jpeg_evt_payload_t));
   5994         if (NULL != payload) {
   5995             memset(payload, 0, sizeof(qcamera_jpeg_evt_payload_t));
   5996             payload->status = status;
   5997             payload->jobId = jobId;
   5998             if (p_output != NULL) {
   5999                 payload->out_data = *p_output;
   6000             }
   6001             obj->processEvt(QCAMERA_SM_EVT_JPEG_EVT_NOTIFY, payload);
   6002         }
   6003     } else {
   6004         LOGE("NULL user_data");
   6005     }
   6006 }
   6007 
   6008 /*===========================================================================
   6009  * FUNCTION   : thermalEvtHandle
   6010  *
   6011  * DESCRIPTION: routine to handle thermal event notification
   6012  *
   6013  * PARAMETERS :
   6014  *   @level      : thermal level
   6015  *   @userdata   : userdata passed in during registration
   6016  *   @data       : opaque data from thermal client
   6017  *
   6018  * RETURN     : int32_t type of status
   6019  *              NO_ERROR  -- success
   6020  *              none-zero failure code
   6021  *==========================================================================*/
   6022 int QCamera2HardwareInterface::thermalEvtHandle(
   6023         qcamera_thermal_level_enum_t *level, void *userdata, void *data)
   6024 {
   6025     if (!mCameraOpened) {
   6026         LOGH("Camera is not opened, no need to handle thermal evt");
   6027         return NO_ERROR;
   6028     }
   6029 
   6030     // Make sure thermal events are logged
   6031     LOGH("level = %d, userdata = %p, data = %p",
   6032          *level, userdata, data);
   6033     //We don't need to lockAPI, waitAPI here. QCAMERA_SM_EVT_THERMAL_NOTIFY
   6034     // becomes an aync call. This also means we can only pass payload
   6035     // by value, not by address.
   6036     return processAPI(QCAMERA_SM_EVT_THERMAL_NOTIFY, (void *)level);
   6037 }
   6038 
   6039 /*===========================================================================
   6040  * FUNCTION   : sendEvtNotify
   6041  *
   6042  * DESCRIPTION: send event notify to notify thread
   6043  *
   6044  * PARAMETERS :
   6045  *   @msg_type: msg type to be sent
   6046  *   @ext1    : optional extension1
   6047  *   @ext2    : optional extension2
   6048  *
   6049  * RETURN     : int32_t type of status
   6050  *              NO_ERROR  -- success
   6051  *              none-zero failure code
   6052  *==========================================================================*/
   6053 int32_t QCamera2HardwareInterface::sendEvtNotify(int32_t msg_type,
   6054                                                  int32_t ext1,
   6055                                                  int32_t ext2)
   6056 {
   6057     qcamera_callback_argm_t cbArg;
   6058     memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   6059     cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
   6060     cbArg.msg_type = msg_type;
   6061     cbArg.ext1 = ext1;
   6062     cbArg.ext2 = ext2;
   6063     return m_cbNotifier.notifyCallback(cbArg);
   6064 }
   6065 
   6066 /*===========================================================================
   6067  * FUNCTION   : processAEInfo
   6068  *
   6069  * DESCRIPTION: process AE updates
   6070  *
   6071  * PARAMETERS :
   6072  *   @ae_params: current AE parameters
   6073  *
   6074  * RETURN     : None
   6075  *==========================================================================*/
   6076 int32_t QCamera2HardwareInterface::processAEInfo(cam_3a_params_t &ae_params)
   6077 {
   6078     mParameters.updateAEInfo(ae_params);
   6079     if (mParameters.isInstantAECEnabled()) {
   6080         // Reset Instant AEC info only if instant aec enabled.
   6081         bool bResetInstantAec = false;
   6082         if (ae_params.settled) {
   6083             // If AEC settled, reset instant AEC
   6084             bResetInstantAec = true;
   6085         } else if ((mParameters.isInstantCaptureEnabled()) &&
   6086                 (mInstantAecFrameCount >= mParameters.getAecFrameBoundValue())) {
   6087             // if AEC not settled, and instant capture enabled,
   6088             // reset instant AEC only when frame count is
   6089             // more or equal to AEC frame bound value.
   6090             bResetInstantAec = true;
   6091         } else if ((mParameters.isInstantAECEnabled()) &&
   6092                 (mInstantAecFrameCount >= mParameters.getAecSkipDisplayFrameBound())) {
   6093             // if AEC not settled, and only instant AEC enabled,
   6094             // reset instant AEC only when frame count is
   6095             // more or equal to AEC skip display frame bound value.
   6096             bResetInstantAec = true;
   6097         }
   6098 
   6099         if (bResetInstantAec) {
   6100             LOGD("setting instant AEC to false");
   6101             mParameters.setInstantAEC(false, true);
   6102             mInstantAecFrameCount = 0;
   6103         }
   6104     }
   6105     return NO_ERROR;
   6106 }
   6107 
   6108 /*===========================================================================
   6109  * FUNCTION   : processFocusPositionInfo
   6110  *
   6111  * DESCRIPTION: process AF updates
   6112  *
   6113  * PARAMETERS :
   6114  *   @cur_pos_info: current lens position
   6115  *
   6116  * RETURN     : None
   6117  *==========================================================================*/
   6118 int32_t QCamera2HardwareInterface::processFocusPositionInfo(cam_focus_pos_info_t &cur_pos_info)
   6119 {
   6120     mParameters.updateCurrentFocusPosition(cur_pos_info);
   6121     return NO_ERROR;
   6122 }
   6123 
   6124 /*===========================================================================
   6125  * FUNCTION   : processAutoFocusEvent
   6126  *
   6127  * DESCRIPTION: process auto focus event
   6128  *
   6129  * PARAMETERS :
   6130  *   @focus_data: struct containing auto focus result info
   6131  *
   6132  * RETURN     : int32_t type of status
   6133  *              NO_ERROR  -- success
   6134  *              none-zero failure code
   6135  *==========================================================================*/
   6136 int32_t QCamera2HardwareInterface::processAutoFocusEvent(cam_auto_focus_data_t &focus_data)
   6137 {
   6138     int32_t ret = NO_ERROR;
   6139     LOGH("E");
   6140 
   6141     if (getRelatedCamSyncInfo()->mode == CAM_MODE_SECONDARY) {
   6142         // Ignore focus updates
   6143         LOGH("X Secondary Camera, no need to process!! ");
   6144         return ret;
   6145     }
   6146     cam_focus_mode_type focusMode = mParameters.getFocusMode();
   6147     LOGH("[AF_DBG]  focusMode=%d, focusState=%d",
   6148              focusMode, focus_data.focus_state);
   6149 
   6150     switch (focusMode) {
   6151     case CAM_FOCUS_MODE_AUTO:
   6152     case CAM_FOCUS_MODE_MACRO:
   6153         // ignore AF event if AF was already cancelled meanwhile
   6154         if (!mActiveAF) {
   6155             break;
   6156         }
   6157         // If the HAL focus mode is different from AF INFINITY focus mode, send event to app
   6158         if ((focus_data.focus_mode == CAM_FOCUS_MODE_INFINITY) &&
   6159                 (focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
   6160             ret = sendEvtNotify(CAMERA_MSG_FOCUS, true, 0);
   6161             mActiveAF = false; // reset the mActiveAF in this special case
   6162             break;
   6163         }
   6164 
   6165         //while transitioning from CAF->Auto/Macro, we might receive CAF related
   6166         //events (PASSIVE_*) due to timing. Ignore such events if any.
   6167         if ((focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN) ||
   6168                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
   6169                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED)) {
   6170             break;
   6171         }
   6172 
   6173         //This is just an intermediate update to HAL indicating focus is in progress. No need
   6174         //to send this event to app. Same applies to INACTIVE state as well.
   6175         if ((focus_data.focus_state == CAM_AF_STATE_ACTIVE_SCAN) ||
   6176                 (focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
   6177             break;
   6178         }
   6179         // update focus distance
   6180         mParameters.updateFocusDistances(&focus_data.focus_dist);
   6181 
   6182         //flush any old snapshot frames in ZSL Q which are not focused.
   6183         if (mParameters.isZSLMode() && focus_data.flush_info.needFlush ) {
   6184             QCameraPicChannel *pZSLChannel =
   6185                     (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
   6186             if (NULL != pZSLChannel) {
   6187                 //flush the zsl-buffer
   6188                 uint32_t flush_frame_idx = focus_data.flush_info.focused_frame_idx;
   6189                 LOGD("flush the zsl-buffer before frame = %u.", flush_frame_idx);
   6190                 pZSLChannel->flushSuperbuffer(flush_frame_idx);
   6191             }
   6192         }
   6193 
   6194         //send event to app finally
   6195         LOGI("Send AF DOne event to app");
   6196         ret = sendEvtNotify(CAMERA_MSG_FOCUS,
   6197                             (focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED), 0);
   6198         break;
   6199     case CAM_FOCUS_MODE_CONTINOUS_VIDEO:
   6200     case CAM_FOCUS_MODE_CONTINOUS_PICTURE:
   6201 
   6202         // If the HAL focus mode is different from AF INFINITY focus mode, send event to app
   6203         if ((focus_data.focus_mode == CAM_FOCUS_MODE_INFINITY) &&
   6204                 (focus_data.focus_state == CAM_AF_STATE_INACTIVE)) {
   6205             ret = sendEvtNotify(CAMERA_MSG_FOCUS, false, 0);
   6206             mActiveAF = false; // reset the mActiveAF in this special case
   6207             break;
   6208         }
   6209 
   6210         //If AutoFocus() is triggered while in CAF mode, ignore all CAF events (PASSIVE_*) and
   6211         //process/wait for only ACTIVE_* events.
   6212         if (((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
   6213                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED) ||
   6214                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN)) && mActiveAF) {
   6215             break;
   6216         }
   6217 
   6218         //These are the AF states for which we need to send notification to app in CAF mode.
   6219         //This includes both regular CAF (PASSIVE) events as well as ACTIVE events ( in case
   6220         //AF is triggered while in CAF mode)
   6221         if ((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
   6222                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_UNFOCUSED) ||
   6223                 (focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED) ||
   6224                 (focus_data.focus_state == CAM_AF_STATE_NOT_FOCUSED_LOCKED)) {
   6225 
   6226             // update focus distance
   6227             mParameters.updateFocusDistances(&focus_data.focus_dist);
   6228 
   6229             if (mParameters.isZSLMode() && focus_data.flush_info.needFlush ) {
   6230                 QCameraPicChannel *pZSLChannel =
   6231                         (QCameraPicChannel *)m_channels[QCAMERA_CH_TYPE_ZSL];
   6232                 if (NULL != pZSLChannel) {
   6233                     //flush the zsl-buffer
   6234                     uint32_t flush_frame_idx = focus_data.flush_info.focused_frame_idx;
   6235                     LOGD("flush the zsl-buffer before frame = %u.", flush_frame_idx);
   6236                     pZSLChannel->flushSuperbuffer(flush_frame_idx);
   6237                 }
   6238             }
   6239 
   6240             if (mActiveAF) {
   6241                 LOGI("Send AF Done event to app");
   6242             }
   6243             ret = sendEvtNotify(CAMERA_MSG_FOCUS,
   6244                     ((focus_data.focus_state == CAM_AF_STATE_PASSIVE_FOCUSED) ||
   6245                     (focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED)), 0);
   6246         }
   6247         ret = sendEvtNotify(CAMERA_MSG_FOCUS_MOVE,
   6248                 (focus_data.focus_state == CAM_AF_STATE_PASSIVE_SCAN), 0);
   6249         break;
   6250     case CAM_FOCUS_MODE_INFINITY:
   6251     case CAM_FOCUS_MODE_FIXED:
   6252     case CAM_FOCUS_MODE_EDOF:
   6253     default:
   6254         LOGH("no ops for autofocus event in focusmode %d", focusMode);
   6255         break;
   6256     }
   6257 
   6258     //Reset mActiveAF once we receive focus done event
   6259     if ((focus_data.focus_state == CAM_AF_STATE_FOCUSED_LOCKED) ||
   6260             (focus_data.focus_state == CAM_AF_STATE_NOT_FOCUSED_LOCKED)) {
   6261         mActiveAF = false;
   6262     }
   6263 
   6264     LOGH("X");
   6265     return ret;
   6266 }
   6267 
   6268 /*===========================================================================
   6269  * FUNCTION   : processZoomEvent
   6270  *
   6271  * DESCRIPTION: process zoom event
   6272  *
   6273  * PARAMETERS :
   6274  *   @crop_info : crop info as a result of zoom operation
   6275  *
   6276  * RETURN     : int32_t type of status
   6277  *              NO_ERROR  -- success
   6278  *              none-zero failure code
   6279  *==========================================================================*/
   6280 int32_t QCamera2HardwareInterface::processZoomEvent(cam_crop_data_t &crop_info)
   6281 {
   6282     int32_t ret = NO_ERROR;
   6283 
   6284     for (int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
   6285         if (m_channels[i] != NULL) {
   6286             ret = m_channels[i]->processZoomDone(mPreviewWindow, crop_info);
   6287         }
   6288     }
   6289     return ret;
   6290 }
   6291 
   6292 /*===========================================================================
   6293  * FUNCTION   : processZSLCaptureDone
   6294  *
   6295  * DESCRIPTION: process ZSL capture done events
   6296  *
   6297  * PARAMETERS : None
   6298  *
   6299  * RETURN     : int32_t type of status
   6300  *              NO_ERROR  -- success
   6301  *              none-zero failure code
   6302  *==========================================================================*/
   6303 int32_t QCamera2HardwareInterface::processZSLCaptureDone()
   6304 {
   6305     int rc = NO_ERROR;
   6306 
   6307     if (++mInputCount >= mParameters.getBurstCountForAdvancedCapture()) {
   6308         rc = unconfigureAdvancedCapture();
   6309     }
   6310 
   6311     return rc;
   6312 }
   6313 
   6314 /*===========================================================================
   6315  * FUNCTION   : processRetroAECUnlock
   6316  *
   6317  * DESCRIPTION: process retro burst AEC unlock events
   6318  *
   6319  * PARAMETERS : None
   6320  *
   6321  * RETURN     : int32_t type of status
   6322  *              NO_ERROR  -- success
   6323  *              none-zero failure code
   6324  *==========================================================================*/
   6325 int32_t QCamera2HardwareInterface::processRetroAECUnlock()
   6326 {
   6327     int rc = NO_ERROR;
   6328 
   6329     LOGH("LED assisted AF Release AEC Lock");
   6330     rc = mParameters.setAecLock("false");
   6331     if (NO_ERROR != rc) {
   6332         LOGE("Error setting AEC lock");
   6333         return rc;
   6334     }
   6335 
   6336     rc = mParameters.commitParameters();
   6337     if (NO_ERROR != rc) {
   6338         LOGE("Error during camera parameter commit");
   6339     } else {
   6340         m_bLedAfAecLock = FALSE;
   6341     }
   6342 
   6343     return rc;
   6344 }
   6345 
   6346 /*===========================================================================
   6347  * FUNCTION   : processHDRData
   6348  *
   6349  * DESCRIPTION: process HDR scene events
   6350  *
   6351  * PARAMETERS :
   6352  *   @hdr_scene : HDR scene event data
   6353  *
   6354  * RETURN     : int32_t type of status
   6355  *              NO_ERROR  -- success
   6356  *              none-zero failure code
   6357  *==========================================================================*/
   6358 int32_t QCamera2HardwareInterface::processHDRData(
   6359         __unused cam_asd_hdr_scene_data_t hdr_scene)
   6360 {
   6361     int rc = NO_ERROR;
   6362 
   6363 #ifndef VANILLA_HAL
   6364     if (hdr_scene.is_hdr_scene &&
   6365       (hdr_scene.hdr_confidence > HDR_CONFIDENCE_THRESHOLD) &&
   6366       mParameters.isAutoHDREnabled()) {
   6367         m_HDRSceneEnabled = true;
   6368     } else {
   6369         m_HDRSceneEnabled = false;
   6370     }
   6371     mParameters.setHDRSceneEnable(m_HDRSceneEnabled);
   6372 
   6373     if ( msgTypeEnabled(CAMERA_MSG_META_DATA) ) {
   6374 
   6375         size_t data_len = sizeof(int);
   6376         size_t buffer_len = 1 *sizeof(int)       //meta type
   6377                           + 1 *sizeof(int)       //data len
   6378                           + 1 *sizeof(int);      //data
   6379         camera_memory_t *hdrBuffer = mGetMemory(-1,
   6380                                                  buffer_len,
   6381                                                  1,
   6382                                                  mCallbackCookie);
   6383         if ( NULL == hdrBuffer ) {
   6384             LOGE("Not enough memory for auto HDR data");
   6385             return NO_MEMORY;
   6386         }
   6387 
   6388         int *pHDRData = (int *)hdrBuffer->data;
   6389         if (pHDRData == NULL) {
   6390             LOGE("memory data ptr is NULL");
   6391             return UNKNOWN_ERROR;
   6392         }
   6393 
   6394         pHDRData[0] = CAMERA_META_DATA_HDR;
   6395         pHDRData[1] = (int)data_len;
   6396         pHDRData[2] = m_HDRSceneEnabled;
   6397 
   6398         qcamera_callback_argm_t cbArg;
   6399         memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   6400         cbArg.cb_type = QCAMERA_DATA_CALLBACK;
   6401         cbArg.msg_type = CAMERA_MSG_META_DATA;
   6402         cbArg.data = hdrBuffer;
   6403         cbArg.user_data = hdrBuffer;
   6404         cbArg.cookie = this;
   6405         cbArg.release_cb = releaseCameraMemory;
   6406         rc = m_cbNotifier.notifyCallback(cbArg);
   6407         if (rc != NO_ERROR) {
   6408             LOGE("fail sending auto HDR notification");
   6409             hdrBuffer->release(hdrBuffer);
   6410         }
   6411     }
   6412 
   6413     LOGH("hdr_scene_data: processHDRData: %d %f",
   6414           hdr_scene.is_hdr_scene,
   6415           hdr_scene.hdr_confidence);
   6416 
   6417 #endif
   6418   return rc;
   6419 }
   6420 
   6421 /*===========================================================================
   6422  * FUNCTION   : transAwbMetaToParams
   6423  *
   6424  * DESCRIPTION: translate awb params from metadata callback to QCameraParametersIntf
   6425  *
   6426  * PARAMETERS :
   6427  *   @awb_params : awb params from metadata callback
   6428  *
   6429  * RETURN     : int32_t type of status
   6430  *              NO_ERROR  -- success
   6431  *              none-zero failure code
   6432  *==========================================================================*/
   6433 int32_t QCamera2HardwareInterface::transAwbMetaToParams(cam_awb_params_t &awb_params)
   6434 {
   6435     mParameters.updateAWBParams(awb_params);
   6436     return NO_ERROR;
   6437 }
   6438 
   6439 /*===========================================================================
   6440  * FUNCTION   : processPrepSnapshotDone
   6441  *
   6442  * DESCRIPTION: process prep snapshot done event
   6443  *
   6444  * PARAMETERS :
   6445  *   @prep_snapshot_state  : state of prepare snapshot done. In other words,
   6446  *                           i.e. whether need future frames for capture.
   6447  *
   6448  * RETURN     : int32_t type of status
   6449  *              NO_ERROR  -- success
   6450  *              none-zero failure code
   6451  *==========================================================================*/
   6452 int32_t QCamera2HardwareInterface::processPrepSnapshotDoneEvent(
   6453                         cam_prep_snapshot_state_t prep_snapshot_state)
   6454 {
   6455     int32_t ret = NO_ERROR;
   6456     LOGI("[KPI Perf]: Received PREPARE SANSPHOT Done event state = %d",
   6457             prep_snapshot_state);
   6458     if (m_channels[QCAMERA_CH_TYPE_ZSL] &&
   6459         prep_snapshot_state == NEED_FUTURE_FRAME) {
   6460         LOGH("already handled in mm-camera-intf, no ops here");
   6461         if (isRetroPicture()) {
   6462             mParameters.setAecLock("true");
   6463             mParameters.commitParameters();
   6464             m_bLedAfAecLock = TRUE;
   6465         }
   6466     }
   6467     return ret;
   6468 }
   6469 
   6470 /*===========================================================================
   6471  * FUNCTION   : processASDUpdate
   6472  *
   6473  * DESCRIPTION: process ASD update event
   6474  *
   6475  * PARAMETERS :
   6476  *   @scene: selected scene mode
   6477  *
   6478  * RETURN     : int32_t type of status
   6479  *              NO_ERROR  -- success
   6480  *              none-zero failure code
   6481  *==========================================================================*/
   6482 int32_t QCamera2HardwareInterface::processASDUpdate(
   6483         __unused cam_asd_decision_t asd_decision)
   6484 {
   6485 #ifndef VANILLA_HAL
   6486     if ( msgTypeEnabled(CAMERA_MSG_META_DATA) ) {
   6487         size_t data_len = sizeof(cam_auto_scene_t);
   6488         size_t buffer_len = 1 *sizeof(int)       //meta type
   6489                 + 1 *sizeof(int)       //data len
   6490                 + data_len;            //data
   6491         camera_memory_t *asdBuffer = mGetMemory(-1,
   6492                 buffer_len, 1, mCallbackCookie);
   6493         if ( NULL == asdBuffer ) {
   6494             LOGE("Not enough memory for histogram data");
   6495             return NO_MEMORY;
   6496         }
   6497 
   6498         int *pASDData = (int *)asdBuffer->data;
   6499         if (pASDData == NULL) {
   6500             LOGE("memory data ptr is NULL");
   6501             return UNKNOWN_ERROR;
   6502         }
   6503 
   6504         pASDData[0] = CAMERA_META_DATA_ASD;
   6505         pASDData[1] = (int)data_len;
   6506         pASDData[2] = asd_decision.detected_scene;
   6507 
   6508         qcamera_callback_argm_t cbArg;
   6509         memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   6510         cbArg.cb_type = QCAMERA_DATA_CALLBACK;
   6511         cbArg.msg_type = CAMERA_MSG_META_DATA;
   6512         cbArg.data = asdBuffer;
   6513         cbArg.user_data = asdBuffer;
   6514         cbArg.cookie = this;
   6515         cbArg.release_cb = releaseCameraMemory;
   6516         int32_t rc = m_cbNotifier.notifyCallback(cbArg);
   6517         if (rc != NO_ERROR) {
   6518             LOGE("fail sending notification");
   6519             asdBuffer->release(asdBuffer);
   6520         }
   6521     }
   6522 #endif
   6523     return NO_ERROR;
   6524 }
   6525 
   6526 /*===========================================================================
   6527  * FUNCTION   : processJpegNotify
   6528  *
   6529  * DESCRIPTION: process jpeg event
   6530  *
   6531  * PARAMETERS :
   6532  *   @jpeg_evt: ptr to jpeg event payload
   6533  *
   6534  * RETURN     : int32_t type of status
   6535  *              NO_ERROR  -- success
   6536  *              none-zero failure code
   6537  *==========================================================================*/
   6538 int32_t QCamera2HardwareInterface::processJpegNotify(qcamera_jpeg_evt_payload_t *jpeg_evt)
   6539 {
   6540     return m_postprocessor.processJpegEvt(jpeg_evt);
   6541 }
   6542 
   6543 /*===========================================================================
   6544  * FUNCTION   : lockAPI
   6545  *
   6546  * DESCRIPTION: lock to process API
   6547  *
   6548  * PARAMETERS : none
   6549  *
   6550  * RETURN     : none
   6551  *==========================================================================*/
   6552 void QCamera2HardwareInterface::lockAPI()
   6553 {
   6554     pthread_mutex_lock(&m_lock);
   6555 }
   6556 
   6557 /*===========================================================================
   6558  * FUNCTION   : waitAPIResult
   6559  *
   6560  * DESCRIPTION: wait for API result coming back. This is a blocking call, it will
   6561  *              return only cerntain API event type arrives
   6562  *
   6563  * PARAMETERS :
   6564  *   @api_evt : API event type
   6565  *
   6566  * RETURN     : none
   6567  *==========================================================================*/
   6568 void QCamera2HardwareInterface::waitAPIResult(qcamera_sm_evt_enum_t api_evt,
   6569         qcamera_api_result_t *apiResult)
   6570 {
   6571     LOGD("wait for API result of evt (%d)", api_evt);
   6572     int resultReceived = 0;
   6573     while  (!resultReceived) {
   6574         pthread_cond_wait(&m_cond, &m_lock);
   6575         if (m_apiResultList != NULL) {
   6576             api_result_list *apiResultList = m_apiResultList;
   6577             api_result_list *apiResultListPrevious = m_apiResultList;
   6578             while (apiResultList != NULL) {
   6579                 if (apiResultList->result.request_api == api_evt) {
   6580                     resultReceived = 1;
   6581                     *apiResult = apiResultList->result;
   6582                     apiResultListPrevious->next = apiResultList->next;
   6583                     if (apiResultList == m_apiResultList) {
   6584                         m_apiResultList = apiResultList->next;
   6585                     }
   6586                     free(apiResultList);
   6587                     break;
   6588                 }
   6589                 else {
   6590                     apiResultListPrevious = apiResultList;
   6591                     apiResultList = apiResultList->next;
   6592                 }
   6593             }
   6594         }
   6595     }
   6596     LOGD("return (%d) from API result wait for evt (%d)",
   6597            apiResult->status, api_evt);
   6598 }
   6599 
   6600 
   6601 /*===========================================================================
   6602  * FUNCTION   : unlockAPI
   6603  *
   6604  * DESCRIPTION: API processing is done, unlock
   6605  *
   6606  * PARAMETERS : none
   6607  *
   6608  * RETURN     : none
   6609  *==========================================================================*/
   6610 void QCamera2HardwareInterface::unlockAPI()
   6611 {
   6612     pthread_mutex_unlock(&m_lock);
   6613 }
   6614 
   6615 /*===========================================================================
   6616  * FUNCTION   : signalAPIResult
   6617  *
   6618  * DESCRIPTION: signal condition viarable that cerntain API event type arrives
   6619  *
   6620  * PARAMETERS :
   6621  *   @result  : API result
   6622  *
   6623  * RETURN     : none
   6624  *==========================================================================*/
   6625 void QCamera2HardwareInterface::signalAPIResult(qcamera_api_result_t *result)
   6626 {
   6627 
   6628     pthread_mutex_lock(&m_lock);
   6629     api_result_list *apiResult = (api_result_list *)malloc(sizeof(api_result_list));
   6630     if (apiResult == NULL) {
   6631         LOGE("ERROR: malloc for api result failed, Result will not be sent");
   6632         goto malloc_failed;
   6633     }
   6634     apiResult->result = *result;
   6635     apiResult->next = NULL;
   6636     if (m_apiResultList == NULL) m_apiResultList = apiResult;
   6637     else {
   6638         api_result_list *apiResultList = m_apiResultList;
   6639         while(apiResultList->next != NULL) apiResultList = apiResultList->next;
   6640         apiResultList->next = apiResult;
   6641     }
   6642 malloc_failed:
   6643     pthread_cond_broadcast(&m_cond);
   6644     pthread_mutex_unlock(&m_lock);
   6645 }
   6646 
   6647 /*===========================================================================
   6648  * FUNCTION   : signalEvtResult
   6649  *
   6650  * DESCRIPTION: signal condition variable that certain event was processed
   6651  *
   6652  * PARAMETERS :
   6653  *   @result  : Event result
   6654  *
   6655  * RETURN     : none
   6656  *==========================================================================*/
   6657 void QCamera2HardwareInterface::signalEvtResult(qcamera_api_result_t *result)
   6658 {
   6659     pthread_mutex_lock(&m_evtLock);
   6660     m_evtResult = *result;
   6661     pthread_cond_signal(&m_evtCond);
   6662     pthread_mutex_unlock(&m_evtLock);
   6663 }
   6664 
   6665 int32_t QCamera2HardwareInterface::prepareRawStream(QCameraChannel *curChannel)
   6666 {
   6667     int32_t rc = NO_ERROR;
   6668     cam_dimension_t str_dim,max_dim;
   6669     QCameraChannel *pChannel;
   6670 
   6671     max_dim.width = 0;
   6672     max_dim.height = 0;
   6673 
   6674     for (int j = 0; j < QCAMERA_CH_TYPE_MAX; j++) {
   6675         if (m_channels[j] != NULL) {
   6676             pChannel = m_channels[j];
   6677             for (uint8_t i = 0; i < pChannel->getNumOfStreams(); i++) {
   6678                 QCameraStream *pStream = pChannel->getStreamByIndex(i);
   6679                 if (pStream != NULL) {
   6680                     if ((pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
   6681                             || (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
   6682                         continue;
   6683                     }
   6684                     pStream->getFrameDimension(str_dim);
   6685                     if (str_dim.width > max_dim.width) {
   6686                         max_dim.width = str_dim.width;
   6687                     }
   6688                     if (str_dim.height > max_dim.height) {
   6689                         max_dim.height = str_dim.height;
   6690                     }
   6691                 }
   6692             }
   6693         }
   6694     }
   6695 
   6696     for (uint8_t i = 0; i < curChannel->getNumOfStreams(); i++) {
   6697         QCameraStream *pStream = curChannel->getStreamByIndex(i);
   6698         if (pStream != NULL) {
   6699             if ((pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
   6700                     || (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
   6701                 continue;
   6702             }
   6703             pStream->getFrameDimension(str_dim);
   6704             if (str_dim.width > max_dim.width) {
   6705                 max_dim.width = str_dim.width;
   6706             }
   6707             if (str_dim.height > max_dim.height) {
   6708                 max_dim.height = str_dim.height;
   6709             }
   6710         }
   6711     }
   6712     rc = mParameters.updateRAW(max_dim);
   6713     return rc;
   6714 }
   6715 /*===========================================================================
   6716  * FUNCTION   : addStreamToChannel
   6717  *
   6718  * DESCRIPTION: add a stream into a channel
   6719  *
   6720  * PARAMETERS :
   6721  *   @pChannel   : ptr to channel obj
   6722  *   @streamType : type of stream to be added
   6723  *   @streamCB   : callback of stream
   6724  *   @userData   : user data ptr to callback
   6725  *
   6726  * RETURN     : int32_t type of status
   6727  *              NO_ERROR  -- success
   6728  *              none-zero failure code
   6729  *==========================================================================*/
   6730 int32_t QCamera2HardwareInterface::addStreamToChannel(QCameraChannel *pChannel,
   6731                                                       cam_stream_type_t streamType,
   6732                                                       stream_cb_routine streamCB,
   6733                                                       void *userData)
   6734 {
   6735     int32_t rc = NO_ERROR;
   6736 
   6737     if (streamType == CAM_STREAM_TYPE_RAW) {
   6738         prepareRawStream(pChannel);
   6739     }
   6740     QCameraHeapMemory *pStreamInfo = allocateStreamInfoBuf(streamType);
   6741     if (pStreamInfo == NULL) {
   6742         LOGE("no mem for stream info buf");
   6743         return NO_MEMORY;
   6744     }
   6745     uint8_t minStreamBufNum = getBufNumRequired(streamType);
   6746     bool bDynAllocBuf = false;
   6747     if (isZSLMode() && streamType == CAM_STREAM_TYPE_SNAPSHOT) {
   6748         bDynAllocBuf = true;
   6749     }
   6750 
   6751     cam_padding_info_t padding_info;
   6752 
   6753     if (streamType == CAM_STREAM_TYPE_ANALYSIS) {
   6754         cam_analysis_info_t analysisInfo;
   6755         cam_feature_mask_t featureMask;
   6756 
   6757         featureMask = 0;
   6758         mParameters.getStreamPpMask(CAM_STREAM_TYPE_ANALYSIS, featureMask);
   6759         rc = mParameters.getAnalysisInfo(
   6760                 ((mParameters.getRecordingHintValue() == true) &&
   6761                  mParameters.fdModeInVideo()),
   6762                 FALSE,
   6763                 featureMask,
   6764                 &analysisInfo);
   6765         if (rc != NO_ERROR) {
   6766             LOGE("getAnalysisInfo failed, ret = %d", rc);
   6767             return rc;
   6768         }
   6769 
   6770         padding_info = analysisInfo.analysis_padding_info;
   6771     } else {
   6772         padding_info =
   6773                 gCamCapability[mCameraId]->padding_info;
   6774         if (streamType == CAM_STREAM_TYPE_PREVIEW) {
   6775             padding_info.width_padding = mSurfaceStridePadding;
   6776             padding_info.height_padding = CAM_PAD_TO_2;
   6777         }
   6778         if((!needReprocess())
   6779                 || (streamType != CAM_STREAM_TYPE_SNAPSHOT)
   6780                 || (!mParameters.isLLNoiseEnabled())) {
   6781             padding_info.offset_info.offset_x = 0;
   6782             padding_info.offset_info.offset_y = 0;
   6783         }
   6784     }
   6785 
   6786     bool deferAllocation = needDeferred(streamType);
   6787     LOGD("deferAllocation = %d bDynAllocBuf = %d, stream type = %d",
   6788             deferAllocation, bDynAllocBuf, streamType);
   6789     rc = pChannel->addStream(*this,
   6790             pStreamInfo,
   6791             NULL,
   6792             minStreamBufNum,
   6793             &padding_info,
   6794             streamCB, userData,
   6795             bDynAllocBuf,
   6796             deferAllocation);
   6797 
   6798     if (rc != NO_ERROR) {
   6799         LOGE("add stream type (%d) failed, ret = %d",
   6800                streamType, rc);
   6801         return rc;
   6802     }
   6803 
   6804     return rc;
   6805 }
   6806 
   6807 /*===========================================================================
   6808  * FUNCTION   : addPreviewChannel
   6809  *
   6810  * DESCRIPTION: add a preview channel that contains a preview stream
   6811  *
   6812  * PARAMETERS : none
   6813  *
   6814  * RETURN     : int32_t type of status
   6815  *              NO_ERROR  -- success
   6816  *              none-zero failure code
   6817  *==========================================================================*/
   6818 int32_t QCamera2HardwareInterface::addPreviewChannel()
   6819 {
   6820     int32_t rc = NO_ERROR;
   6821     QCameraChannel *pChannel = NULL;
   6822     char value[PROPERTY_VALUE_MAX];
   6823     bool raw_yuv = false;
   6824 
   6825 
   6826     if (m_channels[QCAMERA_CH_TYPE_PREVIEW] != NULL) {
   6827         // if we had preview channel before, delete it first
   6828         delete m_channels[QCAMERA_CH_TYPE_PREVIEW];
   6829         m_channels[QCAMERA_CH_TYPE_PREVIEW] = NULL;
   6830     }
   6831 
   6832     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   6833                                   mCameraHandle->ops);
   6834     if (NULL == pChannel) {
   6835         LOGE("no mem for preview channel");
   6836         return NO_MEMORY;
   6837     }
   6838 
   6839     // preview only channel, don't need bundle attr and cb
   6840     rc = pChannel->init(NULL, NULL, NULL);
   6841     if (rc != NO_ERROR) {
   6842         LOGE("init preview channel failed, ret = %d", rc);
   6843         return rc;
   6844     }
   6845 
   6846     // meta data stream always coexists with preview if applicable
   6847     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
   6848                             metadata_stream_cb_routine, this);
   6849     if (rc != NO_ERROR) {
   6850         LOGE("add metadata stream failed, ret = %d", rc);
   6851         return rc;
   6852     }
   6853 
   6854     if (isRdiMode()) {
   6855         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
   6856                                 rdi_mode_stream_cb_routine, this);
   6857     } else {
   6858         if (isNoDisplayMode()) {
   6859             rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
   6860                                     nodisplay_preview_stream_cb_routine, this);
   6861         } else {
   6862             rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
   6863                                     preview_stream_cb_routine, this);
   6864             pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
   6865                     synchronous_stream_cb_routine);
   6866         }
   6867     }
   6868 
   6869     if (((mParameters.fdModeInVideo())
   6870             || (mParameters.getDcrf() == true)
   6871             || (mParameters.getRecordingHintValue() != true))
   6872             && (!mParameters.isSecureMode())) {
   6873         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
   6874                 NULL, this);
   6875         if (rc != NO_ERROR) {
   6876             LOGE("add Analysis stream failed, ret = %d", rc);
   6877             return rc;
   6878         }
   6879     }
   6880 
   6881     property_get("persist.camera.raw_yuv", value, "0");
   6882     raw_yuv = atoi(value) > 0 ? true : false;
   6883     if ( raw_yuv ) {
   6884         rc = addStreamToChannel(pChannel,CAM_STREAM_TYPE_RAW,
   6885                 preview_raw_stream_cb_routine,this);
   6886         if ( rc != NO_ERROR ) {
   6887             LOGE("add raw stream failed, ret = %d", __FUNCTION__, rc);
   6888             delete pChannel;
   6889             return rc;
   6890         }
   6891     }
   6892 
   6893     if (rc != NO_ERROR) {
   6894         LOGE("add preview stream failed, ret = %d", rc);
   6895         delete pChannel;
   6896         return rc;
   6897     }
   6898 
   6899     m_channels[QCAMERA_CH_TYPE_PREVIEW] = pChannel;
   6900     return rc;
   6901 }
   6902 
   6903 /*===========================================================================
   6904  * FUNCTION   : addVideoChannel
   6905  *
   6906  * DESCRIPTION: add a video channel that contains a video stream
   6907  *
   6908  * PARAMETERS : none
   6909  *
   6910  * RETURN     : int32_t type of status
   6911  *              NO_ERROR  -- success
   6912  *              none-zero failure code
   6913  *==========================================================================*/
   6914 int32_t QCamera2HardwareInterface::addVideoChannel()
   6915 {
   6916     int32_t rc = NO_ERROR;
   6917     QCameraVideoChannel *pChannel = NULL;
   6918 
   6919     if (m_channels[QCAMERA_CH_TYPE_VIDEO] != NULL) {
   6920         // if we had video channel before, delete it first
   6921         delete m_channels[QCAMERA_CH_TYPE_VIDEO];
   6922         m_channels[QCAMERA_CH_TYPE_VIDEO] = NULL;
   6923     }
   6924 
   6925     pChannel = new QCameraVideoChannel(mCameraHandle->camera_handle,
   6926                                        mCameraHandle->ops);
   6927     if (NULL == pChannel) {
   6928         LOGE("no mem for video channel");
   6929         return NO_MEMORY;
   6930     }
   6931 
   6932     if (isLowPowerMode()) {
   6933         mm_camera_channel_attr_t attr;
   6934         memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   6935         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
   6936         attr.look_back = 0; //wait for future frame for liveshot
   6937         attr.post_frame_skip = mParameters.getZSLBurstInterval();
   6938         attr.water_mark = 1; //hold min buffers possible in Q
   6939         attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   6940         rc = pChannel->init(&attr, snapshot_channel_cb_routine, this);
   6941     } else {
   6942         // preview only channel, don't need bundle attr and cb
   6943         rc = pChannel->init(NULL, NULL, NULL);
   6944     }
   6945 
   6946     if (rc != 0) {
   6947         LOGE("init video channel failed, ret = %d", rc);
   6948         delete pChannel;
   6949         return rc;
   6950     }
   6951 
   6952     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_VIDEO,
   6953                             video_stream_cb_routine, this);
   6954     if (rc != NO_ERROR) {
   6955         LOGE("add video stream failed, ret = %d", rc);
   6956         delete pChannel;
   6957         return rc;
   6958     }
   6959 
   6960     m_channels[QCAMERA_CH_TYPE_VIDEO] = pChannel;
   6961     return rc;
   6962 }
   6963 
   6964 /*===========================================================================
   6965  * FUNCTION   : addSnapshotChannel
   6966  *
   6967  * DESCRIPTION: add a snapshot channel that contains a snapshot stream
   6968  *
   6969  * PARAMETERS : none
   6970  *
   6971  * RETURN     : int32_t type of status
   6972  *              NO_ERROR  -- success
   6973  *              none-zero failure code
   6974  * NOTE       : Add this channel for live snapshot usecase. Regular capture will
   6975  *              use addCaptureChannel.
   6976  *==========================================================================*/
   6977 int32_t QCamera2HardwareInterface::addSnapshotChannel()
   6978 {
   6979     int32_t rc = NO_ERROR;
   6980     QCameraChannel *pChannel = NULL;
   6981 
   6982     if (m_channels[QCAMERA_CH_TYPE_SNAPSHOT] != NULL) {
   6983         // if we had ZSL channel before, delete it first
   6984         delete m_channels[QCAMERA_CH_TYPE_SNAPSHOT];
   6985         m_channels[QCAMERA_CH_TYPE_SNAPSHOT] = NULL;
   6986     }
   6987 
   6988     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   6989                                   mCameraHandle->ops);
   6990     if (NULL == pChannel) {
   6991         LOGE("no mem for snapshot channel");
   6992         return NO_MEMORY;
   6993     }
   6994 
   6995     mm_camera_channel_attr_t attr;
   6996     memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   6997     attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
   6998     attr.look_back = 0; //wait for future frame for liveshot
   6999     attr.post_frame_skip = mParameters.getZSLBurstInterval();
   7000     attr.water_mark = 1; //hold min buffers possible in Q
   7001     attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   7002     attr.priority = MM_CAMERA_SUPER_BUF_PRIORITY_LOW;
   7003     rc = pChannel->init(&attr, snapshot_channel_cb_routine, this);
   7004     if (rc != NO_ERROR) {
   7005         LOGE("init snapshot channel failed, ret = %d", rc);
   7006         delete pChannel;
   7007         return rc;
   7008     }
   7009 
   7010     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
   7011             NULL, NULL);
   7012     if (rc != NO_ERROR) {
   7013         LOGE("add snapshot stream failed, ret = %d", rc);
   7014         delete pChannel;
   7015         return rc;
   7016     }
   7017 
   7018     m_channels[QCAMERA_CH_TYPE_SNAPSHOT] = pChannel;
   7019     return rc;
   7020 }
   7021 
   7022 /*===========================================================================
   7023  * FUNCTION   : addRawChannel
   7024  *
   7025  * DESCRIPTION: add a raw channel that contains a raw image stream
   7026  *
   7027  * PARAMETERS : none
   7028  *
   7029  * RETURN     : int32_t type of status
   7030  *              NO_ERROR  -- success
   7031  *              none-zero failure code
   7032  *==========================================================================*/
   7033 int32_t QCamera2HardwareInterface::addRawChannel()
   7034 {
   7035     int32_t rc = NO_ERROR;
   7036     QCameraChannel *pChannel = NULL;
   7037 
   7038     if (m_channels[QCAMERA_CH_TYPE_RAW] != NULL) {
   7039         // if we had raw channel before, delete it first
   7040         delete m_channels[QCAMERA_CH_TYPE_RAW];
   7041         m_channels[QCAMERA_CH_TYPE_RAW] = NULL;
   7042     }
   7043 
   7044     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   7045                                   mCameraHandle->ops);
   7046     if (NULL == pChannel) {
   7047         LOGE("no mem for raw channel");
   7048         return NO_MEMORY;
   7049     }
   7050 
   7051     if (mParameters.getofflineRAW()) {
   7052         mm_camera_channel_attr_t attr;
   7053         memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   7054         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
   7055         attr.look_back = mParameters.getZSLBackLookCount();
   7056         attr.post_frame_skip = mParameters.getZSLBurstInterval();
   7057         attr.water_mark = 1;
   7058         attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   7059         rc = pChannel->init(&attr, raw_channel_cb_routine, this);
   7060         if (rc != NO_ERROR) {
   7061             LOGE("init RAW channel failed, ret = %d", rc);
   7062             delete pChannel;
   7063             return rc;
   7064         }
   7065     } else {
   7066         rc = pChannel->init(NULL, NULL, NULL);
   7067         if (rc != NO_ERROR) {
   7068             LOGE("init raw channel failed, ret = %d", rc);
   7069             delete pChannel;
   7070             return rc;
   7071         }
   7072     }
   7073 
   7074     if (!mParameters.isZSLMode()) {
   7075         // meta data stream always coexists with snapshot in regular RAW capture case
   7076         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
   7077                 metadata_stream_cb_routine, this);
   7078         if (rc != NO_ERROR) {
   7079             LOGE("add metadata stream failed, ret = %d", rc);
   7080             delete pChannel;
   7081             return rc;
   7082         }
   7083     }
   7084 
   7085     if (mParameters.getofflineRAW()) {
   7086         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
   7087                 NULL, this);
   7088     } else {
   7089         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_RAW,
   7090                 raw_stream_cb_routine, this);
   7091     }
   7092     if (rc != NO_ERROR) {
   7093         LOGE("add snapshot stream failed, ret = %d", rc);
   7094         delete pChannel;
   7095         return rc;
   7096     }
   7097     m_channels[QCAMERA_CH_TYPE_RAW] = pChannel;
   7098     return rc;
   7099 }
   7100 
   7101 /*===========================================================================
   7102  * FUNCTION   : addZSLChannel
   7103  *
   7104  * DESCRIPTION: add a ZSL channel that contains a preview stream and
   7105  *              a snapshot stream
   7106  *
   7107  * PARAMETERS : none
   7108  *
   7109  * RETURN     : int32_t type of status
   7110  *              NO_ERROR  -- success
   7111  *              none-zero failure code
   7112  *==========================================================================*/
   7113 int32_t QCamera2HardwareInterface::addZSLChannel()
   7114 {
   7115     int32_t rc = NO_ERROR;
   7116     QCameraPicChannel *pChannel = NULL;
   7117     char value[PROPERTY_VALUE_MAX];
   7118     bool raw_yuv = false;
   7119 
   7120     if (m_channels[QCAMERA_CH_TYPE_ZSL] != NULL) {
   7121         // if we had ZSL channel before, delete it first
   7122         delete m_channels[QCAMERA_CH_TYPE_ZSL];
   7123         m_channels[QCAMERA_CH_TYPE_ZSL] = NULL;
   7124     }
   7125 
   7126     pChannel = new QCameraPicChannel(mCameraHandle->camera_handle,
   7127                                      mCameraHandle->ops);
   7128     if (NULL == pChannel) {
   7129         LOGE("no mem for ZSL channel");
   7130         return NO_MEMORY;
   7131     }
   7132 
   7133     // ZSL channel, init with bundle attr and cb
   7134     mm_camera_channel_attr_t attr;
   7135     memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   7136     if (mParameters.isSceneSelectionEnabled()) {
   7137         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
   7138     } else {
   7139         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
   7140     }
   7141     attr.look_back = mParameters.getZSLBackLookCount();
   7142     attr.post_frame_skip = mParameters.getZSLBurstInterval();
   7143     if (mParameters.isOEMFeatEnabled()) {
   7144         attr.post_frame_skip++;
   7145     }
   7146     attr.water_mark = mParameters.getZSLQueueDepth();
   7147     attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   7148     attr.user_expected_frame_id =
   7149         mParameters.isInstantCaptureEnabled() ? (uint8_t)mParameters.getAecFrameBoundValue() : 0;
   7150 
   7151     //Enabled matched queue
   7152     if (isFrameSyncEnabled()) {
   7153         LOGH("Enabling frame sync for dual camera, camera Id: %d",
   7154                  mCameraId);
   7155         attr.enable_frame_sync = 1;
   7156     }
   7157     rc = pChannel->init(&attr,
   7158                         zsl_channel_cb,
   7159                         this);
   7160     if (rc != 0) {
   7161         LOGE("init ZSL channel failed, ret = %d", rc);
   7162         delete pChannel;
   7163         return rc;
   7164     }
   7165 
   7166     // meta data stream always coexists with preview if applicable
   7167     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
   7168                             metadata_stream_cb_routine, this);
   7169     if (rc != NO_ERROR) {
   7170         LOGE("add metadata stream failed, ret = %d", rc);
   7171         delete pChannel;
   7172         return rc;
   7173     }
   7174 
   7175     if (isNoDisplayMode()) {
   7176         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
   7177                                 nodisplay_preview_stream_cb_routine, this);
   7178     } else {
   7179         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
   7180                                 preview_stream_cb_routine, this);
   7181         pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
   7182                 synchronous_stream_cb_routine);
   7183     }
   7184     if (rc != NO_ERROR) {
   7185         LOGE("add preview stream failed, ret = %d", rc);
   7186         delete pChannel;
   7187         return rc;
   7188     }
   7189 
   7190     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
   7191                             NULL, this);
   7192     if (rc != NO_ERROR) {
   7193         LOGE("add snapshot stream failed, ret = %d", rc);
   7194         delete pChannel;
   7195         return rc;
   7196     }
   7197 
   7198     if (!mParameters.isSecureMode()) {
   7199         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
   7200                 NULL, this);
   7201         if (rc != NO_ERROR) {
   7202             LOGE("add Analysis stream failed, ret = %d", rc);
   7203             delete pChannel;
   7204             return rc;
   7205         }
   7206     }
   7207 
   7208     property_get("persist.camera.raw_yuv", value, "0");
   7209     raw_yuv = atoi(value) > 0 ? true : false;
   7210     if (raw_yuv) {
   7211         rc = addStreamToChannel(pChannel,
   7212                                 CAM_STREAM_TYPE_RAW,
   7213                                 NULL,
   7214                                 this);
   7215         if (rc != NO_ERROR) {
   7216             LOGE("add raw stream failed, ret = %d", rc);
   7217             delete pChannel;
   7218             return rc;
   7219         }
   7220     }
   7221 
   7222     m_channels[QCAMERA_CH_TYPE_ZSL] = pChannel;
   7223     return rc;
   7224 }
   7225 
   7226 /*===========================================================================
   7227  * FUNCTION   : addCaptureChannel
   7228  *
   7229  * DESCRIPTION: add a capture channel that contains a snapshot stream
   7230  *              and a postview stream
   7231  *
   7232  * PARAMETERS : none
   7233  *
   7234  * RETURN     : int32_t type of status
   7235  *              NO_ERROR  -- success
   7236  *              none-zero failure code
   7237  * NOTE       : Add this channel for regular capture usecase.
   7238  *              For Live snapshot usecase, use addSnapshotChannel.
   7239  *==========================================================================*/
   7240 int32_t QCamera2HardwareInterface::addCaptureChannel()
   7241 {
   7242     int32_t rc = NO_ERROR;
   7243     QCameraPicChannel *pChannel = NULL;
   7244     char value[PROPERTY_VALUE_MAX];
   7245     bool raw_yuv = false;
   7246 
   7247     if (m_channels[QCAMERA_CH_TYPE_CAPTURE] != NULL) {
   7248         delete m_channels[QCAMERA_CH_TYPE_CAPTURE];
   7249         m_channels[QCAMERA_CH_TYPE_CAPTURE] = NULL;
   7250     }
   7251 
   7252     pChannel = new QCameraPicChannel(mCameraHandle->camera_handle,
   7253                                   mCameraHandle->ops);
   7254     if (NULL == pChannel) {
   7255         LOGE("no mem for capture channel");
   7256         return NO_MEMORY;
   7257     }
   7258 
   7259     // Capture channel, only need snapshot and postview streams start together
   7260     mm_camera_channel_attr_t attr;
   7261     memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   7262     if ( mLongshotEnabled ) {
   7263         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
   7264         attr.look_back = mParameters.getZSLBackLookCount();
   7265         attr.water_mark = mParameters.getZSLQueueDepth();
   7266     } else {
   7267         attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
   7268     }
   7269     attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   7270 
   7271     rc = pChannel->init(&attr,
   7272                         capture_channel_cb_routine,
   7273                         this);
   7274     if (rc != NO_ERROR) {
   7275         LOGE("init capture channel failed, ret = %d", rc);
   7276         return rc;
   7277     }
   7278 
   7279     // meta data stream always coexists with snapshot in regular capture case
   7280     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
   7281                             metadata_stream_cb_routine, this);
   7282     if (rc != NO_ERROR) {
   7283         LOGE("add metadata stream failed, ret = %d", rc);
   7284         return rc;
   7285     }
   7286 
   7287     if (!mLongshotEnabled) {
   7288         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_POSTVIEW,
   7289                                 NULL, this);
   7290 
   7291         if (rc != NO_ERROR) {
   7292             LOGE("add postview stream failed, ret = %d", rc);
   7293             return rc;
   7294         }
   7295     } else {
   7296         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_PREVIEW,
   7297                                 preview_stream_cb_routine, this);
   7298 
   7299         if (rc != NO_ERROR) {
   7300             LOGE("add preview stream failed, ret = %d", rc);
   7301             return rc;
   7302         }
   7303         pChannel->setStreamSyncCB(CAM_STREAM_TYPE_PREVIEW,
   7304                 synchronous_stream_cb_routine);
   7305     }
   7306 
   7307     if (!mParameters.getofflineRAW()) {
   7308         rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_SNAPSHOT,
   7309                 NULL, this);
   7310         if (rc != NO_ERROR) {
   7311             LOGE("add snapshot stream failed, ret = %d", rc);
   7312             return rc;
   7313         }
   7314     }
   7315 
   7316     stream_cb_routine stream_cb = NULL;
   7317     property_get("persist.camera.raw_yuv", value, "0");
   7318     raw_yuv = atoi(value) > 0 ? true : false;
   7319 
   7320     if (raw_yuv) {
   7321         stream_cb = snapshot_raw_stream_cb_routine;
   7322     }
   7323 
   7324     if ((raw_yuv) || (mParameters.getofflineRAW())) {
   7325         rc = addStreamToChannel(pChannel,
   7326                 CAM_STREAM_TYPE_RAW, stream_cb, this);
   7327         if (rc != NO_ERROR) {
   7328             LOGE("add raw stream failed, ret = %d", rc);
   7329             return rc;
   7330         }
   7331     }
   7332 
   7333     m_channels[QCAMERA_CH_TYPE_CAPTURE] = pChannel;
   7334     return rc;
   7335 }
   7336 
   7337 /*===========================================================================
   7338  * FUNCTION   : addMetaDataChannel
   7339  *
   7340  * DESCRIPTION: add a meta data channel that contains a metadata stream
   7341  *
   7342  * PARAMETERS : none
   7343  *
   7344  * RETURN     : int32_t type of status
   7345  *              NO_ERROR  -- success
   7346  *              none-zero failure code
   7347  *==========================================================================*/
   7348 int32_t QCamera2HardwareInterface::addMetaDataChannel()
   7349 {
   7350     int32_t rc = NO_ERROR;
   7351     QCameraChannel *pChannel = NULL;
   7352 
   7353     if (m_channels[QCAMERA_CH_TYPE_METADATA] != NULL) {
   7354         delete m_channels[QCAMERA_CH_TYPE_METADATA];
   7355         m_channels[QCAMERA_CH_TYPE_METADATA] = NULL;
   7356     }
   7357 
   7358     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   7359                                   mCameraHandle->ops);
   7360     if (NULL == pChannel) {
   7361         LOGE("no mem for metadata channel");
   7362         return NO_MEMORY;
   7363     }
   7364 
   7365     rc = pChannel->init(NULL,
   7366                         NULL,
   7367                         NULL);
   7368     if (rc != NO_ERROR) {
   7369         LOGE("init metadata channel failed, ret = %d", rc);
   7370         delete pChannel;
   7371         return rc;
   7372     }
   7373 
   7374     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_METADATA,
   7375                             metadata_stream_cb_routine, this);
   7376     if (rc != NO_ERROR) {
   7377         LOGE("add metadata stream failed, ret = %d", rc);
   7378         delete pChannel;
   7379         return rc;
   7380     }
   7381 
   7382     m_channels[QCAMERA_CH_TYPE_METADATA] = pChannel;
   7383     return rc;
   7384 }
   7385 
   7386 /*===========================================================================
   7387  * FUNCTION   : addCallbackChannel
   7388  *
   7389  * DESCRIPTION: add a callback channel that contains a callback stream
   7390  *
   7391  * PARAMETERS : none
   7392  *
   7393  * RETURN     : int32_t type of status
   7394  *              NO_ERROR  -- success
   7395  *              none-zero failure code
   7396  *==========================================================================*/
   7397 int32_t QCamera2HardwareInterface::addCallbackChannel()
   7398 {
   7399     int32_t rc = NO_ERROR;
   7400     QCameraChannel *pChannel = NULL;
   7401 
   7402     if (m_channels[QCAMERA_CH_TYPE_CALLBACK] != NULL) {
   7403         delete m_channels[QCAMERA_CH_TYPE_CALLBACK];
   7404         m_channels[QCAMERA_CH_TYPE_CALLBACK] = NULL;
   7405     }
   7406 
   7407     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   7408             mCameraHandle->ops);
   7409     if (NULL == pChannel) {
   7410         LOGE("no mem for callback channel");
   7411         return NO_MEMORY;
   7412     }
   7413 
   7414     rc = pChannel->init(NULL, NULL, this);
   7415     if (rc != NO_ERROR) {
   7416         LOGE("init callback channel failed, ret = %d",
   7417                  rc);
   7418         delete pChannel;
   7419         return rc;
   7420     }
   7421 
   7422     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_CALLBACK,
   7423             callback_stream_cb_routine, this);
   7424     if (rc != NO_ERROR) {
   7425         LOGE("add callback stream failed, ret = %d", rc);
   7426         delete pChannel;
   7427         return rc;
   7428     }
   7429 
   7430     m_channels[QCAMERA_CH_TYPE_CALLBACK] = pChannel;
   7431     return rc;
   7432 }
   7433 
   7434 
   7435 /*===========================================================================
   7436  * FUNCTION   : addAnalysisChannel
   7437  *
   7438  * DESCRIPTION: add a analysis channel that contains a analysis stream
   7439  *
   7440  * PARAMETERS : none
   7441  *
   7442  * RETURN     : int32_t type of status
   7443  *              NO_ERROR  -- success
   7444  *              none-zero failure code
   7445  *==========================================================================*/
   7446 int32_t QCamera2HardwareInterface::addAnalysisChannel()
   7447 {
   7448     int32_t rc = NO_ERROR;
   7449     QCameraChannel *pChannel = NULL;
   7450 
   7451     if (m_channels[QCAMERA_CH_TYPE_ANALYSIS] != NULL) {
   7452         delete m_channels[QCAMERA_CH_TYPE_ANALYSIS];
   7453         m_channels[QCAMERA_CH_TYPE_ANALYSIS] = NULL;
   7454     }
   7455 
   7456     pChannel = new QCameraChannel(mCameraHandle->camera_handle,
   7457                                   mCameraHandle->ops);
   7458     if (NULL == pChannel) {
   7459         LOGE("no mem for metadata channel");
   7460         return NO_MEMORY;
   7461     }
   7462 
   7463     rc = pChannel->init(NULL, NULL, this);
   7464     if (rc != NO_ERROR) {
   7465         LOGE("init Analysis channel failed, ret = %d", rc);
   7466         delete pChannel;
   7467         return rc;
   7468     }
   7469 
   7470     rc = addStreamToChannel(pChannel, CAM_STREAM_TYPE_ANALYSIS,
   7471                             NULL, this);
   7472     if (rc != NO_ERROR) {
   7473         LOGE("add Analysis stream failed, ret = %d", rc);
   7474         delete pChannel;
   7475         return rc;
   7476     }
   7477 
   7478     m_channels[QCAMERA_CH_TYPE_ANALYSIS] = pChannel;
   7479     return rc;
   7480 }
   7481 
   7482 
   7483 /*===========================================================================
   7484  * FUNCTION   : getPPConfig
   7485  *
   7486  * DESCRIPTION: get Post processing configaration data
   7487  *
   7488  * PARAMETERS :
   7489  * @pp config:  pp config structure pointer,
   7490  * @curIndex:  current pp channel index
   7491  * @multipass: Flag if multipass prcessing enabled.
   7492  *
   7493  * RETURN     : int32_t type of status
   7494  *              NO_ERROR  -- success
   7495  *              none-zero failure code
   7496  *==========================================================================*/
   7497 int32_t QCamera2HardwareInterface::getPPConfig(cam_pp_feature_config_t &pp_config,
   7498         int8_t curIndex, bool multipass)
   7499 {
   7500     int32_t rc = NO_ERROR;
   7501 
   7502     if (multipass) {
   7503         LOGW("Multi pass enabled. Total Pass = %d, cur index = %d",
   7504                 mParameters.getReprocCount(), curIndex);
   7505     }
   7506 
   7507     LOGH("Supported pproc feature mask = %llx",
   7508             gCamCapability[mCameraId]->qcom_supported_feature_mask);
   7509     cam_feature_mask_t feature_mask = gCamCapability[mCameraId]->qcom_supported_feature_mask;
   7510     int32_t zoomLevel = mParameters.getParmZoomLevel();
   7511     uint32_t rotation = mParameters.getJpegRotation();
   7512     int32_t effect = mParameters.getEffectValue();
   7513 
   7514     pp_config.cur_reproc_count = curIndex + 1;
   7515     pp_config.total_reproc_count = mParameters.getReprocCount();
   7516 
   7517     switch(curIndex) {
   7518         case 0:
   7519             //Configure feature mask for first pass of reprocessing
   7520             //check if any effects are enabled
   7521             if ((CAM_EFFECT_MODE_OFF != effect) &&
   7522                 (feature_mask & CAM_QCOM_FEATURE_EFFECT)) {
   7523                 pp_config.feature_mask |= CAM_QCOM_FEATURE_EFFECT;
   7524                 pp_config.effect = effect;
   7525             }
   7526 
   7527             //check for features that need to be enabled by default like sharpness
   7528             //(if supported by hw).
   7529             if ((feature_mask & CAM_QCOM_FEATURE_SHARPNESS) &&
   7530                 !mParameters.isOptiZoomEnabled()) {
   7531                 pp_config.feature_mask |= CAM_QCOM_FEATURE_SHARPNESS;
   7532                 pp_config.sharpness = mParameters.getSharpness();
   7533             }
   7534 
   7535             //check if zoom is enabled
   7536             if ((zoomLevel > 0) && (feature_mask & CAM_QCOM_FEATURE_CROP)) {
   7537                 pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
   7538             }
   7539 
   7540             if (mParameters.isWNREnabled() &&
   7541                 (feature_mask & CAM_QCOM_FEATURE_DENOISE2D)) {
   7542                 pp_config.feature_mask |= CAM_QCOM_FEATURE_DENOISE2D;
   7543                 pp_config.denoise2d.denoise_enable = 1;
   7544                 pp_config.denoise2d.process_plates =
   7545                         mParameters.getDenoiseProcessPlate(CAM_INTF_PARM_WAVELET_DENOISE);
   7546             }
   7547 
   7548             if (isCACEnabled()) {
   7549                 pp_config.feature_mask |= CAM_QCOM_FEATURE_CAC;
   7550             }
   7551 
   7552             //check if rotation is required
   7553             if ((feature_mask & CAM_QCOM_FEATURE_ROTATION) && (rotation > 0)) {
   7554                 pp_config.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
   7555                 if (rotation == 0) {
   7556                     pp_config.rotation = ROTATE_0;
   7557                 } else if (rotation == 90) {
   7558                     pp_config.rotation = ROTATE_90;
   7559                 } else if (rotation == 180) {
   7560                     pp_config.rotation = ROTATE_180;
   7561                 } else if (rotation == 270) {
   7562                     pp_config.rotation = ROTATE_270;
   7563                 }
   7564             }
   7565 
   7566             if (mParameters.isHDREnabled()){
   7567                 pp_config.feature_mask |= CAM_QCOM_FEATURE_HDR;
   7568                 pp_config.hdr_param.hdr_enable = 1;
   7569                 pp_config.hdr_param.hdr_need_1x = mParameters.isHDR1xFrameEnabled();
   7570                 pp_config.hdr_param.hdr_mode = CAM_HDR_MODE_MULTIFRAME;
   7571             } else {
   7572                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_HDR;
   7573                 pp_config.hdr_param.hdr_enable = 0;
   7574             }
   7575 
   7576             //check if scaling is enabled
   7577             if ((feature_mask & CAM_QCOM_FEATURE_SCALE) &&
   7578                 mParameters.isReprocScaleEnabled() &&
   7579                 mParameters.isUnderReprocScaling()){
   7580                 pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
   7581                 mParameters.getPicSizeFromAPK(
   7582                         pp_config.scale_param.output_width,
   7583                         pp_config.scale_param.output_height);
   7584             }
   7585 
   7586             if(mParameters.isUbiFocusEnabled()) {
   7587                 pp_config.feature_mask |= CAM_QCOM_FEATURE_UBIFOCUS;
   7588             } else {
   7589                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_UBIFOCUS;
   7590             }
   7591 
   7592             if(mParameters.isUbiRefocus()) {
   7593                 pp_config.feature_mask |= CAM_QCOM_FEATURE_REFOCUS;
   7594                 pp_config.misc_buf_param.misc_buffer_index = 0;
   7595             } else {
   7596                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_REFOCUS;
   7597             }
   7598 
   7599             if(mParameters.isChromaFlashEnabled()) {
   7600                 pp_config.feature_mask |= CAM_QCOM_FEATURE_CHROMA_FLASH;
   7601                 pp_config.flash_value = CAM_FLASH_ON;
   7602             } else {
   7603                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_CHROMA_FLASH;
   7604             }
   7605 
   7606             if(mParameters.isOptiZoomEnabled() && (0 <= zoomLevel)) {
   7607                 pp_config.feature_mask |= CAM_QCOM_FEATURE_OPTIZOOM;
   7608                 pp_config.zoom_level = (uint8_t) zoomLevel;
   7609             } else {
   7610                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_OPTIZOOM;
   7611             }
   7612 
   7613             if (mParameters.getofflineRAW()) {
   7614                 pp_config.feature_mask |= CAM_QCOM_FEATURE_RAW_PROCESSING;
   7615             }
   7616 
   7617             if (mParameters.isTruePortraitEnabled()) {
   7618                 pp_config.feature_mask |= CAM_QCOM_FEATURE_TRUEPORTRAIT;
   7619                 pp_config.misc_buf_param.misc_buffer_index = 0;
   7620             } else {
   7621                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_TRUEPORTRAIT;
   7622             }
   7623 
   7624             if(mParameters.isStillMoreEnabled()) {
   7625                 pp_config.feature_mask |= CAM_QCOM_FEATURE_STILLMORE;
   7626             } else {
   7627                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_STILLMORE;
   7628             }
   7629 
   7630             if (mParameters.isOEMFeatEnabled()) {
   7631                 pp_config.feature_mask |= CAM_OEM_FEATURE_1;
   7632             }
   7633 
   7634             if (mParameters.getCDSMode() != CAM_CDS_MODE_OFF) {
   7635                 if (feature_mask & CAM_QCOM_FEATURE_DSDN) {
   7636                     pp_config.feature_mask |= CAM_QCOM_FEATURE_DSDN;
   7637                 } else {
   7638                     pp_config.feature_mask |= CAM_QCOM_FEATURE_CDS;
   7639                 }
   7640             }
   7641 
   7642             if ((multipass) &&
   7643                     (m_postprocessor.getPPChannelCount() > 1)) {
   7644                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_PP_PASS_2;
   7645                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_ROTATION;
   7646                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_CDS;
   7647                 pp_config.feature_mask &= ~CAM_QCOM_FEATURE_DSDN;
   7648                 pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
   7649             } else {
   7650                 pp_config.feature_mask |= CAM_QCOM_FEATURE_SCALE;
   7651             }
   7652 
   7653             cam_dimension_t thumb_src_dim;
   7654             cam_dimension_t thumb_dst_dim;
   7655             mParameters.getThumbnailSize(&(thumb_dst_dim.width), &(thumb_dst_dim.height));
   7656             mParameters.getStreamDimension(CAM_STREAM_TYPE_POSTVIEW,thumb_src_dim);
   7657             if ((thumb_dst_dim.width != thumb_src_dim.width) ||
   7658                     (thumb_dst_dim.height != thumb_src_dim.height)) {
   7659                 if (thumb_dst_dim.width != 0 && thumb_dst_dim.height != 0) {
   7660                     pp_config.feature_mask |= CAM_QCOM_FEATURE_CROP;
   7661                 }
   7662             }
   7663 
   7664             break;
   7665 
   7666         case 1:
   7667             //Configure feature mask for second pass of reprocessing
   7668             pp_config.feature_mask |= CAM_QCOM_FEATURE_PP_PASS_2;
   7669             if ((feature_mask & CAM_QCOM_FEATURE_ROTATION) && (rotation > 0)) {
   7670                 pp_config.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
   7671                 if (rotation == 0) {
   7672                     pp_config.rotation = ROTATE_0;
   7673                 } else if (rotation == 90) {
   7674                     pp_config.rotation = ROTATE_90;
   7675                 } else if (rotation == 180) {
   7676                     pp_config.rotation = ROTATE_180;
   7677                 } else if (rotation == 270) {
   7678                     pp_config.rotation = ROTATE_270;
   7679                 }
   7680             }
   7681             if (mParameters.getCDSMode() != CAM_CDS_MODE_OFF) {
   7682                 if (feature_mask & CAM_QCOM_FEATURE_DSDN) {
   7683                     pp_config.feature_mask |= CAM_QCOM_FEATURE_DSDN;
   7684                 } else {
   7685                     pp_config.feature_mask |= CAM_QCOM_FEATURE_CDS;
   7686                 }
   7687             }
   7688             pp_config.feature_mask &= ~CAM_QCOM_FEATURE_RAW_PROCESSING;
   7689             pp_config.feature_mask &= ~CAM_QCOM_FEATURE_METADATA_PROCESSING;
   7690             break;
   7691 
   7692     }
   7693     LOGH("pproc feature mask set = %llx pass count = %d",
   7694              pp_config.feature_mask, curIndex);
   7695     return rc;
   7696 }
   7697 
   7698 /*===========================================================================
   7699  * FUNCTION   : addReprocChannel
   7700  *
   7701  * DESCRIPTION: add a reprocess channel that will do reprocess on frames
   7702  *              coming from input channel
   7703  *
   7704  * PARAMETERS :
   7705  *   @pInputChannel : ptr to input channel whose frames will be post-processed
   7706  *   @cur_channel_index : Current channel index in multipass
   7707  *
   7708  * RETURN     : Ptr to the newly created channel obj. NULL if failed.
   7709  *==========================================================================*/
   7710 QCameraReprocessChannel *QCamera2HardwareInterface::addReprocChannel(
   7711         QCameraChannel *pInputChannel, int8_t cur_channel_index)
   7712 {
   7713     int32_t rc = NO_ERROR;
   7714     QCameraReprocessChannel *pChannel = NULL;
   7715     uint32_t burst_cnt = mParameters.getNumOfSnapshots();
   7716 
   7717     if (pInputChannel == NULL) {
   7718         LOGE("input channel obj is NULL");
   7719         return NULL;
   7720     }
   7721 
   7722     pChannel = new QCameraReprocessChannel(mCameraHandle->camera_handle,
   7723                                            mCameraHandle->ops);
   7724     if (NULL == pChannel) {
   7725         LOGE("no mem for reprocess channel");
   7726         return NULL;
   7727     }
   7728 
   7729     // Capture channel, only need snapshot and postview streams start together
   7730     mm_camera_channel_attr_t attr;
   7731     memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
   7732     attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
   7733     attr.max_unmatched_frames = mParameters.getMaxUnmatchedFramesInQueue();
   7734     rc = pChannel->init(&attr,
   7735                         postproc_channel_cb_routine,
   7736                         this);
   7737     if (rc != NO_ERROR) {
   7738         LOGE("init reprocess channel failed, ret = %d", rc);
   7739         delete pChannel;
   7740         return NULL;
   7741     }
   7742 
   7743     // pp feature config
   7744     cam_pp_feature_config_t pp_config;
   7745     memset(&pp_config, 0, sizeof(cam_pp_feature_config_t));
   7746 
   7747     rc = getPPConfig(pp_config, cur_channel_index,
   7748             ((mParameters.getReprocCount() > 1) ? TRUE : FALSE));
   7749     if (rc != NO_ERROR){
   7750         LOGE("Error while creating PP config");
   7751         delete pChannel;
   7752         return NULL;
   7753     }
   7754 
   7755     uint8_t minStreamBufNum = getBufNumRequired(CAM_STREAM_TYPE_OFFLINE_PROC);
   7756 
   7757     //WNR and HDR happen inline. No extra buffers needed.
   7758     cam_feature_mask_t temp_feature_mask = pp_config.feature_mask;
   7759     temp_feature_mask &= ~CAM_QCOM_FEATURE_HDR;
   7760     if (temp_feature_mask && mParameters.isHDREnabled()) {
   7761         minStreamBufNum = (uint8_t)(1 + mParameters.getNumOfExtraHDRInBufsIfNeeded());
   7762     }
   7763 
   7764     if (mParameters.isStillMoreEnabled()) {
   7765         cam_still_more_t stillmore_config = mParameters.getStillMoreSettings();
   7766         pp_config.burst_cnt = stillmore_config.burst_count;
   7767         LOGH("Stillmore burst %d", pp_config.burst_cnt);
   7768 
   7769         // getNumOfExtraBuffersForImageProc returns 1 less buffer assuming
   7770         // number of capture is already added. In the case of liveshot,
   7771         // stillmore burst is 1. This is to account for the premature decrement
   7772         if (mParameters.getNumOfExtraBuffersForImageProc() == 0) {
   7773             minStreamBufNum += 1;
   7774         }
   7775     }
   7776 
   7777     if (mParameters.getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_3) {
   7778         minStreamBufNum += mParameters.getReprocCount() - 1;
   7779         burst_cnt = mParameters.getReprocCount();
   7780         if (cur_channel_index == 0) {
   7781             pChannel->setReprocCount(2);
   7782         } else {
   7783             pChannel->setReprocCount(1);
   7784         }
   7785     } else {
   7786         pChannel->setReprocCount(1);
   7787     }
   7788 
   7789     // Add non inplace image lib buffers only when ppproc is present,
   7790     // becuase pproc is non inplace and input buffers for img lib
   7791     // are output for pproc and this number of extra buffers is required
   7792     // If pproc is not there, input buffers for imglib are from snapshot stream
   7793     uint8_t imglib_extra_bufs = mParameters.getNumOfExtraBuffersForImageProc();
   7794     if (temp_feature_mask && imglib_extra_bufs) {
   7795         // 1 is added because getNumOfExtraBuffersForImageProc returns extra
   7796         // buffers assuming number of capture is already added
   7797         minStreamBufNum = (uint8_t)(minStreamBufNum + imglib_extra_bufs + 1);
   7798     }
   7799 
   7800     //Mask out features that are already processed in snapshot stream.
   7801     cam_feature_mask_t snapshot_feature_mask = 0;
   7802     mParameters.getStreamPpMask(CAM_STREAM_TYPE_SNAPSHOT, snapshot_feature_mask);
   7803 
   7804     pp_config.feature_mask &= ~snapshot_feature_mask;
   7805     LOGH("Snapshot feature mask: 0x%llx, reproc feature mask: 0x%llx",
   7806             snapshot_feature_mask, pp_config.feature_mask);
   7807 
   7808     bool offlineReproc = isRegularCapture();
   7809     if (m_postprocessor.mOfflineDataBufs != NULL) {
   7810         offlineReproc = TRUE;
   7811     }
   7812 
   7813     cam_padding_info_t paddingInfo = gCamCapability[mCameraId]->padding_info;
   7814     paddingInfo.offset_info.offset_x = 0;
   7815     paddingInfo.offset_info.offset_y = 0;
   7816     rc = pChannel->addReprocStreamsFromSource(*this,
   7817                                               pp_config,
   7818                                               pInputChannel,
   7819                                               minStreamBufNum,
   7820                                               burst_cnt,
   7821                                               &paddingInfo,
   7822                                               mParameters,
   7823                                               mLongshotEnabled,
   7824                                               offlineReproc);
   7825     if (rc != NO_ERROR) {
   7826         delete pChannel;
   7827         return NULL;
   7828     }
   7829 
   7830     return pChannel;
   7831 }
   7832 
   7833 /*===========================================================================
   7834  * FUNCTION   : addOfflineReprocChannel
   7835  *
   7836  * DESCRIPTION: add a offline reprocess channel contains one reproc stream,
   7837  *              that will do reprocess on frames coming from external images
   7838  *
   7839  * PARAMETERS :
   7840  *   @img_config  : offline reporcess image info
   7841  *   @pp_feature  : pp feature config
   7842  *
   7843  * RETURN     : int32_t type of status
   7844  *              NO_ERROR  -- success
   7845  *              none-zero failure code
   7846  *==========================================================================*/
   7847 QCameraReprocessChannel *QCamera2HardwareInterface::addOfflineReprocChannel(
   7848                                             cam_pp_offline_src_config_t &img_config,
   7849                                             cam_pp_feature_config_t &pp_feature,
   7850                                             stream_cb_routine stream_cb,
   7851                                             void *userdata)
   7852 {
   7853     int32_t rc = NO_ERROR;
   7854     QCameraReprocessChannel *pChannel = NULL;
   7855 
   7856     pChannel = new QCameraReprocessChannel(mCameraHandle->camera_handle,
   7857                                            mCameraHandle->ops);
   7858     if (NULL == pChannel) {
   7859         LOGE("no mem for reprocess channel");
   7860         return NULL;
   7861     }
   7862 
   7863     rc = pChannel->init(NULL, NULL, NULL);
   7864     if (rc != NO_ERROR) {
   7865         LOGE("init reprocess channel failed, ret = %d", rc);
   7866         delete pChannel;
   7867         return NULL;
   7868     }
   7869 
   7870     QCameraHeapMemory *pStreamInfo = allocateStreamInfoBuf(CAM_STREAM_TYPE_OFFLINE_PROC);
   7871     if (pStreamInfo == NULL) {
   7872         LOGE("no mem for stream info buf");
   7873         delete pChannel;
   7874         return NULL;
   7875     }
   7876 
   7877     cam_stream_info_t *streamInfoBuf = (cam_stream_info_t *)pStreamInfo->getPtr(0);
   7878     memset(streamInfoBuf, 0, sizeof(cam_stream_info_t));
   7879     streamInfoBuf->stream_type = CAM_STREAM_TYPE_OFFLINE_PROC;
   7880     streamInfoBuf->fmt = img_config.input_fmt;
   7881     streamInfoBuf->dim = img_config.input_dim;
   7882     streamInfoBuf->buf_planes = img_config.input_buf_planes;
   7883     streamInfoBuf->streaming_mode = CAM_STREAMING_MODE_BURST;
   7884     streamInfoBuf->num_of_burst = img_config.num_of_bufs;
   7885 
   7886     streamInfoBuf->reprocess_config.pp_type = CAM_OFFLINE_REPROCESS_TYPE;
   7887     streamInfoBuf->reprocess_config.offline = img_config;
   7888     streamInfoBuf->reprocess_config.pp_feature_config = pp_feature;
   7889 
   7890     rc = pChannel->addStream(*this,
   7891             pStreamInfo, NULL, img_config.num_of_bufs,
   7892             &gCamCapability[mCameraId]->padding_info,
   7893             stream_cb, userdata, false);
   7894 
   7895     if (rc != NO_ERROR) {
   7896         LOGE("add reprocess stream failed, ret = %d", rc);
   7897         delete pChannel;
   7898         return NULL;
   7899     }
   7900 
   7901     return pChannel;
   7902 }
   7903 
   7904 /*===========================================================================
   7905  * FUNCTION   : addChannel
   7906  *
   7907  * DESCRIPTION: add a channel by its type
   7908  *
   7909  * PARAMETERS :
   7910  *   @ch_type : channel type
   7911  *
   7912  * RETURN     : int32_t type of status
   7913  *              NO_ERROR  -- success
   7914  *              none-zero failure code
   7915  *==========================================================================*/
   7916 int32_t QCamera2HardwareInterface::addChannel(qcamera_ch_type_enum_t ch_type)
   7917 {
   7918     int32_t rc = UNKNOWN_ERROR;
   7919     switch (ch_type) {
   7920     case QCAMERA_CH_TYPE_ZSL:
   7921         rc = addZSLChannel();
   7922         break;
   7923     case QCAMERA_CH_TYPE_CAPTURE:
   7924         rc = addCaptureChannel();
   7925         break;
   7926     case QCAMERA_CH_TYPE_PREVIEW:
   7927         rc = addPreviewChannel();
   7928         break;
   7929     case QCAMERA_CH_TYPE_VIDEO:
   7930         rc = addVideoChannel();
   7931         break;
   7932     case QCAMERA_CH_TYPE_SNAPSHOT:
   7933         rc = addSnapshotChannel();
   7934         break;
   7935     case QCAMERA_CH_TYPE_RAW:
   7936         rc = addRawChannel();
   7937         break;
   7938     case QCAMERA_CH_TYPE_METADATA:
   7939         rc = addMetaDataChannel();
   7940         break;
   7941     case QCAMERA_CH_TYPE_CALLBACK:
   7942         rc = addCallbackChannel();
   7943         break;
   7944     case QCAMERA_CH_TYPE_ANALYSIS:
   7945         rc = addAnalysisChannel();
   7946         break;
   7947     default:
   7948         break;
   7949     }
   7950     return rc;
   7951 }
   7952 
   7953 /*===========================================================================
   7954  * FUNCTION   : delChannel
   7955  *
   7956  * DESCRIPTION: delete a channel by its type
   7957  *
   7958  * PARAMETERS :
   7959  *   @ch_type : channel type
   7960  *   @destroy : delete context as well
   7961  *
   7962  * RETURN     : int32_t type of status
   7963  *              NO_ERROR  -- success
   7964  *              none-zero failure code
   7965  *==========================================================================*/
   7966 int32_t QCamera2HardwareInterface::delChannel(qcamera_ch_type_enum_t ch_type,
   7967                                               bool destroy)
   7968 {
   7969     if (m_channels[ch_type] != NULL) {
   7970         if (destroy) {
   7971             delete m_channels[ch_type];
   7972             m_channels[ch_type] = NULL;
   7973         } else {
   7974             m_channels[ch_type]->deleteChannel();
   7975         }
   7976     }
   7977 
   7978     return NO_ERROR;
   7979 }
   7980 
   7981 /*===========================================================================
   7982  * FUNCTION   : startChannel
   7983  *
   7984  * DESCRIPTION: start a channel by its type
   7985  *
   7986  * PARAMETERS :
   7987  *   @ch_type : channel type
   7988  *
   7989  * RETURN     : int32_t type of status
   7990  *              NO_ERROR  -- success
   7991  *              none-zero failure code
   7992  *==========================================================================*/
   7993 int32_t QCamera2HardwareInterface::startChannel(qcamera_ch_type_enum_t ch_type)
   7994 {
   7995     int32_t rc = UNKNOWN_ERROR;
   7996     if (m_channels[ch_type] != NULL) {
   7997         rc = m_channels[ch_type]->start();
   7998     }
   7999     return rc;
   8000 }
   8001 
   8002 /*===========================================================================
   8003  * FUNCTION   : stopChannel
   8004  *
   8005  * DESCRIPTION: stop a channel by its type
   8006  *
   8007  * PARAMETERS :
   8008  *   @ch_type : channel type
   8009  *
   8010  * RETURN     : int32_t type of status
   8011  *              NO_ERROR  -- success
   8012  *              none-zero failure code
   8013  *==========================================================================*/
   8014 int32_t QCamera2HardwareInterface::stopChannel(qcamera_ch_type_enum_t ch_type)
   8015 {
   8016     int32_t rc = UNKNOWN_ERROR;
   8017     if (m_channels[ch_type] != NULL) {
   8018         rc = m_channels[ch_type]->stop();
   8019     }
   8020 
   8021     return rc;
   8022 }
   8023 
   8024 /*===========================================================================
   8025  * FUNCTION   : preparePreview
   8026  *
   8027  * DESCRIPTION: add channels needed for preview
   8028  *
   8029  * PARAMETERS : none
   8030  *
   8031  * RETURN     : int32_t type of status
   8032  *              NO_ERROR  -- success
   8033  *              none-zero failure code
   8034  *==========================================================================*/
   8035 int32_t QCamera2HardwareInterface::preparePreview()
   8036 {
   8037     ATRACE_CALL();
   8038     int32_t rc = NO_ERROR;
   8039 
   8040     LOGI("E");
   8041     rc = mParameters.setStreamConfigure(false, false, false);
   8042     if (rc != NO_ERROR) {
   8043         LOGE("setStreamConfigure failed %d", rc);
   8044         return rc;
   8045     }
   8046 
   8047     if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() != true) {
   8048         rc = addChannel(QCAMERA_CH_TYPE_ZSL);
   8049         if (rc != NO_ERROR) {
   8050             LOGE("failed!! rc = %d", rc);
   8051             return rc;
   8052         }
   8053 
   8054         if (mParameters.isUBWCEnabled()) {
   8055             cam_format_t fmt;
   8056             mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW, fmt);
   8057             if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
   8058                 rc = addChannel(QCAMERA_CH_TYPE_CALLBACK);
   8059                 if (rc != NO_ERROR) {
   8060                     delChannel(QCAMERA_CH_TYPE_ZSL);
   8061                     LOGE("failed!! rc = %d", rc);
   8062                     return rc;
   8063                 }
   8064             }
   8065         }
   8066 
   8067         if (mParameters.getofflineRAW()) {
   8068             addChannel(QCAMERA_CH_TYPE_RAW);
   8069         }
   8070     } else {
   8071         bool recordingHint = mParameters.getRecordingHintValue();
   8072         if(!isRdiMode() && recordingHint) {
   8073             //stop face detection,longshot,etc if turned ON in Camera mode
   8074 #ifndef VANILLA_HAL
   8075             int32_t arg; //dummy arg
   8076             if (isLongshotEnabled()) {
   8077                 sendCommand(CAMERA_CMD_LONGSHOT_OFF, arg, arg);
   8078             }
   8079             if (mParameters.isFaceDetectionEnabled()
   8080                     && (!mParameters.fdModeInVideo())) {
   8081                 sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, arg, arg);
   8082             }
   8083             if (mParameters.isHistogramEnabled()) {
   8084                 sendCommand(CAMERA_CMD_HISTOGRAM_OFF, arg, arg);
   8085             }
   8086 #endif
   8087             //Don't create snapshot channel for liveshot, if low power mode is set.
   8088             //Use video stream instead.
   8089             if (!isLowPowerMode()) {
   8090                rc = addChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   8091                if (rc != NO_ERROR) {
   8092                    return rc;
   8093                }
   8094             }
   8095 
   8096             rc = addChannel(QCAMERA_CH_TYPE_VIDEO);
   8097             if (rc != NO_ERROR) {
   8098                 delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   8099                 LOGE("failed!! rc = %d", rc);
   8100                 return rc;
   8101             }
   8102         }
   8103 
   8104         rc = addChannel(QCAMERA_CH_TYPE_PREVIEW);
   8105         if (!isRdiMode() && (rc != NO_ERROR)) {
   8106             if (recordingHint) {
   8107                 delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   8108                 delChannel(QCAMERA_CH_TYPE_VIDEO);
   8109             }
   8110         }
   8111 
   8112         if (mParameters.isUBWCEnabled() && !recordingHint) {
   8113             cam_format_t fmt;
   8114             mParameters.getStreamFormat(CAM_STREAM_TYPE_PREVIEW, fmt);
   8115             if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
   8116                 rc = addChannel(QCAMERA_CH_TYPE_CALLBACK);
   8117                 if (rc != NO_ERROR) {
   8118                     delChannel(QCAMERA_CH_TYPE_PREVIEW);
   8119                     if (!isRdiMode()) {
   8120                         delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   8121                         delChannel(QCAMERA_CH_TYPE_VIDEO);
   8122                     }
   8123                     LOGE("failed!! rc = %d", rc);
   8124                     return rc;
   8125                 }
   8126             }
   8127         }
   8128 
   8129         if (NO_ERROR != rc) {
   8130             delChannel(QCAMERA_CH_TYPE_PREVIEW);
   8131             LOGE("failed!! rc = %d", rc);
   8132         }
   8133     }
   8134 
   8135     LOGI("X rc = %d", rc);
   8136     return rc;
   8137 }
   8138 
   8139 /*===========================================================================
   8140  * FUNCTION   : unpreparePreview
   8141  *
   8142  * DESCRIPTION: delete channels for preview
   8143  *
   8144  * PARAMETERS : none
   8145  *
   8146  * RETURN     : none
   8147  *==========================================================================*/
   8148 void QCamera2HardwareInterface::unpreparePreview()
   8149 {
   8150     delChannel(QCAMERA_CH_TYPE_ZSL);
   8151     delChannel(QCAMERA_CH_TYPE_PREVIEW);
   8152     delChannel(QCAMERA_CH_TYPE_VIDEO);
   8153     delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
   8154     delChannel(QCAMERA_CH_TYPE_CALLBACK);
   8155     delChannel(QCAMERA_CH_TYPE_RAW);
   8156 }
   8157 
   8158 /*===========================================================================
   8159  * FUNCTION   : playShutter
   8160  *
   8161  * DESCRIPTION: send request to play shutter sound
   8162  *
   8163  * PARAMETERS : none
   8164  *
   8165  * RETURN     : none
   8166  *==========================================================================*/
   8167 void QCamera2HardwareInterface::playShutter(){
   8168      if (mNotifyCb == NULL ||
   8169          msgTypeEnabledWithLock(CAMERA_MSG_SHUTTER) == 0){
   8170          LOGD("shutter msg not enabled or NULL cb");
   8171          return;
   8172      }
   8173      LOGH("CAMERA_MSG_SHUTTER ");
   8174      qcamera_callback_argm_t cbArg;
   8175      memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   8176      cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
   8177      cbArg.msg_type = CAMERA_MSG_SHUTTER;
   8178      cbArg.ext1 = 0;
   8179      cbArg.ext2 = false;
   8180      m_cbNotifier.notifyCallback(cbArg);
   8181 }
   8182 
   8183 /*===========================================================================
   8184  * FUNCTION   : getChannelByHandle
   8185  *
   8186  * DESCRIPTION: return a channel by its handle
   8187  *
   8188  * PARAMETERS :
   8189  *   @channelHandle : channel handle
   8190  *
   8191  * RETURN     : a channel obj if found, NULL if not found
   8192  *==========================================================================*/
   8193 QCameraChannel *QCamera2HardwareInterface::getChannelByHandle(uint32_t channelHandle)
   8194 {
   8195     for(int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
   8196         if (m_channels[i] != NULL &&
   8197             m_channels[i]->getMyHandle() == channelHandle) {
   8198             return m_channels[i];
   8199         }
   8200     }
   8201 
   8202     return NULL;
   8203 }
   8204 /*===========================================================================
   8205  * FUNCTION   : needPreviewFDCallback
   8206  *
   8207  * DESCRIPTION: decides if needPreviewFDCallback
   8208  *
   8209  * PARAMETERS :
   8210  *   @num_faces : number of faces
   8211  *
   8212  * RETURN     : bool type of status
   8213  *              true  -- success
   8214  *              fale -- failure code
   8215  *==========================================================================*/
   8216 bool QCamera2HardwareInterface::needPreviewFDCallback(uint8_t num_faces)
   8217 {
   8218     if (num_faces == 0 && mNumPreviewFaces == 0) {
   8219         return false;
   8220     }
   8221 
   8222     return true;
   8223 }
   8224 
   8225 /*===========================================================================
   8226  * FUNCTION   : processFaceDetectionReuslt
   8227  *
   8228  * DESCRIPTION: process face detection reuslt
   8229  *
   8230  * PARAMETERS :
   8231  *   @faces_data : ptr to face processing result struct
   8232  *
   8233  * RETURN     : int32_t type of status
   8234  *              NO_ERROR  -- success
   8235  *              none-zero failure code
   8236  *==========================================================================*/
   8237 int32_t QCamera2HardwareInterface::processFaceDetectionResult(cam_faces_data_t *faces_data)
   8238 {
   8239     if (!mParameters.isFaceDetectionEnabled()) {
   8240         LOGH("FaceDetection not enabled, no ops here");
   8241         return NO_ERROR;
   8242     }
   8243 
   8244     qcamera_face_detect_type_t fd_type = faces_data->detection_data.fd_type;
   8245     cam_face_detection_data_t *detect_data = &(faces_data->detection_data);
   8246     if ((NULL == mDataCb) ||
   8247         (fd_type == QCAMERA_FD_PREVIEW && !msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA)) ||
   8248         (!needPreviewFDCallback(detect_data->num_faces_detected))
   8249 #ifndef VANILLA_HAL
   8250         || (fd_type == QCAMERA_FD_SNAPSHOT && !msgTypeEnabled(CAMERA_MSG_META_DATA))
   8251 #endif
   8252         ) {
   8253         LOGH("metadata msgtype not enabled, no ops here");
   8254         return NO_ERROR;
   8255     }
   8256 
   8257     if ((fd_type == QCAMERA_FD_PREVIEW) && (detect_data->update_flag == FALSE)) {
   8258         // Don't send callback to app if this is skipped by fd at backend
   8259         return NO_ERROR;
   8260     }
   8261 
   8262     cam_dimension_t display_dim;
   8263     mParameters.getStreamDimension(CAM_STREAM_TYPE_PREVIEW, display_dim);
   8264     if (display_dim.width <= 0 || display_dim.height <= 0) {
   8265         LOGE("Invalid preview width or height (%d x %d)",
   8266                display_dim.width, display_dim.height);
   8267         return UNKNOWN_ERROR;
   8268     }
   8269 
   8270     // process face detection result
   8271     // need separate face detection in preview or snapshot type
   8272     size_t faceResultSize = 0;
   8273     size_t data_len = 0;
   8274     if(fd_type == QCAMERA_FD_PREVIEW){
   8275         //fd for preview frames
   8276         faceResultSize = sizeof(camera_frame_metadata_t);
   8277         faceResultSize += sizeof(camera_face_t) * MAX_ROI;
   8278     }else if(fd_type == QCAMERA_FD_SNAPSHOT){
   8279 #ifndef VANILLA_HAL
   8280         // fd for snapshot frames
   8281         //check if face is detected in this frame
   8282         if(detect_data->num_faces_detected > 0){
   8283             data_len = sizeof(camera_frame_metadata_t) +
   8284                     sizeof(camera_face_t) * detect_data->num_faces_detected;
   8285         }else{
   8286             //no face
   8287             data_len = 0;
   8288         }
   8289 #endif
   8290         faceResultSize = 1 *sizeof(int)    //meta data type
   8291                        + 1 *sizeof(int)    // meta data len
   8292                        + data_len;         //data
   8293     }
   8294 
   8295     camera_memory_t *faceResultBuffer = mGetMemory(-1,
   8296                                                    faceResultSize,
   8297                                                    1,
   8298                                                    mCallbackCookie);
   8299     if ( NULL == faceResultBuffer ) {
   8300         LOGE("Not enough memory for face result data");
   8301         return NO_MEMORY;
   8302     }
   8303 
   8304     unsigned char *pFaceResult = ( unsigned char * ) faceResultBuffer->data;
   8305     memset(pFaceResult, 0, faceResultSize);
   8306     unsigned char *faceData = NULL;
   8307     if(fd_type == QCAMERA_FD_PREVIEW){
   8308         faceData = pFaceResult;
   8309         mNumPreviewFaces = detect_data->num_faces_detected;
   8310     }else if(fd_type == QCAMERA_FD_SNAPSHOT){
   8311 #ifndef VANILLA_HAL
   8312         //need fill meta type and meta data len first
   8313         int *data_header = (int* )pFaceResult;
   8314         data_header[0] = CAMERA_META_DATA_FD;
   8315         data_header[1] = (int)data_len;
   8316 
   8317         if(data_len <= 0){
   8318             //if face is not valid or do not have face, return
   8319             qcamera_callback_argm_t cbArg;
   8320             memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   8321             cbArg.cb_type = QCAMERA_DATA_CALLBACK;
   8322             cbArg.msg_type = CAMERA_MSG_META_DATA;
   8323             cbArg.data = faceResultBuffer;
   8324             cbArg.user_data = faceResultBuffer;
   8325             cbArg.cookie = this;
   8326             cbArg.release_cb = releaseCameraMemory;
   8327             int32_t rc = m_cbNotifier.notifyCallback(cbArg);
   8328             if (rc != NO_ERROR) {
   8329                 LOGE("fail sending notification");
   8330                 faceResultBuffer->release(faceResultBuffer);
   8331             }
   8332             return rc;
   8333         }
   8334 #endif
   8335         faceData = pFaceResult + 2 *sizeof(int); //skip two int length
   8336     }
   8337 
   8338     camera_frame_metadata_t *roiData = (camera_frame_metadata_t * ) faceData;
   8339     camera_face_t *faces = (camera_face_t *) ( faceData + sizeof(camera_frame_metadata_t) );
   8340 
   8341     roiData->number_of_faces = detect_data->num_faces_detected;
   8342     roiData->faces = faces;
   8343     if (roiData->number_of_faces > 0) {
   8344         for (int i = 0; i < roiData->number_of_faces; i++) {
   8345             faces[i].id = detect_data->faces[i].face_id;
   8346             faces[i].score = detect_data->faces[i].score;
   8347 
   8348             // left
   8349             faces[i].rect[0] = MAP_TO_DRIVER_COORDINATE(
   8350                     detect_data->faces[i].face_boundary.left,
   8351                     display_dim.width, 2000, -1000);
   8352 
   8353             // top
   8354             faces[i].rect[1] = MAP_TO_DRIVER_COORDINATE(
   8355                     detect_data->faces[i].face_boundary.top,
   8356                     display_dim.height, 2000, -1000);
   8357 
   8358             // right
   8359             faces[i].rect[2] = faces[i].rect[0] +
   8360                     MAP_TO_DRIVER_COORDINATE(
   8361                     detect_data->faces[i].face_boundary.width,
   8362                     display_dim.width, 2000, 0);
   8363 
   8364              // bottom
   8365             faces[i].rect[3] = faces[i].rect[1] +
   8366                     MAP_TO_DRIVER_COORDINATE(
   8367                     detect_data->faces[i].face_boundary.height,
   8368                     display_dim.height, 2000, 0);
   8369 
   8370             if (faces_data->landmark_valid) {
   8371                 // Center of left eye
   8372                 faces[i].left_eye[0] = MAP_TO_DRIVER_COORDINATE(
   8373                         faces_data->landmark_data.face_landmarks[i].left_eye_center.x,
   8374                         display_dim.width, 2000, -1000);
   8375                 faces[i].left_eye[1] = MAP_TO_DRIVER_COORDINATE(
   8376                         faces_data->landmark_data.face_landmarks[i].left_eye_center.y,
   8377                         display_dim.height, 2000, -1000);
   8378 
   8379                 // Center of right eye
   8380                 faces[i].right_eye[0] = MAP_TO_DRIVER_COORDINATE(
   8381                         faces_data->landmark_data.face_landmarks[i].right_eye_center.x,
   8382                         display_dim.width, 2000, -1000);
   8383                 faces[i].right_eye[1] = MAP_TO_DRIVER_COORDINATE(
   8384                         faces_data->landmark_data.face_landmarks[i].right_eye_center.y,
   8385                         display_dim.height, 2000, -1000);
   8386 
   8387                 // Center of mouth
   8388                 faces[i].mouth[0] = MAP_TO_DRIVER_COORDINATE(
   8389                         faces_data->landmark_data.face_landmarks[i].mouth_center.x,
   8390                         display_dim.width, 2000, -1000);
   8391                 faces[i].mouth[1] = MAP_TO_DRIVER_COORDINATE(
   8392                         faces_data->landmark_data.face_landmarks[i].mouth_center.y,
   8393                         display_dim.height, 2000, -1000);
   8394             } else {
   8395                 // return -2000 if invalid
   8396                 faces[i].left_eye[0] = -2000;
   8397                 faces[i].left_eye[1] = -2000;
   8398 
   8399                 faces[i].right_eye[0] = -2000;
   8400                 faces[i].right_eye[1] = -2000;
   8401 
   8402                 faces[i].mouth[0] = -2000;
   8403                 faces[i].mouth[1] = -2000;
   8404             }
   8405 
   8406 #ifndef VANILLA_HAL
   8407 #ifdef TARGET_TS_MAKEUP
   8408             mFaceRect.left = detect_data->faces[i].face_boundary.left;
   8409             mFaceRect.top = detect_data->faces[i].face_boundary.top;
   8410             mFaceRect.right = detect_data->faces[i].face_boundary.width+mFaceRect.left;
   8411             mFaceRect.bottom = detect_data->faces[i].face_boundary.height+mFaceRect.top;
   8412 #endif
   8413             if (faces_data->smile_valid) {
   8414                 faces[i].smile_degree = faces_data->smile_data.smile[i].smile_degree;
   8415                 faces[i].smile_score = faces_data->smile_data.smile[i].smile_confidence;
   8416             }
   8417             if (faces_data->blink_valid) {
   8418                 faces[i].blink_detected = faces_data->blink_data.blink[i].blink_detected;
   8419                 faces[i].leye_blink = faces_data->blink_data.blink[i].left_blink;
   8420                 faces[i].reye_blink = faces_data->blink_data.blink[i].right_blink;
   8421             }
   8422             if (faces_data->recog_valid) {
   8423                 faces[i].face_recognised = faces_data->recog_data.face_rec[i].face_recognised;
   8424             }
   8425             if (faces_data->gaze_valid) {
   8426                 faces[i].gaze_angle = faces_data->gaze_data.gaze[i].gaze_angle;
   8427                 faces[i].updown_dir = faces_data->gaze_data.gaze[i].updown_dir;
   8428                 faces[i].leftright_dir = faces_data->gaze_data.gaze[i].leftright_dir;
   8429                 faces[i].roll_dir = faces_data->gaze_data.gaze[i].roll_dir;
   8430                 faces[i].left_right_gaze = faces_data->gaze_data.gaze[i].left_right_gaze;
   8431                 faces[i].top_bottom_gaze = faces_data->gaze_data.gaze[i].top_bottom_gaze;
   8432             }
   8433 #endif
   8434 
   8435         }
   8436     }
   8437     else{
   8438 #ifdef TARGET_TS_MAKEUP
   8439         memset(&mFaceRect,-1,sizeof(mFaceRect));
   8440 #endif
   8441     }
   8442     qcamera_callback_argm_t cbArg;
   8443     memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   8444     cbArg.cb_type = QCAMERA_DATA_CALLBACK;
   8445     if(fd_type == QCAMERA_FD_PREVIEW){
   8446         cbArg.msg_type = CAMERA_MSG_PREVIEW_METADATA;
   8447     }
   8448 #ifndef VANILLA_HAL
   8449     else if(fd_type == QCAMERA_FD_SNAPSHOT){
   8450         cbArg.msg_type = CAMERA_MSG_META_DATA;
   8451     }
   8452 #endif
   8453     cbArg.data = faceResultBuffer;
   8454     cbArg.metadata = roiData;
   8455     cbArg.user_data = faceResultBuffer;
   8456     cbArg.cookie = this;
   8457     cbArg.release_cb = releaseCameraMemory;
   8458     int32_t rc = m_cbNotifier.notifyCallback(cbArg);
   8459     if (rc != NO_ERROR) {
   8460         LOGE("fail sending notification");
   8461         faceResultBuffer->release(faceResultBuffer);
   8462     }
   8463 
   8464     return rc;
   8465 }
   8466 
   8467 /*===========================================================================
   8468  * FUNCTION   : releaseCameraMemory
   8469  *
   8470  * DESCRIPTION: releases camera memory objects
   8471  *
   8472  * PARAMETERS :
   8473  *   @data    : buffer to be released
   8474  *   @cookie  : context data
   8475  *   @cbStatus: callback status
   8476  *
   8477  * RETURN     : None
   8478  *==========================================================================*/
   8479 void QCamera2HardwareInterface::releaseCameraMemory(void *data,
   8480                                                     void */*cookie*/,
   8481                                                     int32_t /*cbStatus*/)
   8482 {
   8483     camera_memory_t *mem = ( camera_memory_t * ) data;
   8484     if ( NULL != mem ) {
   8485         mem->release(mem);
   8486     }
   8487 }
   8488 
   8489 /*===========================================================================
   8490  * FUNCTION   : returnStreamBuffer
   8491  *
   8492  * DESCRIPTION: returns back a stream buffer
   8493  *
   8494  * PARAMETERS :
   8495  *   @data    : buffer to be released
   8496  *   @cookie  : context data
   8497  *   @cbStatus: callback status
   8498  *
   8499  * RETURN     : None
   8500  *==========================================================================*/
   8501 void QCamera2HardwareInterface::returnStreamBuffer(void *data,
   8502                                                    void *cookie,
   8503                                                    int32_t /*cbStatus*/)
   8504 {
   8505     QCameraStream *stream = ( QCameraStream * ) cookie;
   8506     int idx = *((int *)data);
   8507     if ((NULL != stream) && (0 <= idx)) {
   8508         stream->bufDone((uint32_t)idx);
   8509     } else {
   8510         LOGE("Cannot return buffer %d %p", idx, cookie);
   8511     }
   8512 }
   8513 
   8514 /*===========================================================================
   8515  * FUNCTION   : processHistogramStats
   8516  *
   8517  * DESCRIPTION: process histogram stats
   8518  *
   8519  * PARAMETERS :
   8520  *   @hist_data : ptr to histogram stats struct
   8521  *
   8522  * RETURN     : int32_t type of status
   8523  *              NO_ERROR  -- success
   8524  *              none-zero failure code
   8525  *==========================================================================*/
   8526 int32_t QCamera2HardwareInterface::processHistogramStats(
   8527         __unused cam_hist_stats_t &stats_data)
   8528 {
   8529 #ifndef VANILLA_HAL
   8530     if (!mParameters.isHistogramEnabled()) {
   8531         LOGH("Histogram not enabled, no ops here");
   8532         return NO_ERROR;
   8533     }
   8534 
   8535     camera_memory_t *histBuffer = mGetMemory(-1,
   8536                                              sizeof(cam_histogram_data_t),
   8537                                              1,
   8538                                              mCallbackCookie);
   8539     if ( NULL == histBuffer ) {
   8540         LOGE("Not enough memory for histogram data");
   8541         return NO_MEMORY;
   8542     }
   8543 
   8544     cam_histogram_data_t *pHistData = (cam_histogram_data_t *)histBuffer->data;
   8545     if (pHistData == NULL) {
   8546         LOGE("memory data ptr is NULL");
   8547         return UNKNOWN_ERROR;
   8548     }
   8549 
   8550     switch (stats_data.type) {
   8551     case CAM_HISTOGRAM_TYPE_BAYER:
   8552         *pHistData = stats_data.bayer_stats.gb_stats;
   8553         break;
   8554     case CAM_HISTOGRAM_TYPE_YUV:
   8555         *pHistData = stats_data.yuv_stats;
   8556         break;
   8557     }
   8558 
   8559     qcamera_callback_argm_t cbArg;
   8560     memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
   8561     cbArg.cb_type = QCAMERA_DATA_CALLBACK;
   8562     cbArg.msg_type = CAMERA_MSG_STATS_DATA;
   8563     cbArg.data = histBuffer;
   8564     cbArg.user_data = histBuffer;
   8565     cbArg.cookie = this;
   8566     cbArg.release_cb = releaseCameraMemory;
   8567     int32_t rc = m_cbNotifier.notifyCallback(cbArg);
   8568     if (rc != NO_ERROR) {
   8569         LOGE("fail sending notification");
   8570         histBuffer->release(histBuffer);
   8571     }
   8572 #endif
   8573     return NO_ERROR;
   8574 }
   8575 
   8576 /*===========================================================================
   8577  * FUNCTION   : calcThermalLevel
   8578  *
   8579  * DESCRIPTION: Calculates the target fps range depending on
   8580  *              the thermal level.
   8581  *              Note that this function can be called from QCameraParametersIntf
   8582  *              while mutex is held. So it should not call back into
   8583  *              QCameraParametersIntf causing deadlock.
   8584  *
   8585  * PARAMETERS :
   8586  *   @level      : received thermal level
   8587  *   @minFPS     : minimum configured fps range
   8588  *   @maxFPS     : maximum configured fps range
   8589  *   @minVideoFps: minimum configured fps range
   8590  *   @maxVideoFps: maximum configured fps range
   8591  *   @adjustedRange : target fps range
   8592  *   @skipPattern : target skip pattern
   8593  *
   8594  * RETURN     : int32_t type of status
   8595  *              NO_ERROR  -- success
   8596  *              none-zero failure code
   8597  *==========================================================================*/
   8598 int QCamera2HardwareInterface::calcThermalLevel(
   8599             qcamera_thermal_level_enum_t level,
   8600             const int minFPSi,
   8601             const int maxFPSi,
   8602             const float &minVideoFps,
   8603             const float &maxVideoFps,
   8604             cam_fps_range_t &adjustedRange,
   8605             enum msm_vfe_frame_skip_pattern &skipPattern)
   8606 {
   8607     const float minFPS = (float)minFPSi;
   8608     const float maxFPS = (float)maxFPSi;
   8609 
   8610     LOGH("level: %d, preview minfps %f, preview maxfpS %f, "
   8611               "video minfps %f, video maxfpS %f",
   8612              level, minFPS, maxFPS, minVideoFps, maxVideoFps);
   8613 
   8614     switch(level) {
   8615     case QCAMERA_THERMAL_NO_ADJUSTMENT:
   8616         {
   8617             adjustedRange.min_fps = minFPS / 1000.0f;
   8618             adjustedRange.max_fps = maxFPS / 1000.0f;
   8619             adjustedRange.video_min_fps = minVideoFps / 1000.0f;
   8620             adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
   8621             skipPattern = NO_SKIP;
   8622         }
   8623         break;
   8624     case QCAMERA_THERMAL_SLIGHT_ADJUSTMENT:
   8625         {
   8626             adjustedRange.min_fps = minFPS / 1000.0f;
   8627             adjustedRange.max_fps = maxFPS / 1000.0f;
   8628             adjustedRange.min_fps -= 0.1f * adjustedRange.min_fps;
   8629             adjustedRange.max_fps -= 0.1f * adjustedRange.max_fps;
   8630             adjustedRange.video_min_fps = minVideoFps / 1000.0f;
   8631             adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
   8632             adjustedRange.video_min_fps -= 0.1f * adjustedRange.video_min_fps;
   8633             adjustedRange.video_max_fps -= 0.1f * adjustedRange.video_max_fps;
   8634             if ( adjustedRange.min_fps < 1 ) {
   8635                 adjustedRange.min_fps = 1;
   8636             }
   8637             if ( adjustedRange.max_fps < 1 ) {
   8638                 adjustedRange.max_fps = 1;
   8639             }
   8640             if ( adjustedRange.video_min_fps < 1 ) {
   8641                 adjustedRange.video_min_fps = 1;
   8642             }
   8643             if ( adjustedRange.video_max_fps < 1 ) {
   8644                 adjustedRange.video_max_fps = 1;
   8645             }
   8646             skipPattern = EVERY_2FRAME;
   8647         }
   8648         break;
   8649     case QCAMERA_THERMAL_BIG_ADJUSTMENT:
   8650         {
   8651             adjustedRange.min_fps = minFPS / 1000.0f;
   8652             adjustedRange.max_fps = maxFPS / 1000.0f;
   8653             adjustedRange.min_fps -= 0.2f * adjustedRange.min_fps;
   8654             adjustedRange.max_fps -= 0.2f * adjustedRange.max_fps;
   8655             adjustedRange.video_min_fps = minVideoFps / 1000.0f;
   8656             adjustedRange.video_max_fps = maxVideoFps / 1000.0f;
   8657             adjustedRange.video_min_fps -= 0.2f * adjustedRange.video_min_fps;
   8658             adjustedRange.video_max_fps -= 0.2f * adjustedRange.video_max_fps;
   8659             if ( adjustedRange.min_fps < 1 ) {
   8660                 adjustedRange.min_fps = 1;
   8661             }
   8662             if ( adjustedRange.max_fps < 1 ) {
   8663                 adjustedRange.max_fps = 1;
   8664             }
   8665             if ( adjustedRange.video_min_fps < 1 ) {
   8666                 adjustedRange.video_min_fps = 1;
   8667             }
   8668             if ( adjustedRange.video_max_fps < 1 ) {
   8669                 adjustedRange.video_max_fps = 1;
   8670             }
   8671             skipPattern = EVERY_4FRAME;
   8672         }
   8673         break;
   8674     case QCAMERA_THERMAL_MAX_ADJUSTMENT:
   8675         {
   8676             // Stop Preview?
   8677             // Set lowest min FPS for now
   8678             adjustedRange.min_fps = minFPS/1000.0f;
   8679             adjustedRange.max_fps = minFPS/1000.0f;
   8680             cam_capability_t *capability = gCamCapability[mCameraId];
   8681             for (size_t i = 0;
   8682                      i < capability->fps_ranges_tbl_cnt;
   8683                      i++) {
   8684                 if (capability->fps_ranges_tbl[i].min_fps <
   8685                         adjustedRange.min_fps) {
   8686                     adjustedRange.min_fps =
   8687                             capability->fps_ranges_tbl[i].min_fps;
   8688                     adjustedRange.max_fps = adjustedRange.min_fps;
   8689                 }
   8690             }
   8691             skipPattern = MAX_SKIP;
   8692             adjustedRange.video_min_fps = adjustedRange.min_fps;
   8693             adjustedRange.video_max_fps = adjustedRange.max_fps;
   8694         }
   8695         break;
   8696     case QCAMERA_THERMAL_SHUTDOWN:
   8697         {
   8698             // send error notify
   8699             LOGE("Received shutdown thermal level. Closing camera");
   8700             sendEvtNotify(CAMERA_MSG_ERROR, CAMERA_ERROR_SERVER_DIED, 0);
   8701         }
   8702         break;
   8703     default:
   8704         {
   8705             LOGW("Invalid thermal level %d", level);
   8706             return BAD_VALUE;
   8707         }
   8708         break;
   8709     }
   8710 
   8711     return NO_ERROR;
   8712 }
   8713 
   8714 /*===========================================================================
   8715  * FUNCTION   : recalcFPSRange
   8716  *
   8717  * DESCRIPTION: adjust the configured fps range regarding
   8718  *              the last thermal level.
   8719  *
   8720  * PARAMETERS :
   8721  *   @minFPS      : minimum configured fps range
   8722  *   @maxFPS      : maximum configured fps range
   8723  *   @minVideoFPS : minimum configured video fps
   8724  *   @maxVideoFPS : maximum configured video fps
   8725  *   @adjustedRange : target fps range
   8726  *
   8727  * RETURN     : int32_t type of status
   8728  *              NO_ERROR  -- success
   8729  *              none-zero failure code
   8730  *==========================================================================*/
   8731 int QCamera2HardwareInterface::recalcFPSRange(int &minFPS, int &maxFPS,
   8732         const float &minVideoFPS, const float &maxVideoFPS,
   8733         cam_fps_range_t &adjustedRange)
   8734 {
   8735     enum msm_vfe_frame_skip_pattern skipPattern;
   8736     calcThermalLevel(mThermalLevel,
   8737                      minFPS,
   8738                      maxFPS,
   8739                      minVideoFPS,
   8740                      maxVideoFPS,
   8741                      adjustedRange,
   8742                      skipPattern);
   8743     return NO_ERROR;
   8744 }
   8745 
   8746 /*===========================================================================
   8747  * FUNCTION   : updateThermalLevel
   8748  *
   8749  * DESCRIPTION: update thermal level depending on thermal events
   8750  *
   8751  * PARAMETERS :
   8752  *   @level   : thermal level
   8753  *
   8754  * RETURN     : int32_t type of status
   8755  *              NO_ERROR  -- success
   8756  *              none-zero failure code
   8757  *==========================================================================*/
   8758 int QCamera2HardwareInterface::updateThermalLevel(void *thermal_level)
   8759 {
   8760     int ret = NO_ERROR;
   8761     cam_fps_range_t adjustedRange;
   8762     int minFPS, maxFPS;
   8763     float minVideoFPS, maxVideoFPS;
   8764     enum msm_vfe_frame_skip_pattern skipPattern;
   8765     qcamera_thermal_level_enum_t level = *(qcamera_thermal_level_enum_t *)thermal_level;
   8766 
   8767 
   8768     if (!mCameraOpened) {
   8769         LOGH("Camera is not opened, no need to update camera parameters");
   8770         return NO_ERROR;
   8771     }
   8772     if (mParameters.getRecordingHintValue()) {
   8773         LOGH("Thermal mitigation isn't enabled in camcorder mode");
   8774         return NO_ERROR;
   8775     }
   8776 
   8777     mParameters.getPreviewFpsRange(&minFPS, &maxFPS);
   8778     qcamera_thermal_mode thermalMode = mParameters.getThermalMode();
   8779     if (mParameters.isHfrMode()) {
   8780         cam_fps_range_t hfrFpsRange;
   8781         mParameters.getHfrFps(hfrFpsRange);
   8782         minVideoFPS = hfrFpsRange.video_min_fps;
   8783         maxVideoFPS = hfrFpsRange.video_max_fps;
   8784     } else {
   8785         minVideoFPS = minFPS;
   8786         maxVideoFPS = maxFPS;
   8787     }
   8788 
   8789     calcThermalLevel(level, minFPS, maxFPS, minVideoFPS, maxVideoFPS,
   8790             adjustedRange, skipPattern);
   8791     mThermalLevel = level;
   8792 
   8793     if (thermalMode == QCAMERA_THERMAL_ADJUST_FPS)
   8794         ret = mParameters.adjustPreviewFpsRange(&adjustedRange);
   8795     else if (thermalMode == QCAMERA_THERMAL_ADJUST_FRAMESKIP)
   8796         ret = mParameters.setFrameSkip(skipPattern);
   8797     else
   8798         LOGW("Incorrect thermal mode %d", thermalMode);
   8799 
   8800     return ret;
   8801 
   8802 }
   8803 
   8804 /*===========================================================================
   8805  * FUNCTION   : updateParameters
   8806  *
   8807  * DESCRIPTION: update parameters
   8808  *
   8809  * PARAMETERS :
   8810  *   @parms       : input parameters string
   8811  *   @needRestart : output, flag to indicate if preview restart is needed
   8812  *
   8813  * RETURN     : int32_t type of status
   8814  *              NO_ERROR  -- success
   8815  *              none-zero failure code
   8816  *==========================================================================*/
   8817 int QCamera2HardwareInterface::updateParameters(const char *parms, bool &needRestart)
   8818 {
   8819     int rc = NO_ERROR;
   8820 
   8821     String8 str = String8(parms);
   8822     rc =  mParameters.updateParameters(str, needRestart);
   8823     setNeedRestart(needRestart);
   8824 
   8825     // update stream based parameter settings
   8826     for (int i = 0; i < QCAMERA_CH_TYPE_MAX; i++) {
   8827         if (m_channels[i] != NULL) {
   8828             m_channels[i]->UpdateStreamBasedParameters(mParameters);
   8829         }
   8830     }
   8831 
   8832     return rc;
   8833 }
   8834 
   8835 /*===========================================================================
   8836  * FUNCTION   : commitParameterChanges
   8837  *
   8838  * DESCRIPTION: commit parameter changes to the backend to take effect
   8839  *
   8840  * PARAMETERS : none
   8841  *
   8842  * RETURN     : int32_t type of status
   8843  *              NO_ERROR  -- success
   8844  *              none-zero failure code
   8845  * NOTE       : This function must be called after updateParameters.
   8846  *              Otherwise, no change will be passed to backend to take effect.
   8847  *==========================================================================*/
   8848 int QCamera2HardwareInterface::commitParameterChanges()
   8849 {
   8850     int rc = NO_ERROR;
   8851     rc = mParameters.commitParameters();
   8852     if (rc == NO_ERROR) {
   8853         // update number of snapshot based on committed parameters setting
   8854         rc = mParameters.setNumOfSnapshot();
   8855     }
   8856     return rc;
   8857 }
   8858 
   8859 /*===========================================================================
   8860  * FUNCTION   : needDebugFps
   8861  *
   8862  * DESCRIPTION: if fps log info need to be printed out
   8863  *
   8864  * PARAMETERS : none
   8865  *
   8866  * RETURN     : true: need print out fps log
   8867  *              false: no need to print out fps log
   8868  *==========================================================================*/
   8869 bool QCamera2HardwareInterface::needDebugFps()
   8870 {
   8871     bool needFps = false;
   8872     needFps = mParameters.isFpsDebugEnabled();
   8873     return needFps;
   8874 }
   8875 
   8876 /*===========================================================================
   8877  * FUNCTION   : isCACEnabled
   8878  *
   8879  * DESCRIPTION: if CAC is enabled
   8880  *
   8881  * PARAMETERS : none
   8882  *
   8883  * RETURN     : true: needed
   8884  *              false: no need
   8885  *==========================================================================*/
   8886 bool QCamera2HardwareInterface::isCACEnabled()
   8887 {
   8888     char prop[PROPERTY_VALUE_MAX];
   8889     memset(prop, 0, sizeof(prop));
   8890     property_get("persist.camera.feature.cac", prop, "0");
   8891     int enableCAC = atoi(prop);
   8892     return enableCAC == 1;
   8893 }
   8894 
   8895 /*===========================================================================
   8896  * FUNCTION   : is4k2kResolution
   8897  *
   8898  * DESCRIPTION: if resolution is 4k x 2k or true 4k x 2k
   8899  *
   8900  * PARAMETERS : none
   8901  *
   8902  * RETURN     : true: needed
   8903  *              false: no need
   8904  *==========================================================================*/
   8905 bool QCamera2HardwareInterface::is4k2kResolution(cam_dimension_t* resolution)
   8906 {
   8907    bool enabled = false;
   8908    if ((resolution->width == 4096 && resolution->height == 2160) ||
   8909        (resolution->width == 3840 && resolution->height == 2160) ) {
   8910       enabled = true;
   8911    }
   8912    return enabled;
   8913 }
   8914 
   8915 /*===========================================================================
   8916  * FUNCTION   : isPreviewRestartEnabled
   8917  *
   8918  * DESCRIPTION: Check whether preview should be restarted automatically
   8919  *              during image capture.
   8920  *
   8921  * PARAMETERS : none
   8922  *
   8923  * RETURN     : true: needed
   8924  *              false: no need
   8925  *==========================================================================*/
   8926 bool QCamera2HardwareInterface::isPreviewRestartEnabled()
   8927 {
   8928     char prop[PROPERTY_VALUE_MAX];
   8929     memset(prop, 0, sizeof(prop));
   8930     property_get("persist.camera.feature.restart", prop, "0");
   8931     int earlyRestart = atoi(prop);
   8932     return earlyRestart == 1;
   8933 }
   8934 
   8935 /*===========================================================================
   8936  * FUNCTION   : needReprocess
   8937  *
   8938  * DESCRIPTION: if reprocess is needed
   8939  *
   8940  * PARAMETERS : none
   8941  *
   8942  * RETURN     : true: needed
   8943  *              false: no need
   8944  *==========================================================================*/
   8945 bool QCamera2HardwareInterface::needReprocess()
   8946 {
   8947     bool needReprocess = false;
   8948 
   8949     if (!mParameters.isJpegPictureFormat() &&
   8950         !mParameters.isNV21PictureFormat()) {
   8951         // RAW image, no need to reprocess
   8952         return false;
   8953     }
   8954 
   8955     //Disable reprocess for 4K liveshot case but enable if lowpower mode
   8956     if (mParameters.is4k2kVideoResolution() && mParameters.getRecordingHintValue()
   8957             && !isLowPowerMode()) {
   8958         return false;
   8959     }
   8960 
   8961     // pp feature config
   8962     cam_pp_feature_config_t pp_config;
   8963     memset(&pp_config, 0, sizeof(cam_pp_feature_config_t));
   8964 
   8965     //Decide whether to do reprocess or not based on
   8966     //ppconfig obtained in the first pass.
   8967     getPPConfig(pp_config);
   8968 
   8969     if (pp_config.feature_mask > 0) {
   8970         needReprocess = true;
   8971     }
   8972 
   8973     LOGH("needReprocess %s", needReprocess ? "true" : "false");
   8974     return needReprocess;
   8975 }
   8976 
   8977 
   8978 /*===========================================================================
   8979  * FUNCTION   : needRotationReprocess
   8980  *
   8981  * DESCRIPTION: if rotation needs to be done by reprocess in pp
   8982  *
   8983  * PARAMETERS : none
   8984  *
   8985  * RETURN     : true: needed
   8986  *              false: no need
   8987  *==========================================================================*/
   8988 bool QCamera2HardwareInterface::needRotationReprocess()
   8989 {
   8990     if (!mParameters.isJpegPictureFormat() &&
   8991         !mParameters.isNV21PictureFormat()) {
   8992         // RAW image, no need to reprocess
   8993         return false;
   8994     }
   8995 
   8996     //Disable reprocess for 4K liveshot case
   8997     if (mParameters.is4k2kVideoResolution() && mParameters.getRecordingHintValue()
   8998             && !isLowPowerMode()) {
   8999         //Disable reprocess for 4K liveshot case
   9000         return false;
   9001     }
   9002 
   9003     if ((gCamCapability[mCameraId]->qcom_supported_feature_mask &
   9004             CAM_QCOM_FEATURE_ROTATION) > 0 &&
   9005             (mParameters.getJpegRotation() > 0)) {
   9006         // current rotation is not zero, and pp has the capability to process rotation
   9007         LOGH("need to do reprocess for rotation=%d",
   9008                  mParameters.getJpegRotation());
   9009         return true;
   9010     }
   9011 
   9012     return false;
   9013 }
   9014 
   9015 /*===========================================================================
   9016  * FUNCTION   : getThumbnailSize
   9017  *
   9018  * DESCRIPTION: get user set thumbnail size
   9019  *
   9020  * PARAMETERS :
   9021  *   @dim     : output of thumbnail dimension
   9022  *
   9023  * RETURN     : none
   9024  *==========================================================================*/
   9025 void QCamera2HardwareInterface::getThumbnailSize(cam_dimension_t &dim)
   9026 {
   9027     mParameters.getThumbnailSize(&dim.width, &dim.height);
   9028 }
   9029 
   9030 /*===========================================================================
   9031  * FUNCTION   : getJpegQuality
   9032  *
   9033  * DESCRIPTION: get user set jpeg quality
   9034  *
   9035  * PARAMETERS : none
   9036  *
   9037  * RETURN     : jpeg quality setting
   9038  *==========================================================================*/
   9039 uint32_t QCamera2HardwareInterface::getJpegQuality()
   9040 {
   9041     uint32_t quality = 0;
   9042     quality =  mParameters.getJpegQuality();
   9043     return quality;
   9044 }
   9045 
   9046 /*===========================================================================
   9047  * FUNCTION   : getExifData
   9048  *
   9049  * DESCRIPTION: get exif data to be passed into jpeg encoding
   9050  *
   9051  * PARAMETERS : none
   9052  *
   9053  * RETURN     : exif data from user setting and GPS
   9054  *==========================================================================*/
   9055 QCameraExif *QCamera2HardwareInterface::getExifData()
   9056 {
   9057     QCameraExif *exif = new QCameraExif();
   9058     if (exif == NULL) {
   9059         LOGE("No memory for QCameraExif");
   9060         return NULL;
   9061     }
   9062 
   9063     int32_t rc = NO_ERROR;
   9064 
   9065     // add exif entries
   9066     String8 dateTime, subSecTime;
   9067     rc = mParameters.getExifDateTime(dateTime, subSecTime);
   9068     if(rc == NO_ERROR) {
   9069         exif->addEntry(EXIFTAGID_DATE_TIME, EXIF_ASCII,
   9070                 (uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
   9071         exif->addEntry(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII,
   9072                 (uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
   9073         exif->addEntry(EXIFTAGID_EXIF_DATE_TIME_DIGITIZED, EXIF_ASCII,
   9074                 (uint32_t)(dateTime.length() + 1), (void *)dateTime.string());
   9075         exif->addEntry(EXIFTAGID_SUBSEC_TIME, EXIF_ASCII,
   9076                 (uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
   9077         exif->addEntry(EXIFTAGID_SUBSEC_TIME_ORIGINAL, EXIF_ASCII,
   9078                 (uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
   9079         exif->addEntry(EXIFTAGID_SUBSEC_TIME_DIGITIZED, EXIF_ASCII,
   9080                 (uint32_t)(subSecTime.length() + 1), (void *)subSecTime.string());
   9081     } else {
   9082         LOGW("getExifDateTime failed");
   9083     }
   9084 
   9085     rat_t focalLength;
   9086     rc = mParameters.getExifFocalLength(&focalLength);
   9087     if (rc == NO_ERROR) {
   9088         exif->addEntry(EXIFTAGID_FOCAL_LENGTH,
   9089                        EXIF_RATIONAL,
   9090                        1,
   9091                        (void *)&(focalLength));
   9092     } else {
   9093         LOGW("getExifFocalLength failed");
   9094     }
   9095 
   9096     uint16_t isoSpeed = mParameters.getExifIsoSpeed();
   9097     if (getSensorType() != CAM_SENSOR_YUV) {
   9098         exif->addEntry(EXIFTAGID_ISO_SPEED_RATING,
   9099                        EXIF_SHORT,
   9100                        1,
   9101                        (void *)&(isoSpeed));
   9102     }
   9103 
   9104     char gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE];
   9105     uint32_t count = 0;
   9106 
   9107     /*gps data might not be available */
   9108     rc = mParameters.getExifGpsProcessingMethod(gpsProcessingMethod, count);
   9109     if(rc == NO_ERROR) {
   9110         exif->addEntry(EXIFTAGID_GPS_PROCESSINGMETHOD,
   9111                        EXIF_ASCII,
   9112                        count,
   9113                        (void *)gpsProcessingMethod);
   9114     } else {
   9115         LOGW("getExifGpsProcessingMethod failed");
   9116     }
   9117 
   9118     rat_t latitude[3];
   9119     char latRef[2];
   9120     rc = mParameters.getExifLatitude(latitude, latRef);
   9121     if(rc == NO_ERROR) {
   9122         exif->addEntry(EXIFTAGID_GPS_LATITUDE,
   9123                        EXIF_RATIONAL,
   9124                        3,
   9125                        (void *)latitude);
   9126         exif->addEntry(EXIFTAGID_GPS_LATITUDE_REF,
   9127                        EXIF_ASCII,
   9128                        2,
   9129                        (void *)latRef);
   9130     } else {
   9131         LOGW("getExifLatitude failed");
   9132     }
   9133 
   9134     rat_t longitude[3];
   9135     char lonRef[2];
   9136     rc = mParameters.getExifLongitude(longitude, lonRef);
   9137     if(rc == NO_ERROR) {
   9138         exif->addEntry(EXIFTAGID_GPS_LONGITUDE,
   9139                        EXIF_RATIONAL,
   9140                        3,
   9141                        (void *)longitude);
   9142 
   9143         exif->addEntry(EXIFTAGID_GPS_LONGITUDE_REF,
   9144                        EXIF_ASCII,
   9145                        2,
   9146                        (void *)lonRef);
   9147     } else {
   9148         LOGW("getExifLongitude failed");
   9149     }
   9150 
   9151     rat_t altitude;
   9152     char altRef;
   9153     rc = mParameters.getExifAltitude(&altitude, &altRef);
   9154     if(rc == NO_ERROR) {
   9155         exif->addEntry(EXIFTAGID_GPS_ALTITUDE,
   9156                        EXIF_RATIONAL,
   9157                        1,
   9158                        (void *)&(altitude));
   9159 
   9160         exif->addEntry(EXIFTAGID_GPS_ALTITUDE_REF,
   9161                        EXIF_BYTE,
   9162                        1,
   9163                        (void *)&altRef);
   9164     } else {
   9165         LOGW("getExifAltitude failed");
   9166     }
   9167 
   9168     char gpsDateStamp[20];
   9169     rat_t gpsTimeStamp[3];
   9170     rc = mParameters.getExifGpsDateTimeStamp(gpsDateStamp, 20, gpsTimeStamp);
   9171     if(rc == NO_ERROR) {
   9172         exif->addEntry(EXIFTAGID_GPS_DATESTAMP,
   9173                        EXIF_ASCII,
   9174                        (uint32_t)(strlen(gpsDateStamp) + 1),
   9175                        (void *)gpsDateStamp);
   9176 
   9177         exif->addEntry(EXIFTAGID_GPS_TIMESTAMP,
   9178                        EXIF_RATIONAL,
   9179                        3,
   9180                        (void *)gpsTimeStamp);
   9181     } else {
   9182         LOGW("getExifGpsDataTimeStamp failed");
   9183     }
   9184 
   9185 #ifdef ENABLE_MODEL_INFO_EXIF
   9186 
   9187     char value[PROPERTY_VALUE_MAX];
   9188     if (property_get("persist.sys.exif.make", value, "") > 0 ||
   9189             property_get("ro.product.manufacturer", value, "QCOM-AA") > 0) {
   9190         exif->addEntry(EXIFTAGID_MAKE,
   9191                 EXIF_ASCII, strlen(value) + 1, (void *)value);
   9192     } else {
   9193         LOGW("getExifMaker failed");
   9194     }
   9195 
   9196     if (property_get("persist.sys.exif.model", value, "") > 0 ||
   9197             property_get("ro.product.model", value, "QCAM-AA") > 0) {
   9198         exif->addEntry(EXIFTAGID_MODEL,
   9199                 EXIF_ASCII, strlen(value) + 1, (void *)value);
   9200     } else {
   9201         LOGW("getExifModel failed");
   9202     }
   9203 
   9204     if (property_get("ro.build.description", value, "QCAM-AA") > 0) {
   9205         exif->addEntry(EXIFTAGID_SOFTWARE, EXIF_ASCII,
   9206                 (uint32_t)(strlen(value) + 1), (void *)value);
   9207     } else {
   9208         LOGW("getExifSoftware failed");
   9209     }
   9210 
   9211 #endif
   9212 
   9213     if (mParameters.useJpegExifRotation()) {
   9214         int16_t orientation;
   9215         switch (mParameters.getJpegExifRotation()) {
   9216         case 0:
   9217             orientation = 1;
   9218             break;
   9219         case 90:
   9220             orientation = 6;
   9221             break;
   9222         case 180:
   9223             orientation = 3;
   9224             break;
   9225         case 270:
   9226             orientation = 8;
   9227             break;
   9228         default:
   9229             orientation = 1;
   9230             break;
   9231         }
   9232         exif->addEntry(EXIFTAGID_ORIENTATION,
   9233                 EXIF_SHORT,
   9234                 1,
   9235                 (void *)&orientation);
   9236         exif->addEntry(EXIFTAGID_TN_ORIENTATION,
   9237                 EXIF_SHORT,
   9238                 1,
   9239                 (void *)&orientation);
   9240     }
   9241 
   9242     return exif;
   9243 }
   9244 
   9245 /*===========================================================================
   9246  * FUNCTION   : setHistogram
   9247  *
   9248  * DESCRIPTION: set if histogram should be enabled
   9249  *
   9250  * PARAMETERS :
   9251  *   @histogram_en : bool flag if histogram should be enabled
   9252  *
   9253  * RETURN     : int32_t type of status
   9254  *              NO_ERROR  -- success
   9255  *              none-zero failure code
   9256  *==========================================================================*/
   9257 int32_t QCamera2HardwareInterface::setHistogram(bool histogram_en)
   9258 {
   9259     return mParameters.setHistogram(histogram_en);
   9260 }
   9261 
   9262 /*===========================================================================
   9263  * FUNCTION   : setFaceDetection
   9264  *
   9265  * DESCRIPTION: set if face detection should be enabled
   9266  *
   9267  * PARAMETERS :
   9268  *   @enabled : bool flag if face detection should be enabled
   9269  *
   9270  * RETURN     : int32_t type of status
   9271  *              NO_ERROR  -- success
   9272  *              none-zero failure code
   9273  *==========================================================================*/
   9274 int32_t QCamera2HardwareInterface::setFaceDetection(bool enabled)
   9275 {
   9276     return mParameters.setFaceDetection(enabled, true);
   9277 }
   9278 
   9279 /*===========================================================================
   9280  * FUNCTION   : isCaptureShutterEnabled
   9281  *
   9282  * DESCRIPTION: Check whether shutter should be triggered immediately after
   9283  *              capture
   9284  *
   9285  * PARAMETERS :
   9286  *
   9287  * RETURN     : true - regular capture
   9288  *              false - other type of capture
   9289  *==========================================================================*/
   9290 bool QCamera2HardwareInterface::isCaptureShutterEnabled()
   9291 {
   9292     char prop[PROPERTY_VALUE_MAX];
   9293     memset(prop, 0, sizeof(prop));
   9294     property_get("persist.camera.feature.shutter", prop, "0");
   9295     int enableShutter = atoi(prop);
   9296     return enableShutter == 1;
   9297 }
   9298 
   9299 /*===========================================================================
   9300  * FUNCTION   : needProcessPreviewFrame
   9301  *
   9302  * DESCRIPTION: returns whether preview frame need to be displayed
   9303  *
   9304  * PARAMETERS :
   9305  *   @frameID : frameID of frame to be processed
   9306  *
   9307  * RETURN     : int32_t type of status
   9308  *              NO_ERROR  -- success
   9309  *              none-zero failure code
   9310  *==========================================================================*/
   9311 bool QCamera2HardwareInterface::needProcessPreviewFrame(uint32_t frameID)
   9312 {
   9313     return ((m_stateMachine.isPreviewRunning()) &&
   9314             (!isDisplayFrameToSkip(frameID)) &&
   9315             (!mParameters.isInstantAECEnabled()));
   9316 }
   9317 
   9318 /*===========================================================================
   9319  * FUNCTION   : needSendPreviewCallback
   9320  *
   9321  * DESCRIPTION: returns whether preview frame need to callback to APP
   9322  *
   9323  * PARAMETERS :
   9324  *
   9325  * RETURN     : true - need preview frame callbck
   9326  *              false - not send preview frame callback
   9327  *==========================================================================*/
   9328 bool QCamera2HardwareInterface::needSendPreviewCallback()
   9329 {
   9330     return m_stateMachine.isPreviewRunning()
   9331             && (mDataCb != NULL)
   9332             && (msgTypeEnabledWithLock(CAMERA_MSG_PREVIEW_FRAME) > 0)
   9333             && m_stateMachine.isPreviewCallbackNeeded();
   9334 };
   9335 
   9336 /*===========================================================================
   9337  * FUNCTION   : setDisplaySkip
   9338  *
   9339  * DESCRIPTION: set range of frames to skip for preview
   9340  *
   9341  * PARAMETERS :
   9342  *   @enabled : TRUE to start skipping frame to display
   9343                 FALSE to stop skipping frame to display
   9344  *   @skipCnt : Number of frame to skip. 0 by default
   9345  *
   9346  * RETURN     : None
   9347  *==========================================================================*/
   9348 void QCamera2HardwareInterface::setDisplaySkip(bool enabled, uint8_t skipCnt)
   9349 {
   9350     pthread_mutex_lock(&mGrallocLock);
   9351     if (enabled) {
   9352         setDisplayFrameSkip();
   9353         setDisplayFrameSkip(mLastPreviewFrameID + skipCnt + 1);
   9354     } else {
   9355         setDisplayFrameSkip(mFrameSkipStart, (mLastPreviewFrameID + skipCnt + 1));
   9356     }
   9357     pthread_mutex_unlock(&mGrallocLock);
   9358 }
   9359 
   9360 /*===========================================================================
   9361  * FUNCTION   : setDisplayFrameSkip
   9362  *
   9363  * DESCRIPTION: set range of frames to skip for preview
   9364  *
   9365  * PARAMETERS :
   9366  *   @start   : frameId to start skip
   9367  *   @end     : frameId to stop skip
   9368  *
   9369  * RETURN     : None
   9370  *==========================================================================*/
   9371 void QCamera2HardwareInterface::setDisplayFrameSkip(uint32_t start,
   9372         uint32_t end)
   9373 {
   9374     if (start == 0) {
   9375         mFrameSkipStart = 0;
   9376         mFrameSkipEnd = 0;
   9377         return;
   9378     }
   9379     if ((mFrameSkipStart == 0) || (mFrameSkipStart > start)) {
   9380         mFrameSkipStart = start;
   9381     }
   9382     if ((end == 0) || (end > mFrameSkipEnd)) {
   9383         mFrameSkipEnd = end;
   9384     }
   9385 }
   9386 
   9387 /*===========================================================================
   9388  * FUNCTION   : isDisplayFrameToSkip
   9389  *
   9390  * DESCRIPTION: function to determin if input frame falls under skip range
   9391  *
   9392  * PARAMETERS :
   9393  *   @frameId : frameId to verify
   9394  *
   9395  * RETURN     : true : need to skip
   9396  *              false: no need to skip
   9397  *==========================================================================*/
   9398 bool QCamera2HardwareInterface::isDisplayFrameToSkip(uint32_t frameId)
   9399 {
   9400     return ((mFrameSkipStart != 0) && (frameId >= mFrameSkipStart) &&
   9401             (frameId <= mFrameSkipEnd || mFrameSkipEnd == 0)) ? TRUE : FALSE;
   9402 }
   9403 
   9404 /*===========================================================================
   9405  * FUNCTION   : prepareHardwareForSnapshot
   9406  *
   9407  * DESCRIPTION: prepare hardware for snapshot, such as LED
   9408  *
   9409  * PARAMETERS :
   9410  *   @afNeeded: flag indicating if Auto Focus needs to be done during preparation
   9411  *
   9412  * RETURN     : int32_t type of status
   9413  *              NO_ERROR  -- success
   9414  *              none-zero failure code
   9415  *==========================================================================*/
   9416 int32_t QCamera2HardwareInterface::prepareHardwareForSnapshot(int32_t afNeeded)
   9417 {
   9418     ATRACE_CALL();
   9419     LOGI("[KPI Perf]: Send PREPARE SANSPHOT event");
   9420     return mCameraHandle->ops->prepare_snapshot(mCameraHandle->camera_handle,
   9421                                                 afNeeded);
   9422 }
   9423 
   9424 /*===========================================================================
   9425  * FUNCTION   : needFDMetadata
   9426  *
   9427  * DESCRIPTION: check whether we need process Face Detection metadata in this chanel
   9428  *
   9429  * PARAMETERS :
   9430  *   @channel_type: channel type
   9431  *
   9432   * RETURN     : true: needed
   9433  *              false: no need
   9434  *==========================================================================*/
   9435 bool QCamera2HardwareInterface::needFDMetadata(qcamera_ch_type_enum_t channel_type)
   9436 {
   9437     //Note: Currently we only process ZSL channel
   9438     bool value = false;
   9439     if(channel_type == QCAMERA_CH_TYPE_ZSL){
   9440         //check if FD requirement is enabled
   9441         if(mParameters.isSnapshotFDNeeded() &&
   9442            mParameters.isFaceDetectionEnabled()){
   9443             value = true;
   9444             LOGH("Face Detection metadata is required in ZSL mode.");
   9445         }
   9446     }
   9447 
   9448     return value;
   9449 }
   9450 
   9451 /*===========================================================================
   9452  * FUNCTION   : deferredWorkRoutine
   9453  *
   9454  * DESCRIPTION: data process routine that executes deferred tasks
   9455  *
   9456  * PARAMETERS :
   9457  *   @data    : user data ptr (QCamera2HardwareInterface)
   9458  *
   9459  * RETURN     : None
   9460  *==========================================================================*/
   9461 void *QCamera2HardwareInterface::deferredWorkRoutine(void *obj)
   9462 {
   9463     int running = 1;
   9464     int ret;
   9465     uint8_t is_active = FALSE;
   9466     int32_t job_status = 0;
   9467 
   9468     QCamera2HardwareInterface *pme = (QCamera2HardwareInterface *)obj;
   9469     QCameraCmdThread *cmdThread = &pme->mDeferredWorkThread;
   9470     cmdThread->setName("CAM_defrdWrk");
   9471 
   9472     do {
   9473         do {
   9474             ret = cam_sem_wait(&cmdThread->cmd_sem);
   9475             if (ret != 0 && errno != EINVAL) {
   9476                 LOGE("cam_sem_wait error (%s)",
   9477                          strerror(errno));
   9478                 return NULL;
   9479             }
   9480         } while (ret != 0);
   9481 
   9482         // we got notified about new cmd avail in cmd queue
   9483         camera_cmd_type_t cmd = cmdThread->getCmd();
   9484         LOGD("cmd: %d", cmd);
   9485         switch (cmd) {
   9486         case CAMERA_CMD_TYPE_START_DATA_PROC:
   9487             LOGH("start data proc");
   9488             is_active = TRUE;
   9489             break;
   9490         case CAMERA_CMD_TYPE_STOP_DATA_PROC:
   9491             LOGH("stop data proc");
   9492             is_active = FALSE;
   9493             // signal cmd is completed
   9494             cam_sem_post(&cmdThread->sync_sem);
   9495             break;
   9496         case CAMERA_CMD_TYPE_DO_NEXT_JOB:
   9497             {
   9498                 DefWork *dw =
   9499                     reinterpret_cast<DefWork *>(pme->mCmdQueue.dequeue());
   9500 
   9501                 if ( NULL == dw ) {
   9502                     LOGE("Invalid deferred work");
   9503                     break;
   9504                 }
   9505 
   9506                 switch( dw->cmd ) {
   9507                 case CMD_DEF_ALLOCATE_BUFF:
   9508                     {
   9509                         QCameraChannel * pChannel = dw->args.allocArgs.ch;
   9510 
   9511                         if ( NULL == pChannel ) {
   9512                             LOGE("Invalid deferred work channel");
   9513                             job_status = BAD_VALUE;
   9514                             break;
   9515                         }
   9516 
   9517                         cam_stream_type_t streamType = dw->args.allocArgs.type;
   9518                         LOGH("Deferred buffer allocation started for stream type: %d",
   9519                                  streamType);
   9520 
   9521                         uint32_t iNumOfStreams = pChannel->getNumOfStreams();
   9522                         QCameraStream *pStream = NULL;
   9523                         for ( uint32_t i = 0; i < iNumOfStreams; ++i) {
   9524                             pStream = pChannel->getStreamByIndex(i);
   9525 
   9526                             if ( NULL == pStream ) {
   9527                                 job_status = BAD_VALUE;
   9528                                 break;
   9529                             }
   9530 
   9531                             if ( pStream->isTypeOf(streamType)) {
   9532                                 if ( pStream->allocateBuffers() ) {
   9533                                     LOGE("Error allocating buffers !!!");
   9534                                     job_status =  NO_MEMORY;
   9535                                     pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9536                                             CAMERA_ERROR_UNKNOWN, 0);
   9537                                 }
   9538                                 break;
   9539                             }
   9540                         }
   9541                     }
   9542                     break;
   9543                 case CMD_DEF_PPROC_START:
   9544                     {
   9545                         int32_t ret = pme->getDefJobStatus(pme->mInitPProcJob);
   9546                         if (ret != NO_ERROR) {
   9547                             job_status = ret;
   9548                             LOGE("PPROC Start failed");
   9549                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9550                                     CAMERA_ERROR_UNKNOWN, 0);
   9551                             break;
   9552                         }
   9553                         QCameraChannel * pChannel = dw->args.pprocArgs;
   9554                         assert(pChannel);
   9555 
   9556                         if (pme->m_postprocessor.start(pChannel) != NO_ERROR) {
   9557                             LOGE("cannot start postprocessor");
   9558                             job_status = BAD_VALUE;
   9559                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9560                                     CAMERA_ERROR_UNKNOWN, 0);
   9561                         }
   9562                     }
   9563                     break;
   9564                 case CMD_DEF_METADATA_ALLOC:
   9565                     {
   9566                         int32_t ret = pme->getDefJobStatus(pme->mParamAllocJob);
   9567                         if (ret != NO_ERROR) {
   9568                             job_status = ret;
   9569                             LOGE("Metadata alloc failed");
   9570                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9571                                     CAMERA_ERROR_UNKNOWN, 0);
   9572                             break;
   9573                         }
   9574                         pme->mMetadataMem = new QCameraMetadataStreamMemory(
   9575                                 QCAMERA_ION_USE_CACHE);
   9576 
   9577                         if (pme->mMetadataMem == NULL) {
   9578                             LOGE("Unable to allocate metadata buffers");
   9579                             job_status = BAD_VALUE;
   9580                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9581                                     CAMERA_ERROR_UNKNOWN, 0);
   9582                         } else {
   9583                             int32_t rc = pme->mMetadataMem->allocate(
   9584                                     dw->args.metadataAllocArgs.bufferCnt,
   9585                                     dw->args.metadataAllocArgs.size,
   9586                                     NON_SECURE);
   9587                             if (rc < 0) {
   9588                                 delete pme->mMetadataMem;
   9589                                 pme->mMetadataMem = NULL;
   9590                             }
   9591                         }
   9592                      }
   9593                      break;
   9594                 case CMD_DEF_CREATE_JPEG_SESSION:
   9595                     {
   9596                         QCameraChannel * pChannel = dw->args.pprocArgs;
   9597                         assert(pChannel);
   9598 
   9599                         int32_t ret = pme->getDefJobStatus(pme->mReprocJob);
   9600                         if (ret != NO_ERROR) {
   9601                             job_status = ret;
   9602                             LOGE("Jpeg create failed");
   9603                             break;
   9604                         }
   9605 
   9606                         if (pme->m_postprocessor.createJpegSession(pChannel)
   9607                             != NO_ERROR) {
   9608                             LOGE("cannot create JPEG session");
   9609                             job_status = UNKNOWN_ERROR;
   9610                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9611                                     CAMERA_ERROR_UNKNOWN, 0);
   9612                         }
   9613                     }
   9614                     break;
   9615                 case CMD_DEF_PPROC_INIT:
   9616                     {
   9617                         int32_t rc = NO_ERROR;
   9618 
   9619                         jpeg_encode_callback_t jpegEvtHandle =
   9620                                 dw->args.pprocInitArgs.jpeg_cb;
   9621                         void* user_data = dw->args.pprocInitArgs.user_data;
   9622                         QCameraPostProcessor *postProcessor =
   9623                                 &(pme->m_postprocessor);
   9624                         uint32_t cameraId = pme->mCameraId;
   9625                         cam_capability_t *capability =
   9626                                 gCamCapability[cameraId];
   9627                         cam_padding_info_t padding_info;
   9628                         cam_padding_info_t& cam_capability_padding_info =
   9629                                 capability->padding_info;
   9630 
   9631                         if(!pme->mJpegClientHandle) {
   9632                             rc = pme->initJpegHandle();
   9633                             if (rc != NO_ERROR) {
   9634                                 LOGE("Error!! creating JPEG handle failed");
   9635                                 job_status = UNKNOWN_ERROR;
   9636                                 pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9637                                         CAMERA_ERROR_UNKNOWN, 0);
   9638                                 break;
   9639                             }
   9640                         }
   9641                         LOGH("mJpegClientHandle : %d", pme->mJpegClientHandle);
   9642 
   9643                         rc = postProcessor->setJpegHandle(&pme->mJpegHandle,
   9644                                 &pme->mJpegMpoHandle,
   9645                                 pme->mJpegClientHandle);
   9646                         if (rc != 0) {
   9647                             LOGE("Error!! set JPEG handle failed");
   9648                             job_status = UNKNOWN_ERROR;
   9649                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9650                                     CAMERA_ERROR_UNKNOWN, 0);
   9651                             break;
   9652                         }
   9653 
   9654                         /* get max pic size for jpeg work buf calculation*/
   9655                         rc = postProcessor->init(jpegEvtHandle, user_data);
   9656 
   9657                         if (rc != NO_ERROR) {
   9658                             LOGE("cannot init postprocessor");
   9659                             job_status = UNKNOWN_ERROR;
   9660                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9661                                     CAMERA_ERROR_UNKNOWN, 0);
   9662                             break;
   9663                         }
   9664 
   9665                         // update padding info from jpeg
   9666                         postProcessor->getJpegPaddingReq(padding_info);
   9667                         if (cam_capability_padding_info.width_padding <
   9668                                 padding_info.width_padding) {
   9669                             cam_capability_padding_info.width_padding =
   9670                                     padding_info.width_padding;
   9671                         }
   9672                         if (cam_capability_padding_info.height_padding <
   9673                                 padding_info.height_padding) {
   9674                             cam_capability_padding_info.height_padding =
   9675                                     padding_info.height_padding;
   9676                         }
   9677                         if (cam_capability_padding_info.plane_padding !=
   9678                                 padding_info.plane_padding) {
   9679                             cam_capability_padding_info.plane_padding =
   9680                                     mm_stream_calc_lcm(
   9681                                     cam_capability_padding_info.plane_padding,
   9682                                     padding_info.plane_padding);
   9683                         }
   9684                         if (cam_capability_padding_info.offset_info.offset_x
   9685                                 != padding_info.offset_info.offset_x) {
   9686                             cam_capability_padding_info.offset_info.offset_x =
   9687                                     mm_stream_calc_lcm (
   9688                                     cam_capability_padding_info.offset_info.offset_x,
   9689                                     padding_info.offset_info.offset_x);
   9690                         }
   9691                         if (cam_capability_padding_info.offset_info.offset_y
   9692                                 != padding_info.offset_info.offset_y) {
   9693                             cam_capability_padding_info.offset_info.offset_y =
   9694                             mm_stream_calc_lcm (
   9695                                     cam_capability_padding_info.offset_info.offset_y,
   9696                                     padding_info.offset_info.offset_y);
   9697                         }
   9698                     }
   9699                     break;
   9700                 case CMD_DEF_PARAM_ALLOC:
   9701                     {
   9702                         int32_t rc = pme->mParameters.allocate();
   9703                         // notify routine would not be initialized by this time.
   9704                         // So, just update error job status
   9705                         if (rc != NO_ERROR) {
   9706                             job_status = rc;
   9707                             LOGE("Param allocation failed");
   9708                             break;
   9709                         }
   9710                     }
   9711                     break;
   9712                 case CMD_DEF_PARAM_INIT:
   9713                     {
   9714                         int32_t rc = pme->getDefJobStatus(pme->mParamAllocJob);
   9715                         if (rc != NO_ERROR) {
   9716                             job_status = rc;
   9717                             LOGE("Param init failed");
   9718                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9719                                     CAMERA_ERROR_UNKNOWN, 0);
   9720                             break;
   9721                         }
   9722 
   9723                         uint32_t camId = pme->mCameraId;
   9724                         cam_capability_t * cap = gCamCapability[camId];
   9725 
   9726                         if (pme->mCameraHandle == NULL) {
   9727                             LOGE("Camera handle is null");
   9728                             job_status = BAD_VALUE;
   9729                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9730                                     CAMERA_ERROR_UNKNOWN, 0);
   9731                             break;
   9732                         }
   9733 
   9734                         // Now PostProc need calibration data as initialization
   9735                         // time for jpeg_open and calibration data is a
   9736                         // get param for now, so params needs to be initialized
   9737                         // before postproc init
   9738                         rc = pme->mParameters.init(cap,
   9739                                 pme->mCameraHandle,
   9740                                 pme);
   9741                         if (rc != 0) {
   9742                             job_status = UNKNOWN_ERROR;
   9743                             LOGE("Parameter Initialization failed");
   9744                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9745                                     CAMERA_ERROR_UNKNOWN, 0);
   9746                             break;
   9747                         }
   9748 
   9749                         // Get related cam calibration only in
   9750                         // dual camera mode
   9751                         if (pme->getRelatedCamSyncInfo()->sync_control ==
   9752                                 CAM_SYNC_RELATED_SENSORS_ON) {
   9753                             rc = pme->mParameters.getRelatedCamCalibration(
   9754                                 &(pme->mJpegMetadata.otp_calibration_data));
   9755                             LOGD("Dumping Calibration Data Version Id %f rc %d",
   9756                                     pme->mJpegMetadata.otp_calibration_data.calibration_format_version,
   9757                                     rc);
   9758                             if (rc != 0) {
   9759                                 job_status = UNKNOWN_ERROR;
   9760                                 LOGE("getRelatedCamCalibration failed");
   9761                                 pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9762                                         CAMERA_ERROR_UNKNOWN, 0);
   9763                                 break;
   9764                             }
   9765                             pme->m_bRelCamCalibValid = true;
   9766                         }
   9767 
   9768                         pme->mJpegMetadata.sensor_mount_angle =
   9769                             cap->sensor_mount_angle;
   9770                         pme->mJpegMetadata.default_sensor_flip = FLIP_NONE;
   9771 
   9772                         pme->mParameters.setMinPpMask(
   9773                             cap->qcom_supported_feature_mask);
   9774                         pme->mExifParams.debug_params =
   9775                                 (mm_jpeg_debug_exif_params_t *)
   9776                                 malloc(sizeof(mm_jpeg_debug_exif_params_t));
   9777                         if (!pme->mExifParams.debug_params) {
   9778                             LOGE("Out of Memory. Allocation failed for "
   9779                                     "3A debug exif params");
   9780                             job_status = NO_MEMORY;
   9781                             pme->sendEvtNotify(CAMERA_MSG_ERROR,
   9782                                     CAMERA_ERROR_UNKNOWN, 0);
   9783                             break;
   9784                         }
   9785                         memset(pme->mExifParams.debug_params, 0,
   9786                                 sizeof(mm_jpeg_debug_exif_params_t));
   9787                     }
   9788                     break;
   9789                 case CMD_DEF_GENERIC:
   9790                     {
   9791                         BackgroundTask *bgTask = dw->args.genericArgs;
   9792                         job_status = bgTask->bgFunction(bgTask->bgArgs);
   9793                     }
   9794                     break;
   9795                 default:
   9796                     LOGE("Incorrect command : %d", dw->cmd);
   9797                 }
   9798 
   9799                 pme->dequeueDeferredWork(dw, job_status);
   9800             }
   9801             break;
   9802         case CAMERA_CMD_TYPE_EXIT:
   9803             running = 0;
   9804             break;
   9805         default:
   9806             break;
   9807         }
   9808     } while (running);
   9809 
   9810     return NULL;
   9811 }
   9812 
   9813 /*===========================================================================
   9814  * FUNCTION   : queueDeferredWork
   9815  *
   9816  * DESCRIPTION: function which queues deferred tasks
   9817  *
   9818  * PARAMETERS :
   9819  *   @cmd     : deferred task
   9820  *   @args    : deferred task arguments
   9821  *
   9822  * RETURN     : job id of deferred job
   9823  *            : 0 in case of error
   9824  *==========================================================================*/
   9825 uint32_t QCamera2HardwareInterface::queueDeferredWork(DeferredWorkCmd cmd,
   9826                                                       DeferWorkArgs args)
   9827 {
   9828     Mutex::Autolock l(mDefLock);
   9829     for (int32_t i = 0; i < MAX_ONGOING_JOBS; ++i) {
   9830         if (mDefOngoingJobs[i].mDefJobId == 0) {
   9831             DefWork *dw = new DefWork(cmd, sNextJobId, args);
   9832             if (!dw) {
   9833                 LOGE("out of memory.");
   9834                 return 0;
   9835             }
   9836             if (mCmdQueue.enqueue(dw)) {
   9837                 mDefOngoingJobs[i].mDefJobId = sNextJobId++;
   9838                 mDefOngoingJobs[i].mDefJobStatus = 0;
   9839                 if (sNextJobId == 0) { // handle overflow
   9840                     sNextJobId = 1;
   9841                 }
   9842                 mDeferredWorkThread.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB,
   9843                         FALSE,
   9844                         FALSE);
   9845                 return mDefOngoingJobs[i].mDefJobId;
   9846             } else {
   9847                 LOGD("Command queue not active! cmd = %d", cmd);
   9848                 delete dw;
   9849                 return 0;
   9850             }
   9851         }
   9852     }
   9853     return 0;
   9854 }
   9855 
   9856 /*===========================================================================
   9857  * FUNCTION   : initJpegHandle
   9858  *
   9859  * DESCRIPTION: Opens JPEG client and gets a handle.
   9860  *                     Sends Dual cam calibration info if present
   9861  *
   9862  * RETURN     : int32_t type of status
   9863  *              NO_ERROR  -- success
   9864  *              none-zero failure code
   9865  *==========================================================================*/
   9866 int32_t QCamera2HardwareInterface::initJpegHandle() {
   9867     // Check if JPEG client handle is present
   9868     LOGH("E");
   9869     if(!mJpegClientHandle) {
   9870         mm_dimension max_size = {0, 0};
   9871         cam_dimension_t size;
   9872 
   9873         mParameters.getMaxPicSize(size);
   9874         max_size.w = size.width;
   9875         max_size.h = size.height;
   9876 
   9877         if (getRelatedCamSyncInfo()->sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
   9878             if (m_bRelCamCalibValid) {
   9879                 mJpegClientHandle = jpeg_open(&mJpegHandle, &mJpegMpoHandle,
   9880                         max_size, &mJpegMetadata);
   9881             } else {
   9882                 mJpegClientHandle =  jpeg_open(&mJpegHandle, &mJpegMpoHandle,
   9883                         max_size, NULL);
   9884             }
   9885         } else {
   9886             mJpegClientHandle = jpeg_open(&mJpegHandle, NULL, max_size, NULL);
   9887         }
   9888         if (!mJpegClientHandle) {
   9889             LOGE("Error !! jpeg_open failed!! ");
   9890             return UNKNOWN_ERROR;
   9891         }
   9892         // Set JPEG initialized as true to signify that this camera
   9893         // has initialized the handle
   9894         mJpegHandleOwner = true;
   9895     }
   9896     LOGH("X mJpegHandleOwner: %d, mJpegClientHandle: %d camera id: %d",
   9897              mJpegHandleOwner, mJpegClientHandle, mCameraId);
   9898     return NO_ERROR;
   9899 }
   9900 
   9901 /*===========================================================================
   9902  * FUNCTION   : deinitJpegHandle
   9903  *
   9904  * DESCRIPTION: Closes JPEG client using handle
   9905  *
   9906  * RETURN     : int32_t type of status
   9907  *              NO_ERROR  -- success
   9908  *              none-zero failure code
   9909  *==========================================================================*/
   9910 int32_t QCamera2HardwareInterface::deinitJpegHandle() {
   9911     int32_t rc = NO_ERROR;
   9912     LOGH("E");
   9913     // Check if JPEG client handle is present and inited by this camera
   9914     if(mJpegHandleOwner && mJpegClientHandle) {
   9915         rc = mJpegHandle.close(mJpegClientHandle);
   9916         if (rc != NO_ERROR) {
   9917             LOGE("Error!! Closing mJpegClientHandle: %d failed",
   9918                      mJpegClientHandle);
   9919         }
   9920         memset(&mJpegHandle, 0, sizeof(mJpegHandle));
   9921         memset(&mJpegMpoHandle, 0, sizeof(mJpegMpoHandle));
   9922         mJpegHandleOwner = false;
   9923     }
   9924     mJpegClientHandle = 0;
   9925     LOGH("X rc = %d", rc);
   9926     return rc;
   9927 }
   9928 
   9929 /*===========================================================================
   9930  * FUNCTION   : setJpegHandleInfo
   9931  *
   9932  * DESCRIPTION: sets JPEG client handle info
   9933  *
   9934  * PARAMETERS:
   9935  *                  @ops                    : JPEG ops
   9936  *                  @mpo_ops             : Jpeg MPO ops
   9937  *                  @pJpegClientHandle : o/p Jpeg Client Handle
   9938  *
   9939  * RETURN     : int32_t type of status
   9940  *              NO_ERROR  -- success
   9941  *              none-zero failure code
   9942  *==========================================================================*/
   9943 int32_t QCamera2HardwareInterface::setJpegHandleInfo(mm_jpeg_ops_t *ops,
   9944         mm_jpeg_mpo_ops_t *mpo_ops, uint32_t pJpegClientHandle) {
   9945 
   9946     if (pJpegClientHandle && ops && mpo_ops) {
   9947         LOGH("Setting JPEG client handle %d",
   9948                 pJpegClientHandle);
   9949         memcpy(&mJpegHandle, ops, sizeof(mm_jpeg_ops_t));
   9950         memcpy(&mJpegMpoHandle, mpo_ops, sizeof(mm_jpeg_mpo_ops_t));
   9951         mJpegClientHandle = pJpegClientHandle;
   9952         return NO_ERROR;
   9953     }
   9954     else {
   9955         LOGE("Error!! No Handle found: %d",
   9956                 pJpegClientHandle);
   9957         return BAD_VALUE;
   9958     }
   9959 }
   9960 
   9961 /*===========================================================================
   9962  * FUNCTION   : getJpegHandleInfo
   9963  *
   9964  * DESCRIPTION: gets JPEG client handle info
   9965  *
   9966  * PARAMETERS:
   9967  *                  @ops                    : JPEG ops
   9968  *                  @mpo_ops             : Jpeg MPO ops
   9969  *                  @pJpegClientHandle : o/p Jpeg Client Handle
   9970  *
   9971  * RETURN     : int32_t type of status
   9972  *              NO_ERROR  -- success
   9973  *              none-zero failure code
   9974  *==========================================================================*/
   9975 int32_t QCamera2HardwareInterface::getJpegHandleInfo(mm_jpeg_ops_t *ops,
   9976         mm_jpeg_mpo_ops_t *mpo_ops, uint32_t *pJpegClientHandle) {
   9977 
   9978     if (NO_ERROR != waitDeferredWork(mInitPProcJob)) {
   9979         LOGE("Init PProc Deferred work failed");
   9980         return UNKNOWN_ERROR;
   9981     }
   9982     // Copy JPEG ops if present
   9983     if (ops && mpo_ops && pJpegClientHandle) {
   9984         memcpy(ops, &mJpegHandle, sizeof(mm_jpeg_ops_t));
   9985         memcpy(mpo_ops, &mJpegMpoHandle, sizeof(mm_jpeg_mpo_ops_t));
   9986         *pJpegClientHandle = mJpegClientHandle;
   9987         LOGH("Getting JPEG client handle %d",
   9988                 pJpegClientHandle);
   9989         return NO_ERROR;
   9990     } else {
   9991         return BAD_VALUE;
   9992     }
   9993 }
   9994 
   9995 /*===========================================================================
   9996  * FUNCTION   : dequeueDeferredWork
   9997  *
   9998  * DESCRIPTION: function which dequeues deferred tasks
   9999  *
   10000  * PARAMETERS :
   10001  *   @dw      : deferred work
   10002  *   @jobStatus: deferred task job status
   10003  *
   10004  * RETURN     : int32_t type of status
   10005  *              NO_ERROR  -- success
   10006  *              none-zero failure code
   10007  *==========================================================================*/
   10008 uint32_t QCamera2HardwareInterface::dequeueDeferredWork(DefWork* dw, int32_t jobStatus)
   10009 {
   10010     Mutex::Autolock l(mDefLock);
   10011     for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
   10012         if (mDefOngoingJobs[i].mDefJobId == dw->id) {
   10013             if (jobStatus != NO_ERROR) {
   10014                 mDefOngoingJobs[i].mDefJobStatus = jobStatus;
   10015                 LOGH("updating job status %d for id %d",
   10016                          jobStatus, dw->id);
   10017             } else {
   10018                 mDefOngoingJobs[i].mDefJobId = 0;
   10019                 mDefOngoingJobs[i].mDefJobStatus = 0;
   10020             }
   10021             delete dw;
   10022             mDefCond.broadcast();
   10023             return NO_ERROR;
   10024         }
   10025     }
   10026 
   10027     return UNKNOWN_ERROR;
   10028 }
   10029 
   10030 /*===========================================================================
   10031  * FUNCTION   : getDefJobStatus
   10032  *
   10033  * DESCRIPTION: Gets if a deferred task is success/fail
   10034  *
   10035  * PARAMETERS :
   10036  *   @job_id  : deferred task id
   10037  *
   10038  * RETURN     : NO_ERROR if the job success, otherwise false
   10039  *
   10040  * PRECONDITION : mDefLock is held by current thread
   10041  *==========================================================================*/
   10042 int32_t QCamera2HardwareInterface::getDefJobStatus(uint32_t &job_id)
   10043 {
   10044     for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
   10045         if (mDefOngoingJobs[i].mDefJobId == job_id) {
   10046             if ( NO_ERROR != mDefOngoingJobs[i].mDefJobStatus ) {
   10047                 LOGE("job_id (%d) was failed", job_id);
   10048                 return mDefOngoingJobs[i].mDefJobStatus;
   10049             }
   10050             else
   10051                 return NO_ERROR;
   10052         }
   10053     }
   10054     return NO_ERROR;
   10055 }
   10056 
   10057 
   10058 /*===========================================================================
   10059  * FUNCTION   : checkDeferredWork
   10060  *
   10061  * DESCRIPTION: checks if a deferred task is in progress
   10062  *
   10063  * PARAMETERS :
   10064  *   @job_id  : deferred task id
   10065  *
   10066  * RETURN     : true if the task exists, otherwise false
   10067  *
   10068  * PRECONDITION : mDefLock is held by current thread
   10069  *==========================================================================*/
   10070 bool QCamera2HardwareInterface::checkDeferredWork(uint32_t &job_id)
   10071 {
   10072     for (uint32_t i = 0; i < MAX_ONGOING_JOBS; i++) {
   10073         if (mDefOngoingJobs[i].mDefJobId == job_id) {
   10074             return (NO_ERROR == mDefOngoingJobs[i].mDefJobStatus);
   10075         }
   10076     }
   10077     return false;
   10078 }
   10079 
   10080 /*===========================================================================
   10081  * FUNCTION   : waitDeferredWork
   10082  *
   10083  * DESCRIPTION: waits for a deferred task to finish
   10084  *
   10085  * PARAMETERS :
   10086  *   @job_id  : deferred task id
   10087  *
   10088  * RETURN     : int32_t type of status
   10089  *              NO_ERROR  -- success
   10090  *              none-zero failure code
   10091  *==========================================================================*/
   10092 int32_t QCamera2HardwareInterface::waitDeferredWork(uint32_t &job_id)
   10093 {
   10094     Mutex::Autolock l(mDefLock);
   10095 
   10096     if (job_id == 0) {
   10097         LOGD("Invalid job id %d", job_id);
   10098         return NO_ERROR;
   10099     }
   10100 
   10101     while (checkDeferredWork(job_id) == true ) {
   10102         mDefCond.waitRelative(mDefLock, CAMERA_DEFERRED_THREAD_TIMEOUT);
   10103     }
   10104     return getDefJobStatus(job_id);
   10105 }
   10106 
   10107 /*===========================================================================
   10108  * FUNCTION   : scheduleBackgroundTask
   10109  *
   10110  * DESCRIPTION: Run a requested task in the deferred thread
   10111  *
   10112  * PARAMETERS :
   10113  *   @bgTask  : Task to perform in the background
   10114  *
   10115  * RETURN     : job id of deferred job
   10116  *            : 0 in case of error
   10117  *==========================================================================*/
   10118 uint32_t QCamera2HardwareInterface::scheduleBackgroundTask(BackgroundTask* bgTask)
   10119 {
   10120     DeferWorkArgs args;
   10121     memset(&args, 0, sizeof(DeferWorkArgs));
   10122     args.genericArgs = bgTask;
   10123 
   10124     return queueDeferredWork(CMD_DEF_GENERIC, args);
   10125 }
   10126 
   10127 /*===========================================================================
   10128  * FUNCTION   : waitForBackgroundTask
   10129  *
   10130  * DESCRIPTION: Wait for a background task to complete
   10131  *
   10132  * PARAMETERS :
   10133  *   @taskId  : Task id to wait for
   10134  *
   10135  * RETURN     : int32_t type of status
   10136  *              NO_ERROR  -- success
   10137  *              none-zero failure code
   10138  *==========================================================================*/
   10139 int32_t QCamera2HardwareInterface::waitForBackgroundTask(uint32_t& taskId)
   10140 {
   10141     return waitDeferredWork(taskId);
   10142 }
   10143 
   10144 /*===========================================================================
   10145  * FUNCTION   : needDeferedAllocation
   10146  *
   10147  * DESCRIPTION: Function to decide background task for streams
   10148  *
   10149  * PARAMETERS :
   10150  *   @stream_type  : stream type
   10151  *
   10152  * RETURN     : true - if background task is needed
   10153  *              false -  if background task is NOT needed
   10154  *==========================================================================*/
   10155 bool QCamera2HardwareInterface::needDeferred(cam_stream_type_t stream_type)
   10156 {
   10157     if ((stream_type == CAM_STREAM_TYPE_PREVIEW && mPreviewWindow == NULL)
   10158             || (stream_type == CAM_STREAM_TYPE_ANALYSIS)) {
   10159         return FALSE;
   10160     }
   10161 
   10162     if ((stream_type == CAM_STREAM_TYPE_RAW)
   10163             && (mParameters.getofflineRAW())) {
   10164         return FALSE;
   10165     }
   10166 
   10167     if ((stream_type == CAM_STREAM_TYPE_SNAPSHOT)
   10168             && (!mParameters.getRecordingHintValue())){
   10169         return TRUE;
   10170     }
   10171 
   10172     if ((stream_type == CAM_STREAM_TYPE_PREVIEW)
   10173             || (stream_type == CAM_STREAM_TYPE_METADATA)
   10174             || (stream_type == CAM_STREAM_TYPE_RAW)
   10175             || (stream_type == CAM_STREAM_TYPE_POSTVIEW)) {
   10176         return TRUE;
   10177     }
   10178 
   10179     if (stream_type == CAM_STREAM_TYPE_VIDEO) {
   10180         return FALSE;
   10181     }
   10182     return FALSE;
   10183 }
   10184 
   10185 /*===========================================================================
   10186  * FUNCTION   : isRegularCapture
   10187  *
   10188  * DESCRIPTION: Check configuration for regular catpure
   10189  *
   10190  * PARAMETERS :
   10191  *
   10192  * RETURN     : true - regular capture
   10193  *              false - other type of capture
   10194  *==========================================================================*/
   10195 bool QCamera2HardwareInterface::isRegularCapture()
   10196 {
   10197     bool ret = false;
   10198 
   10199     if (numOfSnapshotsExpected() == 1 &&
   10200         !isLongshotEnabled() &&
   10201         !mParameters.isHDREnabled() &&
   10202         !mParameters.getRecordingHintValue() &&
   10203         !isZSLMode() && !mParameters.getofflineRAW()) {
   10204             ret = true;
   10205     }
   10206     return ret;
   10207 }
   10208 
   10209 /*===========================================================================
   10210  * FUNCTION   : getLogLevel
   10211  *
   10212  * DESCRIPTION: Reads the log level property into a variable
   10213  *
   10214  * PARAMETERS :
   10215  *   None
   10216  *
   10217  * RETURN     :
   10218  *   None
   10219  *==========================================================================*/
   10220 void QCamera2HardwareInterface::getLogLevel()
   10221 {
   10222     char prop[PROPERTY_VALUE_MAX];
   10223 
   10224     property_get("persist.camera.kpi.debug", prop, "1");
   10225     gKpiDebugLevel = atoi(prop);
   10226     return;
   10227 }
   10228 
   10229 /*===========================================================================
   10230  * FUNCTION   : getSensorType
   10231  *
   10232  * DESCRIPTION: Returns the type of sensor being used whether YUV or Bayer
   10233  *
   10234  * PARAMETERS :
   10235  *   None
   10236  *
   10237  * RETURN     : Type of sensor - bayer or YUV
   10238  *
   10239  *==========================================================================*/
   10240 cam_sensor_t QCamera2HardwareInterface::getSensorType()
   10241 {
   10242     return gCamCapability[mCameraId]->sensor_type.sens_type;
   10243 }
   10244 
   10245 /*===========================================================================
   10246  * FUNCTION   : startRAWChannel
   10247  *
   10248  * DESCRIPTION: start RAW Channel
   10249  *
   10250  * PARAMETERS :
   10251  *   @pChannel  : Src channel to link this RAW channel.
   10252  *
   10253  * RETURN     : int32_t type of status
   10254  *              NO_ERROR  -- success
   10255  *              none-zero failure code
   10256  *==========================================================================*/
   10257 int32_t QCamera2HardwareInterface::startRAWChannel(QCameraChannel *pMetaChannel)
   10258 {
   10259     int32_t rc = NO_ERROR;
   10260     QCameraChannel *pChannel = m_channels[QCAMERA_CH_TYPE_RAW];
   10261     if ((NULL != pChannel) && (mParameters.getofflineRAW())) {
   10262         // Find and try to link a metadata stream from preview channel
   10263         QCameraStream *pMetaStream = NULL;
   10264 
   10265         if (pMetaChannel != NULL) {
   10266             uint32_t streamNum = pMetaChannel->getNumOfStreams();
   10267             QCameraStream *pStream = NULL;
   10268             for (uint32_t i = 0 ; i < streamNum ; i++ ) {
   10269                 pStream = pMetaChannel->getStreamByIndex(i);
   10270                 if ((NULL != pStream) &&
   10271                         (CAM_STREAM_TYPE_METADATA == pStream->getMyType())) {
   10272                     pMetaStream = pStream;
   10273                     break;
   10274                 }
   10275             }
   10276 
   10277             if (NULL != pMetaStream) {
   10278                 rc = pChannel->linkStream(pMetaChannel, pMetaStream);
   10279                 if (NO_ERROR != rc) {
   10280                     LOGE("Metadata stream link failed %d", rc);
   10281                 }
   10282             }
   10283         }
   10284         rc = pChannel->start();
   10285     }
   10286     return rc;
   10287 }
   10288 
   10289 /*===========================================================================
   10290  * FUNCTION   : startRecording
   10291  *
   10292  * DESCRIPTION: start recording impl
   10293  *
   10294  * PARAMETERS : none
   10295  *
   10296  * RETURN     : int32_t type of status
   10297  *              NO_ERROR  -- success
   10298  *              none-zero failure code
   10299  *==========================================================================*/
   10300 int32_t QCamera2HardwareInterface::stopRAWChannel()
   10301 {
   10302     int32_t rc = NO_ERROR;
   10303     rc = stopChannel(QCAMERA_CH_TYPE_RAW);
   10304     return rc;
   10305 }
   10306 
   10307 /*===========================================================================
   10308  * FUNCTION   : isLowPowerMode
   10309  *
   10310  * DESCRIPTION: Returns TRUE if low power mode settings are to be applied for video recording
   10311  *
   10312  * PARAMETERS :
   10313  *   None
   10314  *
   10315  * RETURN     : TRUE/FALSE
   10316  *
   10317  *==========================================================================*/
   10318 bool QCamera2HardwareInterface::isLowPowerMode()
   10319 {
   10320     cam_dimension_t dim;
   10321     mParameters.getStreamDimension(CAM_STREAM_TYPE_VIDEO, dim);
   10322 
   10323     char prop[PROPERTY_VALUE_MAX];
   10324     property_get("camera.lowpower.record.enable", prop, "0");
   10325     int enable = atoi(prop);
   10326 
   10327     //Enable low power mode if :
   10328     //1. Video resolution is 2k (2048x1080) or above and
   10329     //2. camera.lowpower.record.enable is set
   10330 
   10331     bool isLowpower = mParameters.getRecordingHintValue() && enable
   10332             && ((dim.width * dim.height) >= (2048 * 1080));
   10333     return isLowpower;
   10334 }
   10335 
   10336 }; // namespace qcamera
   10337