xref: /hardware/qcom/camera/msm8998/QCamera2/HAL/QCameraChannel.cpp

/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above
*       copyright notice, this list of conditions and the following
*       disclaimer in the documentation and/or other materials provided
*       with the distribution.
*     * Neither the name of The Linux Foundation nor the names of its
*       contributors may be used to endorse or promote products derived
*       from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#define LOG_TAG "QCameraChannel"

// System dependencies
#include <utils/Errors.h>

// Camera dependencies
#include "QCamera2HWI.h"

extern "C" {
#include "mm_camera_dbg.h"
}

using namespace android;

namespace qcamera {

/*===========================================================================
 * FUNCTION   : QCameraChannel
 *
 * DESCRIPTION: constrcutor of QCameraChannel
 *
 * PARAMETERS :
 *   @cam_handle : camera handle
 *   @cam_ops    : ptr to camera ops table
 *
 * RETURN     : none
 *==========================================================================*/
QCameraChannel::QCameraChannel(uint32_t cam_handle,
                               mm_camera_ops_t *cam_ops)
{
    m_camHandle = cam_handle;
    m_camOps = cam_ops;
    m_bIsActive = false;
    m_bAllowDynBufAlloc = false;
    mDualChannel = is_dual_camera_by_handle(cam_handle);
    m_handle = 0;
}

/*===========================================================================
 * FUNCTION   : QCameraChannel
 *
 * DESCRIPTION: default constrcutor of QCameraChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraChannel::QCameraChannel()
{
    m_camHandle = 0;
    m_camOps = NULL;
    m_bIsActive = false;
    mDualChannel = 0;
    m_handle = 0;
}

/*===========================================================================
 * FUNCTION   : ~QCameraChannel
 *
 * DESCRIPTION: destructor of QCameraChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraChannel::~QCameraChannel()
{
    if (m_bIsActive) {
        stop();
    }
    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL) {
            if (validate_handle(m_handle, mStreams[i]->getChannelHandle())) {
                delete mStreams[i];
            }
        }
    }
    mStreams.clear();
    m_camOps->delete_channel(m_camHandle, m_handle);
    m_handle = 0;
}

/*===========================================================================
 * FUNCTION   : deleteChannel
 *
 * DESCRIPTION: deletes a camera channel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
void QCameraChannel::deleteChannel()
{
    if (m_bIsActive) {
        stop();
    }
    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
            mStreams[i]->deleteStream();
        }
    }
    m_camOps->delete_channel(m_camHandle, m_handle);
}

/*===========================================================================
 * FUNCTION   : setStreamSyncCB
 *
 * DESCRIPTION: reg callback function to stream of stream type
 *
 * PARAMETERS :
 *    @stream_type : Stream type for which callback needs to be registered.
 *    @stream_cb   : Callback function

 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              non-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::setStreamSyncCB (cam_stream_type_t stream_type,
        stream_cb_routine stream_cb)
{
    int32_t rc = UNKNOWN_ERROR;
    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) && (stream_type == mStreams[i]->getMyType())) {
            rc = mStreams[i]->setSyncDataCB(stream_cb);
            break;
        }
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : init
 *
 * DESCRIPTION: initialization of channel
 *
 * PARAMETERS :
 *   @attr    : channel bundle attribute setting
 *   @dataCB  : data notify callback
 *   @userData: user data ptr
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::init(mm_camera_channel_attr_t *attr,
                             mm_camera_buf_notify_t dataCB,
                             void *userData)
{
    m_handle = m_camOps->add_channel(m_camHandle,
                                      attr,
                                      dataCB,
                                      userData);
    if (m_handle == 0) {
        LOGE("Add channel failed");
        return UNKNOWN_ERROR;
    }

    mActiveCameras = MM_CAMERA_TYPE_MAIN;
    if (isDualChannel()) {
        mActiveCameras |= MM_CAMERA_TYPE_AUX;
    }
    mMasterCamera = MM_CAMERA_TYPE_MAIN;
    mBundledSnapshot = false;
    return NO_ERROR;
}

/*===========================================================================
 * FUNCTION   : getChHandleForStream
 *
 * DESCRIPTION: return actual channel handle based on use case per stream
 *
 * PARAMETERS :
 *   @ch_type  : type of channel
 *
 * RETURN     : number of buffers needed
 * NOTE :  Based on the use cases and auxillary camera type,
           we can decide channel handle for streams.
           Incase, we want to avoid any stream for auxillary camera,
           we can decide here.
 *==========================================================================*/
uint32_t QCameraChannel::getChHandleForStream(cam_stream_type_t stream_type)
{
    uint32_t handle = m_handle;
    if (!mDualChannel) {
        return m_handle;
    }

    /*Based on the use case, decide channel handle for channel*/
    switch (stream_type) {
    case CAM_STREAM_TYPE_PREVIEW:
    case CAM_STREAM_TYPE_SNAPSHOT:
    case CAM_STREAM_TYPE_VIDEO:
    case CAM_STREAM_TYPE_METADATA:
    case CAM_STREAM_TYPE_ANALYSIS:
    case CAM_STREAM_TYPE_CALLBACK:
        handle = m_handle;
        break;
    case CAM_STREAM_TYPE_POSTVIEW:
    case CAM_STREAM_TYPE_RAW:
    case CAM_STREAM_TYPE_OFFLINE_PROC:
    case CAM_STREAM_TYPE_DEFAULT:
    case CAM_STREAM_TYPE_MAX:
    default:
        handle = get_main_camera_handle(m_handle);
        break;
    }
    return handle;
}

/*===========================================================================
 * FUNCTION   : addStream
 *
 * DESCRIPTION: add a stream into channel
 *
 * PARAMETERS :
 *   @allocator      : stream related buffer allocator
 *   @streamInfoBuf  : ptr to buf that contains stream info
 *   @miscBuf        : ptr to buf that contains misc buffers
 *   @minStreamBufNum: number of stream buffers needed
 *   @paddingInfo    : padding information
 *   @stream_cb      : stream data notify callback
 *   @userdata       : user data ptr
 *   @bDynAllocBuf   : flag indicating if allow allocate buffers in 2 steps
 *   @online_rotation: rotation applied online
 *   @cam_type       : Camera type in case of dual camera
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::addStream(QCameraAllocator &allocator,
        QCameraHeapMemory *streamInfoBuf, QCameraHeapMemory *miscBuf,
        cam_padding_info_t *paddingInfo, stream_cb_routine stream_cb,
        void *userdata, bool bDynAllocBuf, bool bDeffAlloc,
        cam_rotation_t online_rotation,
        uint32_t cam_type)
{
    int32_t rc = NO_ERROR;
    uint32_t ch_handle = m_handle;

    if (mStreams.size() >= MAX_STREAM_NUM_IN_BUNDLE) {
        LOGE("stream number (%zu) exceeds max limit (%d)",
               mStreams.size(), MAX_STREAM_NUM_IN_BUNDLE);
        if (streamInfoBuf != NULL) {
            streamInfoBuf->deallocate();
            delete streamInfoBuf;
            streamInfoBuf = NULL;
        }
        return BAD_VALUE;
    }

    if (cam_type == MM_CAMERA_TYPE_MAIN) {
        ch_handle = get_main_camera_handle(m_handle);
    } else if (cam_type == MM_CAMERA_TYPE_AUX) {
        ch_handle = get_aux_camera_handle(m_handle);
    }

    QCameraStream *pStream = new QCameraStream(allocator,
            m_camHandle, ch_handle, m_camOps, paddingInfo, bDeffAlloc,
            online_rotation);
    if (pStream == NULL) {
        LOGE("No mem for Stream");
        if (streamInfoBuf != NULL) {
            streamInfoBuf->deallocate();
            delete streamInfoBuf;
            streamInfoBuf = NULL;
        }
        return NO_MEMORY;
    }

    rc = pStream->init(streamInfoBuf, miscBuf,
                       stream_cb, userdata, bDynAllocBuf);
    if (rc == 0) {
        Mutex::Autolock lock(mStreamLock);
        mStreams.add(pStream);
    } else {
        delete pStream;
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : linkStream
 *
 * DESCRIPTION: link a stream into channel
 *
 * PARAMETERS :
 *   @ch      : Channel which the stream belongs to
 *   @stream  : Stream which needs to be linked
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::linkStream(QCameraChannel *ch, QCameraStream *stream)
{
    int32_t rc = NO_ERROR;

    if ((0 == m_handle) || (NULL == ch) || (NULL == stream)) {
        return NO_INIT;
    }

    int32_t handle = m_camOps->link_stream(m_camHandle,
            ch->getMyHandle(),
            stream->getMyHandle(),
            m_handle);
    if (0 == handle) {
        LOGE("Linking of stream failed");
        rc = INVALID_OPERATION;
    } else {
        Mutex::Autolock lock(mStreamLock);
        mStreams.add(stream);
    }

    return rc;
}

/*===========================================================================
 * FUNCTION   : start
 *
 * DESCRIPTION: start channel, which will start all streams belong to this channel
 *
 * PARAMETERS : None
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::start()
{
    int32_t rc = NO_ERROR;

    if(m_bIsActive) {
        LOGW("Attempt to start active channel");
        return rc;
    }

    // there is more than one stream in the channel
    // we need to notify mctl that all streams in this channel need to be bundled
    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
            mStreams[i]->setBundleInfo();
        }
    }


    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
            mStreams[i]->start();
        }
    }
    rc = m_camOps->start_channel(m_camHandle, m_handle, /*start_sensor_streaming*/true);

    if (rc != NO_ERROR) {
        for (size_t i = 0; i < mStreams.size(); i++) {
            if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
                mStreams[i]->stop();
            }
        }
    } else {
        m_bIsActive = true;
        for (size_t i = 0; i < mStreams.size(); i++) {
            if (mStreams[i] != NULL) {
                mStreams[i]->cond_signal();
            }
        }
    }

    return rc;
}

/*===========================================================================
 * FUNCTION   : stop
 *
 * DESCRIPTION: stop a channel, which will stop all streams belong to this channel
 *
 * PARAMETERS : none
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::stop()
{
    int32_t rc = NO_ERROR;
    size_t i = 0;

    if (!m_bIsActive) {
        return NO_INIT;
    }

    {
        Mutex::Autolock lock(mStreamLock);
        while(i < mStreams.size()) {
            if (mStreams[i] != NULL) {
                if (validate_handle(m_handle, mStreams[i]->getChannelHandle())) {
                    mStreams[i]->stop();
                    i++;
                } else {
                    // Remove linked stream from stream list
                    mStreams.removeAt(i);
                }
            }
        }
    }

    rc = m_camOps->stop_channel(m_camHandle, m_handle, /*stop_immediately*/false);

    m_bIsActive = false;
    return rc;
}

/*===========================================================================
 * FUNCTION   : bufDone
 *
 * DESCRIPTION: return a stream buf back to kernel
 *
 * PARAMETERS :
 *   @recvd_frame  : stream buf frame to be returned
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::bufDone(mm_camera_super_buf_t *recvd_frame)
{
    int32_t rc = NO_ERROR;
    for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
        if (recvd_frame->bufs[i] != NULL) {
            for (uint32_t j = 0; j < mStreams.size(); j++) {
                if (mStreams[j] != NULL &&
                         (validate_handle(mStreams[j]->getMyHandle(),
                         recvd_frame->bufs[i]->stream_id))) {
                    rc = mStreams[j]->bufDone(recvd_frame->bufs[i]->buf_idx);
                    break; // break loop j
                }
            }
        }
    }

    return rc;
}

/*===========================================================================
 * FUNCTION   : bufDone
 *
 * DESCRIPTION: return specified buffer from super buffer to kernel
 *
 * PARAMETERS :
 *   @recvd_frame  : stream buf frame to be returned
 *   @stream_id      : stream ID of the buffer to be released
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::bufDone(mm_camera_super_buf_t *recvd_frame, uint32_t stream_id)
{
    int32_t rc = NO_ERROR;
    int32_t index;
    for (int32_t i = 0; i < (int32_t)recvd_frame->num_bufs; i++) {
        index = -1;
        if ((recvd_frame->bufs[i] != NULL) &&
                (recvd_frame->bufs[i]->stream_id == stream_id)) {
            for (uint32_t j = 0; j < mStreams.size(); j++) {
                if ((mStreams[j] != NULL) &&
                        (validate_handle(mStreams[j]->getMyHandle(),
                        recvd_frame->bufs[i]->stream_id))) {
                    rc = mStreams[j]->bufDone(recvd_frame->bufs[i]->buf_idx);
                    index = i;
                    break; // break loop j
                }
            }
            if ((index >= 0) && (index < (int32_t)recvd_frame->num_bufs)) {
                for (int32_t j = index; j < (int32_t)(recvd_frame->num_bufs - 1); j++) {
                    recvd_frame->bufs[j] = recvd_frame->bufs[j + 1];
                }
                recvd_frame->num_bufs--;
                i--;
            }
        }
    }

    return rc;
}

/*===========================================================================
 * FUNCTION   : processZoomDone
 *
 * DESCRIPTION: process zoom done event
 *
 * PARAMETERS :
 *   @previewWindoe : ptr to preview window ops table, needed to set preview
 *                    crop information
 *   @crop_info     : crop info as a result of zoom operation
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::processZoomDone(preview_stream_ops_t *previewWindow,
                                        cam_crop_data_t &crop_info)
{
    int32_t rc = NO_ERROR;
    Mutex::Autolock lock(mStreamLock);
    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
            rc = mStreams[i]->processZoomDone(previewWindow, crop_info);
        }
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : getStreamByHandle
 *
 * DESCRIPTION: return stream object by stream handle
 *
 * PARAMETERS :
 *   @streamHandle : stream handle
 *
 * RETURN     : stream object. NULL if not found
 *==========================================================================*/
QCameraStream *QCameraChannel::getStreamByHandle(uint32_t streamHandle)
{
    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL &&
                (validate_handle(mStreams[i]->getMyHandle(), streamHandle))) {
            return mStreams[i];
        }
    }
    return NULL;
}

/*===========================================================================
 * FUNCTION   : getStreamByServerID
 *
 * DESCRIPTION: return stream object by stream server ID from daemon
 *
 * PARAMETERS :
 *   @serverID : stream server ID
 *
 * RETURN     : stream object. NULL if not found
 *==========================================================================*/
QCameraStream *QCameraChannel::getStreamByServerID(uint32_t serverID)
{
    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL && mStreams[i]->getMyServerID() == serverID) {
            return mStreams[i];
        }
    }
    return NULL;
}

/*===========================================================================
 * FUNCTION   : getStreamByIndex
 *
 * DESCRIPTION: return stream object by index of streams in the channel
 *
 * PARAMETERS :
 *   @index : index of stream in the channel
 *
 * RETURN     : stream object. NULL if not found
 *==========================================================================*/
QCameraStream *QCameraChannel::getStreamByIndex(uint32_t index)
{
    if (index >= MAX_STREAM_NUM_IN_BUNDLE) {
        return NULL;
    }

    if (index < mStreams.size()) {
        return mStreams[index];
    }
    return NULL;
}

/*===========================================================================
 * FUNCTION   : UpdateStreamBasedParameters
 *
 * DESCRIPTION: update any stream based settings from parameters
 *
 * PARAMETERS :
 *   @param   : reference to parameters object
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::UpdateStreamBasedParameters(QCameraParametersIntf &param)
{
    int32_t rc = NO_ERROR;
    Mutex::Autolock lock(mStreamLock);
    if (param.isPreviewFlipChanged()) {
        // try to find preview stream
        for (size_t i = 0; i < mStreams.size(); i++) {
            if ((mStreams[i] != NULL) &&
                    (validate_handle(m_handle, mStreams[i]->getChannelHandle())) &&
                    (mStreams[i]->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
                    (mStreams[i]->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW))) ) {
                cam_stream_parm_buffer_t param_buf;
                memset(&param_buf, 0, sizeof(cam_stream_parm_buffer_t));
                param_buf.type = CAM_STREAM_PARAM_TYPE_SET_FLIP;
                param_buf.flipInfo.flip_mask =
                        (uint32_t)param.getFlipMode(CAM_STREAM_TYPE_PREVIEW);
                rc = mStreams[i]->setParameter(param_buf);
                if (rc != NO_ERROR) {
                    LOGW("set preview stream flip failed");
                }
            }
        }
    }
    if (param.isVideoFlipChanged()) {
        // try to find video stream
        for (size_t i = 0; i < mStreams.size(); i++) {
            if ((mStreams[i] != NULL) &&
                    (validate_handle(m_handle, mStreams[i]->getChannelHandle())) &&
                    (mStreams[i]->isTypeOf(CAM_STREAM_TYPE_VIDEO) ||
                    (mStreams[i]->isOrignalTypeOf(CAM_STREAM_TYPE_VIDEO))) ) {
                cam_stream_parm_buffer_t param_buf;
                memset(&param_buf, 0, sizeof(cam_stream_parm_buffer_t));
                param_buf.type = CAM_STREAM_PARAM_TYPE_SET_FLIP;
                param_buf.flipInfo.flip_mask =
                        (uint32_t)param.getFlipMode(CAM_STREAM_TYPE_VIDEO);
                rc = mStreams[i]->setParameter(param_buf);
                if (rc != NO_ERROR) {
                    LOGW("set video stream flip failed");
                }
            }
        }
    }
    if (param.isSnapshotFlipChanged()) {
        // try to find snapshot/postview stream
        for (size_t i = 0; i < mStreams.size(); i++) {
            if (mStreams[i] != NULL &&
                    (validate_handle(m_handle, mStreams[i]->getChannelHandle())) &&
                    (mStreams[i]->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
                     mStreams[i]->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
                     mStreams[i]->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
                 mStreams[i]->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW) ) ) {
                cam_stream_parm_buffer_t param_buf;
                memset(&param_buf, 0, sizeof(cam_stream_parm_buffer_t));
                param_buf.type = CAM_STREAM_PARAM_TYPE_SET_FLIP;
                param_buf.flipInfo.flip_mask =
                        (uint32_t)param.getFlipMode(CAM_STREAM_TYPE_SNAPSHOT);
                rc = mStreams[i]->setParameter(param_buf);
                if (rc != NO_ERROR) {
                    LOGW("set snapshot stream flip failed");
                }
            }
        }
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : processCameraControl
 *
 * DESCRIPTION:  Suspend and resume camera
 *
 * PARAMETERS :
 *   @camState   : Camera start. MAIN/AUX/MAIN&AUX
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::processCameraControl(
        uint32_t camState,
        bool     bundledSnapshot)
{
    int32_t ret = NO_ERROR;

    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL && mStreams[i]->isDualStream()) {
            ret = mStreams[i]->processCameraControl(camState);
            if (ret != NO_ERROR) {
                LOGE("Stream handle failed");
                break;
            }
        }
    }

    mActiveCameras   = camState;
    mBundledSnapshot = bundledSnapshot;
    return ret;
}

/*===========================================================================
 * FUNCTION   : switchChannelCb
 *
 * DESCRIPTION: switch channel's in case of dual camera
 *
 * PARAMETERS :
 * @camMaster : Master camera
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraChannel::switchChannelCb(uint32_t camMaster)
{
    int32_t ret = NO_ERROR;

    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL && mStreams[i]->isDualStream()) {
            ret = mStreams[i]->switchStreamCb(camMaster);
            if (ret != NO_ERROR) {
                LOGE("Stream Switch Failed");
                break;
            }
        }
    }

    // Update master camera
    mMasterCamera = camMaster;
    return ret;
}

/*===========================================================================
 * FUNCTION   : getSnapshotHandle
 *
 * DESCRIPTION: Get the camera handle for snapshot based on the bundlesnapshot
 *              flag and active camera state
 *
 * PARAMETERS : None
 *
 * RETURN     : camera handle for snapshot
 *
 *==========================================================================*/
uint32_t QCameraChannel::getSnapshotHandle()
{
    uint32_t snapshotHandle = 0;

    if ((mActiveCameras == MM_CAMERA_DUAL_CAM) && mBundledSnapshot) {
        snapshotHandle = m_handle;
    } else {
        snapshotHandle = (mMasterCamera == MM_CAMERA_TYPE_MAIN) ?
                get_main_camera_handle(m_handle) : get_aux_camera_handle(m_handle);
    }

    return snapshotHandle;
}

/*===========================================================================
 * FUNCTION   : QCameraPicChannel
 *
 * DESCRIPTION: constructor of QCameraPicChannel
 *
 * PARAMETERS :
 *   @cam_handle : camera handle
 *   @cam_ops    : ptr to camera ops table
 *
 * RETURN     : none
 *==========================================================================*/
QCameraPicChannel::QCameraPicChannel(uint32_t cam_handle,
                                     mm_camera_ops_t *cam_ops) :
    QCameraChannel(cam_handle, cam_ops)
{
    m_bAllowDynBufAlloc = true;
}

/*===========================================================================
 * FUNCTION   : QCameraPicChannel
 *
 * DESCRIPTION: default constructor of QCameraPicChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraPicChannel::QCameraPicChannel()
{
    m_bAllowDynBufAlloc = true;
}

/*===========================================================================
 * FUNCTION   : ~QCameraPicChannel
 *
 * DESCRIPTION: destructor of QCameraPicChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraPicChannel::~QCameraPicChannel()
{
}

/*===========================================================================
 * FUNCTION   : takePicture
 *
 * DESCRIPTION: send request for queued snapshot frames
 *
 * PARAMETERS :
 *   @buf : request buf info
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraPicChannel::takePicture (mm_camera_req_buf_t *buf)
{
    uint32_t snapshotHandle = getSnapshotHandle();
    LOGD("mSnapshotHandle = 0x%x", snapshotHandle);
    int32_t rc = m_camOps->request_super_buf(m_camHandle, snapshotHandle, buf);
    return rc;
}

/*===========================================================================
 * FUNCTION   : cancelPicture
 *
 * DESCRIPTION: cancel request for queued snapshot frames
 *
 * PARAMETERS : none
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraPicChannel::cancelPicture()
{
    int32_t rc = m_camOps->cancel_super_buf_request(m_camHandle, m_handle);
    return rc;
}

/*===========================================================================
 * FUNCTION   : stopAdvancedCapture
 *
 * DESCRIPTION: stop advanced capture based on advanced capture type.
 *
 * PARAMETERS :
 *   @type : advanced capture type.
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraPicChannel::stopAdvancedCapture(mm_camera_advanced_capture_t type)
{
    int32_t rc = m_camOps->process_advanced_capture(m_camHandle,
            m_handle, type, 0, NULL);
    return rc;
}

/*===========================================================================
 * FUNCTION   : startAdvancedCapture
 *
 * DESCRIPTION: start advanced capture based on advanced capture type.
 *
 * PARAMETERS :
 *   @type : advanced capture type.
 *   @config: advance capture config
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraPicChannel::startAdvancedCapture(mm_camera_advanced_capture_t type,
        cam_capture_frame_config_t *config)
{
    int32_t rc = NO_ERROR;

    rc = m_camOps->process_advanced_capture(m_camHandle, getSnapshotHandle(), type,
            1, config);
    return rc;
}

/*===========================================================================
* FUNCTION   : flushSuperbuffer
 *
 * DESCRIPTION: flush the all superbuffer frames.
 *
 * PARAMETERS :
 *   @frame_idx : frame index of focused frame
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraPicChannel::flushSuperbuffer(uint32_t frame_idx)
{
    int32_t rc = m_camOps->flush_super_buf_queue(m_camHandle, m_handle, frame_idx);
    return rc;
}

/*===========================================================================
 * FUNCTION   : QCameraVideoChannel
 *
 * DESCRIPTION: constructor of QCameraVideoChannel
 *
 * PARAMETERS :
 *   @cam_handle : camera handle
 *   @cam_ops    : ptr to camera ops table
 *
 * RETURN     : none
 *==========================================================================*/
QCameraVideoChannel::QCameraVideoChannel(uint32_t cam_handle,
                                         mm_camera_ops_t *cam_ops) :
    QCameraChannel(cam_handle, cam_ops)
{
}

/*===========================================================================
 * FUNCTION   : QCameraVideoChannel
 *
 * DESCRIPTION: default constructor of QCameraVideoChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraVideoChannel::QCameraVideoChannel()
{
}

/*===========================================================================
 * FUNCTION   : ~QCameraVideoChannel
 *
 * DESCRIPTION: destructor of QCameraVideoChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraVideoChannel::~QCameraVideoChannel()
{
}

/*===========================================================================
 * FUNCTION   : takePicture
 *
 * DESCRIPTION: send request for queued snapshot frames
 *
 * PARAMETERS :
 *   @mm_camera_req_buf_t : request buf info
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraVideoChannel::takePicture(mm_camera_req_buf_t *buf)
{
    uint32_t snapshotHandle = getSnapshotHandle();
    LOGD("mSnapshotHandle = 0x%x", snapshotHandle);
    int32_t rc = m_camOps->request_super_buf(m_camHandle, snapshotHandle, buf);
    return rc;
}

/*===========================================================================
 * FUNCTION   : cancelPicture
 *
 * DESCRIPTION: cancel request for queued snapshot frames
 *
 * PARAMETERS : none
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraVideoChannel::cancelPicture()
{
    int32_t rc = m_camOps->cancel_super_buf_request(m_camHandle, m_handle);
    return rc;
}

/*===========================================================================
 * FUNCTION   : releaseFrame
 *
 * DESCRIPTION: return video frame from app
 *
 * PARAMETERS :
 *   @opaque     : ptr to video frame to be returned
 *   @isMetaData : if frame is a metadata or real frame
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraVideoChannel::releaseFrame(const void * opaque, bool isMetaData)
{
    QCameraStream *pVideoStream = NULL;
    for (size_t i = 0; i < mStreams.size(); i++) {
        if (mStreams[i] != NULL && mStreams[i]->isTypeOf(CAM_STREAM_TYPE_VIDEO)) {
            pVideoStream = mStreams[i];
            break;
        }
    }

    if (NULL == pVideoStream) {
        LOGE("No video stream in the channel");
        return BAD_VALUE;
    }

    int32_t rc = pVideoStream->bufDone(opaque, isMetaData);
    return rc;
}

/*===========================================================================
 * FUNCTION   : QCameraReprocessChannel
 *
 * DESCRIPTION: constructor of QCameraReprocessChannel
 *
 * PARAMETERS :
 *   @cam_handle : camera handle
 *   @cam_ops    : ptr to camera ops table
 *
 * RETURN     : none
 *==========================================================================*/
QCameraReprocessChannel::QCameraReprocessChannel(uint32_t cam_handle,
                                                 mm_camera_ops_t *cam_ops) :
    QCameraChannel(cam_handle, cam_ops),
    m_pSrcChannel(NULL),
    mPassCount(0)
{
    memset(mSrcStreamHandles, 0, sizeof(mSrcStreamHandles));
}

/*===========================================================================
 * FUNCTION   : QCameraReprocessChannel
 *
 * DESCRIPTION: default constructor of QCameraReprocessChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraReprocessChannel::QCameraReprocessChannel() :
    m_pSrcChannel(NULL),
    mPassCount(0)
{
}

/*===========================================================================
 * FUNCTION   : ~QCameraReprocessChannel
 *
 * DESCRIPTION: destructor of QCameraReprocessChannel
 *
 * PARAMETERS : none
 *
 * RETURN     : none
 *==========================================================================*/
QCameraReprocessChannel::~QCameraReprocessChannel()
{
}

/*===========================================================================
 * FUNCTION   : addReprocStreamsFromSource
 *
 * DESCRIPTION: add reprocess streams from input source channel
 *
 * PARAMETERS :
 *   @allocator      : stream related buffer allocator
 *   @featureConfig  : pp feature configuration
 *   @pSrcChannel    : ptr to input source channel that needs reprocess
 *   @minStreamBufNum: number of stream buffers needed
 *   @burstNum       : number of burst captures needed
 *   @paddingInfo    : padding information
 *   @param          : reference to parameters
 *   @contStream     : continous streaming mode or burst
 *   @offline        : configure for offline reprocessing
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::addReprocStreamsFromSource(
        QCameraAllocator& allocator, cam_pp_feature_config_t &featureConfig,
        QCameraChannel *pSrcChannel, uint8_t minStreamBufNum, uint8_t burstNum,
        cam_padding_info_t *paddingInfo, QCameraParametersIntf &param, bool contStream,
        bool offline)
{
    int32_t rc = 0;
    QCameraStream *pStream = NULL;
    QCameraHeapMemory *pStreamInfoBuf = NULL;
    QCameraHeapMemory *pMiscBuf = NULL;
    cam_stream_info_t *streamInfo = NULL;
    cam_padding_info_t padding;

    memset(mSrcStreamHandles, 0, sizeof(mSrcStreamHandles));
    if (NULL == paddingInfo) {
        return BAD_VALUE;
    }
    padding = *paddingInfo;
    //Use maximum padding so that the buffer
    //can be rotated
    padding.width_padding = MAX(padding.width_padding, padding.height_padding);
    padding.height_padding = padding.width_padding;
    padding.offset_info.offset_x = 0;
    padding.offset_info.offset_y = 0;

    LOGD("num of src stream = %d", pSrcChannel->getNumOfStreams());
    for (uint32_t i = 0; i < pSrcChannel->getNumOfStreams(); i++) {
        cam_pp_feature_config_t pp_featuremask = featureConfig;
        pStream = pSrcChannel->getStreamByIndex(i);
        if (pStream != NULL) {
            if (param.getofflineRAW() && !((pStream->isTypeOf(CAM_STREAM_TYPE_RAW))
                    || (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW))
                    || (pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
                    || (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))
                    || (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)))) {
                //Skip all the stream other than RAW and POSTVIEW incase of offline of RAW
                continue;
            }

            if (pStream->isTypeOf(CAM_STREAM_TYPE_RAW)
                    && (!param.getofflineRAW())) {
                // Skip raw for reprocess now because PP module cannot handle
                // meta data&raw. May need furthur discussion if Imaginglib need meta data
                continue;
            }

            if (((pStream->isTypeOf(CAM_STREAM_TYPE_METADATA))
                    && !((param.getManualCaptureMode() >=
                    CAM_MANUAL_CAPTURE_TYPE_3) || (param.getQuadraCfa())))
                    || (pStream->isTypeOf(CAM_STREAM_TYPE_ANALYSIS))) {
                // Skip metadata, if not manual capture or quadra cfa
                continue;
            }

            if (pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
                    pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
                    pStream->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
                    pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW)) {
                cam_feature_mask_t feature_mask = featureConfig.feature_mask;

                // skip thumbnail reprocessing if not needed
                if (!param.needThumbnailReprocess(&feature_mask)) {
                    continue;
                }
                // CAC, SHARPNESS, FLIP and WNR would have been already applied -
                // on preview/postview stream in realtime.
                // So, need not apply again.
                feature_mask &= ~(CAM_QCOM_FEATURE_DENOISE2D |
                        CAM_QCOM_FEATURE_CAC |
                        CAM_QCOM_FEATURE_SHARPNESS |
                        CAM_QCOM_FEATURE_FLIP |
                        CAM_QCOM_FEATURE_RAW_PROCESSING);
                if (!feature_mask) {
                    // Skip thumbnail stream reprocessing since no other
                    //reprocessing is enabled.
                    continue;
                }
            }

            // For quadra CFA, assign metada_bypass for first pass feature mask.
            // For second pass in quadra CFA mode, assign metadata_processing.
            // For normal reprocess(no quadra CFA), assign metadata_processing.
            if (!param.getQuadraCfa()) {
                if (pStream->isTypeOf(CAM_STREAM_TYPE_METADATA)) {
                    pp_featuremask.feature_mask = 0;
                    pp_featuremask.feature_mask |= CAM_QCOM_FEATURE_METADATA_PROCESSING;
                }
            } else {
                if (pStream->isTypeOf(CAM_STREAM_TYPE_METADATA)) {
                    // First reprocess pass in quadra CFA mode
                    // Skip processing of the offline metadata for first pass,
                    pp_featuremask.feature_mask = 0;
                    pp_featuremask.feature_mask |= CAM_QCOM_FEATURE_METADATA_BYPASS;
                } else if (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)) {
                    // Second reprocess pass in quadra CFA mode
                    // offline Metadata processing needed for second pass.
                    // offline meta data will be copied from backend.
                    pp_featuremask.feature_mask = 0;
                    pp_featuremask.feature_mask |= CAM_QCOM_FEATURE_METADATA_PROCESSING;
                }
            }

            pStreamInfoBuf = allocator.allocateStreamInfoBuf(CAM_STREAM_TYPE_OFFLINE_PROC);
            if (pStreamInfoBuf == NULL) {
                LOGE("no mem for stream info buf");
                rc = NO_MEMORY;
                break;
            }

            streamInfo = (cam_stream_info_t *)pStreamInfoBuf->getPtr(0);
            memset(streamInfo, 0, sizeof(cam_stream_info_t));
            streamInfo->stream_type = CAM_STREAM_TYPE_OFFLINE_PROC;
            // Enable CPP high performance mode to put it in turbo frequency mode for
            // burst/longshot/HDR snapshot cases
            streamInfo->perf_mode = CAM_PERF_HIGH_PERFORMANCE;
            if (param.getofflineRAW() && (pStream->isTypeOf(CAM_STREAM_TYPE_RAW)
                    || pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))) {
                if (pp_featuremask.feature_mask & CAM_QCOM_FEATURE_QUADRA_CFA) {
                    param.getStreamFormat(CAM_STREAM_TYPE_OFFLINE_PROC, streamInfo->fmt);
                } else {
                    streamInfo->fmt = CAM_FORMAT_YUV_420_NV21;
                }
            } else {
                rc = pStream->getFormat(streamInfo->fmt);
            }

            if (pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
                    pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
                    pStream->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
                    pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW)) {
                if (pp_featuremask.feature_mask & CAM_QCOM_FEATURE_SCALE) {
                    param.getThumbnailSize(&(streamInfo->dim.width),
                            &(streamInfo->dim.height));
                } else {
                    pStream->getFrameDimension(streamInfo->dim);
                }
            } else {
                if ((param.isPostProcScaling() || param.isDCmAsymmetricSnapMode()) &&
                        (pp_featuremask.feature_mask & CAM_QCOM_FEATURE_SCALE)) {
                    rc = param.getStreamDimension(CAM_STREAM_TYPE_OFFLINE_PROC,
                            streamInfo->dim);
                } else if ((param.getofflineRAW()) &&
                        ((pStream->isTypeOf(CAM_STREAM_TYPE_RAW)) ||
                        (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW)))) {
                         if ((param.getQuadraCfa()) &&
                             (pp_featuremask.feature_mask & CAM_QCOM_FEATURE_QUADRA_CFA)) {
                             rc = pStream->getFrameDimension(streamInfo->dim);
                         } else {
                             param.getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT,streamInfo->dim);
                         }
                } else {
                    rc = pStream->getFrameDimension(streamInfo->dim);
                }
            }

            if ( contStream ) {
                streamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
                streamInfo->num_of_burst = 0;
            } else {
                streamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
                streamInfo->num_of_burst = burstNum;
            }
            streamInfo->num_bufs = minStreamBufNum;
            streamInfo->buf_cnt = streamInfo->num_bufs;

            cam_stream_reproc_config_t rp_cfg;
            memset(&rp_cfg, 0, sizeof(cam_stream_reproc_config_t));
            if (offline) {
                cam_frame_len_offset_t offset;
                memset(&offset, 0, sizeof(cam_frame_len_offset_t));

                rp_cfg.pp_type = CAM_OFFLINE_REPROCESS_TYPE;
                pStream->getFormat(rp_cfg.offline.input_fmt);
                pStream->getFrameDimension(rp_cfg.offline.input_dim);
                pStream->getFrameOffset(offset);
                rp_cfg.offline.input_buf_planes.plane_info = offset;
                rp_cfg.offline.input_type = pStream->getMyOriginalType();
                //For input metadata + input buffer
                rp_cfg.offline.num_of_bufs = 2;
            } else {
                rp_cfg.pp_type = CAM_ONLINE_REPROCESS_TYPE;
                rp_cfg.online.input_stream_id = pStream->getMyServerID();
                rp_cfg.online.input_stream_type = pStream->getMyOriginalType();
            }
            param.getStreamRotation(streamInfo->stream_type,
                    streamInfo->pp_config, streamInfo->dim);
            streamInfo->reprocess_config = rp_cfg;
            streamInfo->reprocess_config.pp_feature_config = pp_featuremask;

            if (!(pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT)
                || pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)
                || pStream->isTypeOf(CAM_STREAM_TYPE_RAW)
                || pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))) {
                // CAC, SHARPNESS, FLIP and WNR would have been already applied -
                // on preview/postview stream in realtime. Need not apply again.
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_CAC;
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_SHARPNESS;
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_FLIP;
                //Don't do WNR for thumbnail
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_DENOISE2D;
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_CDS;
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_DSDN;
                //No need of RAW processing for other than RAW streams
                streamInfo->reprocess_config.pp_feature_config.feature_mask &=
                        ~CAM_QCOM_FEATURE_RAW_PROCESSING;

                if (param.isHDREnabled()
                  && !param.isHDRThumbnailProcessNeeded()){
                    streamInfo->reprocess_config.pp_feature_config.feature_mask
                      &= ~CAM_QCOM_FEATURE_HDR;
                }
            }

            cam_stream_type_t type = CAM_STREAM_TYPE_DEFAULT;
            if (offline) {
                type = streamInfo->reprocess_config.offline.input_type;
            } else {
                type = streamInfo->reprocess_config.online.input_stream_type;
            }
            if (type == CAM_STREAM_TYPE_SNAPSHOT) {
                int flipMode = param.getFlipMode(type);
                if (flipMode > 0) {
                    streamInfo->reprocess_config.pp_feature_config.feature_mask |=
                            CAM_QCOM_FEATURE_FLIP;
                    streamInfo->reprocess_config.pp_feature_config.flip = (uint32_t)flipMode;
                }
            }

            if ((streamInfo->reprocess_config.pp_feature_config.feature_mask
                    & CAM_QCOM_FEATURE_SCALE)
                    && param.isReprocScaleEnabled()
                    && param.isUnderReprocScaling()) {
                //we only Scale Snapshot frame
                if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
                    streamInfo->dim.width =
                            streamInfo->reprocess_config.pp_feature_config.scale_param.output_width;
                    streamInfo->dim.height =
                            streamInfo->reprocess_config.pp_feature_config.scale_param.output_height;
                }
                LOGH("stream width=%d, height=%d.",
                         streamInfo->dim.width, streamInfo->dim.height);
            }

            // save source stream handler
            if (mDualChannel) {
                mSrcStreamHandles[mStreams.size()] = pStream->getMyHandle();
            } else if (get_main_camera_handle(pStream->getMyHandle())) {
                mSrcStreamHandles[mStreams.size()] =
                        get_main_camera_handle(pStream->getMyHandle());
            } else if (get_aux_camera_handle(pStream->getMyHandle())) {
                mSrcStreamHandles[mStreams.size()] =
                        get_aux_camera_handle(pStream->getMyHandle());
            } else {
                LOGE("Invalid Handle. ");
                rc = BAD_VALUE;
                break;
            }

            mSrcStreamHandles[mStreams.size()] = pStream->getMyHandle();
            pMiscBuf = allocator.allocateMiscBuf(streamInfo);

            if (offline) {
                LOGH("Configure Reprocessing Input stream = %d Input: res = %dX%d,"
                        "fmt = %d, buf_cnt = %d",
                        streamInfo->reprocess_config.offline.input_type,
                        rp_cfg.offline.input_dim.width,
                        rp_cfg.offline.input_dim.height,
                        rp_cfg.offline.input_fmt, rp_cfg.offline.num_of_bufs);
            }

            LOGH("Configure Reprocessing Output: stream = %d, res = %dX%d, fmt = %d,"
                    "type = %d buf_cnt = %d",
                    pStream->getMyOriginalType(), streamInfo->dim.width,
                    streamInfo->dim.height, streamInfo->fmt, type, minStreamBufNum);

            // add reprocess stream
            if (streamInfo->reprocess_config.pp_feature_config.feature_mask
                    & CAM_QCOM_FEATURE_ROTATION) {
                rc = addStream(allocator, pStreamInfoBuf, pMiscBuf,
                        &padding, NULL, NULL, false, false,
                        streamInfo->reprocess_config.pp_feature_config.rotation,
                        pStream->getMyCamType());
            } else {
                rc = addStream(allocator, pStreamInfoBuf, pMiscBuf,
                        &padding, NULL, NULL, false, false, ROTATE_0,
                        pStream->getMyCamType());
            }
            if (rc != NO_ERROR) {
                LOGE("add reprocess stream failed, ret = %d", rc);
                break;
            }
        }
    }

    if (rc == NO_ERROR) {
        m_pSrcChannel = pSrcChannel;
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : getStreamBySrouceHandle
 *
 * DESCRIPTION: find reprocess stream by its source stream handle
 *
 * PARAMETERS :
 *   @srcHandle : source stream handle
 *
 * RETURN     : ptr to reprocess stream if found. NULL if not found
 *==========================================================================*/
QCameraStream * QCameraReprocessChannel::getStreamBySrouceHandle(uint32_t srcHandle)
{
    QCameraStream *pStream = NULL;

    for (size_t i = 0; i < mStreams.size(); i++) {
        if (validate_handle(mSrcStreamHandles[i], srcHandle)) {
            pStream = mStreams[i];
            break;
        }
    }

    return pStream;
}

/*===========================================================================
 * FUNCTION   : stop
 *
 * DESCRIPTION: stop channel and unmap offline buffers
 *
 * PARAMETERS : none
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::stop()
{
    int32_t rc = QCameraChannel::stop();

    if (!mOfflineBuffers.empty()) {
        QCameraStream *stream = NULL;
        List<OfflineBuffer>::iterator it = mOfflineBuffers.begin();
        int error = NO_ERROR;
        for( ; it != mOfflineBuffers.end(); it++) {
            stream = (*it).stream;
            if (NULL != stream) {
                error = stream->unmapBuf((*it).type,
                                         (*it).index,
                                         -1);
                if (NO_ERROR != error) {
                    LOGE("Error during offline buffer unmap %d",
                           error);
                }
            }
        }
        mOfflineBuffers.clear();
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : doReprocessOffline
 *
 * DESCRIPTION: request to do offline reprocess on the frame
 *
 * PARAMETERS :
 *   @frame   : frame to be performed a reprocess
 *   @meta_buf : Metadata buffer for reprocessing
 *   @pStream  : Actual reprocess stream
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::doReprocessOffline(mm_camera_buf_def_t *frame,
        mm_camera_buf_def_t *meta_buf, QCameraStream *pStream)
{
    int32_t rc = 0;
    OfflineBuffer mappedBuffer;
    uint32_t buf_index = 0;
    uint32_t meta_buf_index = 0;

    if ((frame == NULL) || (meta_buf == NULL)) {
        LOGE("Invalid Input Paramters");
        return INVALID_OPERATION;
    }

    if (pStream == NULL) {
        pStream = getStreamBySrouceHandle(frame->stream_id);
        if (pStream == NULL) {
            LOGE("Input validation failed.");
            return INVALID_OPERATION;
        }
    }

    if (!mOfflineBuffers.empty()) {
        List<OfflineBuffer>::iterator it = mOfflineBuffers.begin();
        for( ; it != mOfflineBuffers.end(); it++) {
            buf_index = (buf_index < ((*it).index)) ? ((*it).index) : buf_index;
        }
        buf_index += 1;
    }

    meta_buf_index = buf_index;
    if (meta_buf != NULL) {
        rc = pStream->mapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF,
                meta_buf_index,
                -1,
                meta_buf->fd,
                meta_buf->buffer,
                meta_buf->frame_len);
        if (NO_ERROR != rc ) {
            LOGE("Error during metadata buffer mapping");
            rc = -1;
            return rc;
        }

        mappedBuffer.index = meta_buf_index;
        mappedBuffer.stream = pStream;
        mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF;
        mOfflineBuffers.push_back(mappedBuffer);
        buf_index += 1;
    }

    rc = pStream->mapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
             buf_index,
             -1,
             frame->fd,
             frame->buffer,
             frame->frame_len);
    if (NO_ERROR != rc ) {
        LOGE("Error during reprocess input buffer mapping");
        rc = -1;
        return rc;
    }
    mappedBuffer.index = buf_index;
    mappedBuffer.stream = pStream;
    mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF;
    mOfflineBuffers.push_back(mappedBuffer);

    cam_stream_parm_buffer_t param;
    memset(&param, 0, sizeof(cam_stream_parm_buffer_t));

    param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
    param.reprocess.buf_index = buf_index;
    param.reprocess.frame_idx = frame->frame_idx;
    param.reprocess.is_uv_subsampled = frame->is_uv_subsampled;
    cam_stream_info_t *streamInfo =
            reinterpret_cast<cam_stream_info_t *>(pStream->getStreamInfoBuf()->getPtr(0));

    if ((pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)) && streamInfo &&
             (streamInfo->reprocess_config.pp_feature_config.feature_mask &
             CAM_QCOM_FEATURE_METADATA_BYPASS)) {
        LOGH("set meta bypass for quadra cfa first pass");
        // Backend will skip processing of metadata for first pass
        param.reprocess.is_offline_meta_bypass = 1;
    }
    if (meta_buf != NULL) {
        param.reprocess.meta_present = 1;
        param.reprocess.meta_buf_index = meta_buf_index;
    }

    LOGI("Offline reprocessing id = %d buf Id = %d meta index = %d type = %d",
             param.reprocess.frame_idx, param.reprocess.buf_index,
            param.reprocess.meta_buf_index, pStream->getMyOriginalType());

    rc = pStream->setParameter(param);
    if (rc != NO_ERROR) {
        LOGE("stream setParameter for reprocess failed");
        return rc;
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : doReprocessOffline
 *
 * DESCRIPTION: request to do offline reprocess on the frame
 *
 * PARAMETERS :
 *   @frame   : frame to be performed a reprocess
 *   @meta_buf : Metadata buffer for reprocessing
 *   @mParameter : camera parameters
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::doReprocessOffline(mm_camera_super_buf_t *frame,
        mm_camera_buf_def_t *meta_buf, QCameraParametersIntf &mParameter)
{
    int32_t rc = 0;
    QCameraStream *pStream = NULL;

    if (mStreams.size() < 1) {
        LOGE("No reprocess streams");
        return -1;
    }
    if (m_pSrcChannel == NULL) {
        LOGE("No source channel for reprocess");
        return -1;
    }

    if (frame == NULL) {
        LOGE("Invalid source frame");
        return BAD_VALUE;
    }

    for (uint32_t i = 0; i < frame->num_bufs; i++) {
        pStream = getStreamBySrouceHandle(frame->bufs[i]->stream_id);
        if ((pStream != NULL) &&
                (validate_handle(m_handle,pStream->getChannelHandle()))) {
            if (mParameter.getofflineRAW() &&
                    !((pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))
                    || (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)))) {
                continue;
            }

            if ((pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)
                     && ((mParameter.getManualCaptureMode()
                     < CAM_MANUAL_CAPTURE_TYPE_3) && (!mParameter.getQuadraCfa())))
                     || (pStream->isTypeOf(CAM_STREAM_TYPE_ANALYSIS))) {
                // Skip metadata for reprocess now because PP module cannot handle meta data
                // May need furthur discussion if Imaginglib need meta data
                // Do not skip metadata for manual capture or quadra CFA mode.
                continue;
            }

            // Update Metadata
            if (meta_buf != NULL) {
                uint32_t stream_id = frame->bufs[i]->stream_id;
                QCameraStream *srcStream =
                        m_pSrcChannel->getStreamByHandle(stream_id);
                metadata_buffer_t *pMetaData =
                        (metadata_buffer_t *)meta_buf->buffer;
                if ((NULL != pMetaData) && (NULL != srcStream)) {
                    IF_META_AVAILABLE(cam_crop_data_t, crop,
                            CAM_INTF_META_CROP_DATA, pMetaData) {
                        if (MAX_NUM_STREAMS > crop->num_of_streams) {
                            for (int j = 0; j < MAX_NUM_STREAMS; j++) {
                                if (crop->crop_info[j].stream_id ==
                                            srcStream->getMyServerID()) {
                                    // Store crop/roi information for offline reprocess
                                    // in the reprocess stream slot
                                    crop->crop_info[crop->num_of_streams].crop =
                                            crop->crop_info[j].crop;
                                    crop->crop_info[crop->num_of_streams].roi_map =
                                            crop->crop_info[j].roi_map;
                                    for (uint8_t k = 0; k < mStreams.size(); k++) {
                                        if (srcStream->getMyType() ==
                                                mStreams[k]->getMyOriginalType()) {
                                            crop->crop_info[crop->num_of_streams].stream_id =
                                                    mStreams[k]->getMyServerID();
                                            break;
                                        }
                                    }
                                    crop->num_of_streams++;
                                    break;
                                }
                            }
                        } else {
                            LOGE("No space to add reprocess stream crop/roi information");
                        }
                    }
                }
            } else {
                LOGE("Metadata NULL");
            }

            if (mParameter.getofflineRAW()) {
                //For offline RAW reprocessing, make sure cache is clean & invalidated
                frame->bufs[i]->cache_flags |= CPU_HAS_READ_WRITTEN;
            }
            //Do Cache ops before sending to reprocess
            if (frame->bufs[i] != NULL) {
                pStream->handleCacheOps(frame->bufs[i]);
            }
            rc = doReprocessOffline (frame->bufs[i], meta_buf, pStream);
        }
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : doReprocess
 *
 * DESCRIPTION: request to do a reprocess on the frame
 *
 * PARAMETERS :
 *   @frame   : frame to be performed a reprocess
 *   @mParameter : camera parameters
 *   @pMetaStream: Metadata stream handle
 *   @meta_buf_index : Metadata buffer index
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::doReprocess(mm_camera_super_buf_t *frame,
        QCameraParametersIntf &mParameter, QCameraStream *pMetaStream,
        uint8_t meta_buf_index)
{
    int32_t rc = 0;
    if (mStreams.size() < 1) {
        LOGE("No reprocess streams");
        return -1;
    }
    if (m_pSrcChannel == NULL) {
        LOGE("No source channel for reprocess");
        return -1;
    }

    if (pMetaStream == NULL) {
        LOGW("Null Metadata buffer for processing");
    }

    for (uint32_t i = 0; i < frame->num_bufs; i++) {
        QCameraStream *pStream = getStreamBySrouceHandle(frame->bufs[i]->stream_id);
        if ((pStream != NULL) &&
                (validate_handle(m_handle, pStream->getChannelHandle()))) {
            if (mParameter.getofflineRAW() && !((pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))
                    || (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW))
                    || (pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)))) {
                //Skip all the stream other than RAW and POSTVIEW incase of offline of RAW
                continue;
            }
            if ((pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)
                     && ((mParameter.getManualCaptureMode()
                     < CAM_MANUAL_CAPTURE_TYPE_3) && (!mParameter.getQuadraCfa())))
                     || (pStream->isTypeOf(CAM_STREAM_TYPE_ANALYSIS))) {
                // Skip metadata for reprocess now because PP module cannot handle meta data
                // May need furthur discussion if Imaginglib need meta data
                // Do not skip metadata for manual capture or quadra CFA mode.
                continue;
            }

            //Do Cache ops before sending to reprocess
            if (frame->bufs[i] != NULL) {
                pStream->handleCacheOps(frame->bufs[i]);
            }

            cam_stream_parm_buffer_t param;
            memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
            param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
            param.reprocess.buf_index = frame->bufs[i]->buf_idx;
            param.reprocess.frame_idx = frame->bufs[i]->frame_idx;
            param.reprocess.is_uv_subsampled = frame->bufs[i]->is_uv_subsampled;
            if (pMetaStream != NULL) {
                // we have meta data frame bundled, sent together with reprocess frame
                param.reprocess.meta_present = 1;
                param.reprocess.meta_stream_handle = pMetaStream->getMyServerID();
                param.reprocess.meta_buf_index = meta_buf_index;
            }

            LOGI("Online reprocessing id = %d buf Id = %d meta index = %d type = %d",
                     param.reprocess.frame_idx, param.reprocess.buf_index,
                    param.reprocess.meta_buf_index, pStream->getMyOriginalType());

            rc = pStream->setParameter(param);
            if (rc != NO_ERROR) {
                LOGE("stream setParameter for reprocess failed");
                break;
            }
        }
    }
    return rc;
}

/*===========================================================================
 * FUNCTION   : doReprocess
 *
 * DESCRIPTION: request to do a reprocess on the frame
 *
 * PARAMETERS :
 *   @buf_fd     : fd to the input buffer that needs reprocess
 *   @buffer     : buffer pointer of actual buffer
 *   @buf_lenght : length of the input buffer
 *   @ret_val    : result of reprocess.
 *                 Example: Could be faceID in case of register face image.
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraReprocessChannel::doReprocess(int buf_fd, void *buffer,
        size_t buf_length, int32_t &ret_val)
{
    int32_t rc = 0;
    if (mStreams.size() < 1) {
        LOGE("No reprocess streams");
        return -1;
    }

    uint32_t buf_idx = 0;
    for (size_t i = 0; i < mStreams.size(); i++) {
        if ((mStreams[i] != NULL) &&
                (validate_handle(m_handle, mStreams[i]->getChannelHandle()))) {
            continue;
        }
        rc = mStreams[i]->mapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
                                 buf_idx, -1,
                                 buf_fd, buffer, buf_length);

        if (rc == NO_ERROR) {
            cam_stream_parm_buffer_t param;
            memset(&param, 0, sizeof(cam_stream_parm_buffer_t));
            param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
            param.reprocess.buf_index = buf_idx;
            rc = mStreams[i]->setParameter(param);
            if (rc == NO_ERROR) {
                ret_val = param.reprocess.ret_val;
            }
            mStreams[i]->unmapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
                                  buf_idx, -1);
        }
    }
    return rc;
}

}; // namespace qcamera