/*
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "FakeCamHwIsp20.h"
#include "FakeSensorHw.h"
#include "Isp20PollThread.h"
#include "rk_isp20_hw.h"
#include "Isp20_module_dbg.h"
#include "mediactl/mediactl-priv.h"
#include <linux/v4l2-subdev.h>
#include <sys/mman.h>
#include <sys/stat.h>

namespace RkCam {
FakeCamHwIsp20::FakeCamHwIsp20()
{
    ENTER_CAMHW_FUNCTION();
    _rx_memory_type = V4L2_MEMORY_DMABUF;
    _tx_memory_type = V4L2_MEMORY_DMABUF;
    EXIT_CAMHW_FUNCTION();
}

FakeCamHwIsp20::~FakeCamHwIsp20()
{
    ENTER_CAMHW_FUNCTION();
    EXIT_CAMHW_FUNCTION();
}

XCamReturn
FakeCamHwIsp20::init(const char* sns_ent_name)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<Isp20PollThread> isp20Pollthread;
    SmartPtr<PollThread> isp20LumaPollthread;
    SmartPtr<PollThread> isp20IsppPollthread;
    SmartPtr<BaseSensorHw> sensorHw;
    SmartPtr<LensHw> lensHw;
    std::string sensor_name(sns_ent_name);

    ENTER_CAMHW_FUNCTION();


    std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
    if ((it = mSensorHwInfos.find(sensor_name)) == mSensorHwInfos.end()) {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM, "can't find sensor %s", sns_ent_name);
        return XCAM_RETURN_ERROR_SENSOR;
    }
    rk_sensor_full_info_t *s_info = it->second.ptr();
    sensorHw = new FakeSensorHw();
    mSensorDev = sensorHw;
    mSensorDev->open();
    strncpy(sns_name, sns_ent_name, sizeof(sns_name));

    if (s_info->linked_to_isp)
        _linked_to_isp = true;

    mIspCoreDev = new V4l2SubDevice(s_info->isp_info->isp_dev_path);
    mIspCoreDev->open();
    if (s_info->linked_to_isp)
        mIspCoreDev->subscribe_event(V4L2_EVENT_FRAME_SYNC);

    if (_linked_to_isp) {
        mIspLumaDev = new V4l2Device(s_info->isp_info->mipi_luma_path);
    } else
        mIspLumaDev = new V4l2Device(s_info->cif_info->mipi_luma_path);
    mIspLumaDev->open();

    _ispp_sd = new V4l2SubDevice(s_info->ispp_info->pp_dev_path);
    _ispp_sd ->open();
    LOGI_CAMHW_SUBM(FAKECAM_SUBM, "pp_dev_path: %s\n", s_info->ispp_info->pp_dev_path);

#ifndef DISABLE_PP_STATS
    mIsppStatsDev = new V4l2Device(s_info->ispp_info->pp_stats_path);
    mIsppStatsDev->open();
#endif
    mIsppParamsDev = new V4l2Device (s_info->ispp_info->pp_input_params_path);
    mIsppParamsDev->open();

    mIspStatsDev = new V4l2Device (s_info->isp_info->stats_path);
    mIspStatsDev->open();
    mIspParamsDev = new V4l2Device (s_info->isp_info->input_params_path);
    mIspParamsDev->open();

    if (!s_info->module_lens_dev_name.empty()) {
        lensHw = new LensHw(s_info->module_lens_dev_name.c_str());
        mLensDev = lensHw;
        mLensDev->open();
    }

    if(!s_info->module_ircut_dev_name.empty()) {
        mIrcutDev = new V4l2SubDevice(s_info->module_ircut_dev_name.c_str());
        mIrcutDev->open();
    }

    if (!_linked_to_isp) {
        if (strlen(s_info->cif_info->mipi_csi2_sd_path) > 0)
            _cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->mipi_csi2_sd_path);
        else if (strlen(s_info->cif_info->lvds_sd_path) > 0)
            _cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->lvds_sd_path);
        else
            LOGW_CAMHW_SUBM(FAKECAM_SUBM, "_cif_csi2_sd is null! \n");

        _cif_csi2_sd->open();
        _cif_csi2_sd->subscribe_event(V4L2_EVENT_FRAME_SYNC);
    }

    isp20Pollthread = new Isp20PollThread();
    isp20Pollthread->set_event_handle_dev(sensorHw);
    if(lensHw.ptr()) {
        isp20Pollthread->set_focus_handle_dev(lensHw);
        //isp20Pollthread->set_iris_handle_dev(lensHw);
    }

    mPollthread = isp20Pollthread;
    if (_linked_to_isp)
        mPollthread->set_event_device(mIspCoreDev);
    else
        mPollthread->set_event_device(_cif_csi2_sd);
    mPollthread->set_isp_stats_device(mIspStatsDev);
    mPollthread->set_isp_params_devices(mIspParamsDev, mIsppParamsDev);
    mPollthread->set_poll_callback (this);

    isp20LumaPollthread = new PollThread();
    mPollLumathread = isp20LumaPollthread;
    mPollLumathread->set_isp_luma_device(mIspLumaDev);
    mPollLumathread->set_poll_callback (this);

#ifndef DISABLE_PP
#ifndef DISABLE_PP_STATS
    isp20IsppPollthread = new PollThread();
    mPollIsppthread = isp20IsppPollthread;
    mPollIsppthread->set_ispp_stats_device(mIsppStatsDev);
    mPollIsppthread->set_poll_callback (this);
#endif
#endif

    if (s_info->flash_num) {
        mFlashLight = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
        mFlashLight->init(s_info->flash_num);
    }
    if (s_info->flash_ir_num) {
        mFlashLightIr = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
        mFlashLightIr->init(s_info->flash_ir_num);
    }

    xcam_mem_clear (_full_active_isp_params);
    xcam_mem_clear (_full_active_ispp_params);

    _state = CAM_HW_STATE_INITED;

    EXIT_CAMHW_FUNCTION();

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
FakeCamHwIsp20::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<Isp20PollThread> isp20Pollthread;
    SmartPtr<BaseSensorHw> sensorHw;

    ENTER_CAMHW_FUNCTION();

    XCAM_ASSERT (mCalibDb);

    _hdr_mode = mode;

    Isp20Params::set_working_mode(_hdr_mode);

    std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
    if ((it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM, "can't find sensor %s", sns_name);
        return XCAM_RETURN_ERROR_SENSOR;
    }

    rk_sensor_full_info_t *s_info = it->second.ptr();
    int isp_index = s_info->isp_info->model_idx;
    LOGI_CAMHW_SUBM(FAKECAM_SUBM, "sensor_name(%s) is linked to isp_index(%d)",
                    sns_name, isp_index);
    if (_linked_to_isp) {
        if (_hdr_mode != RK_AIQ_WORKING_MODE_NORMAL) {
            setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, true);
        } else {
            if (mNoReadBack)
                setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, false);
            else
                setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, true);
        }
    } else {
        setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, true);
        int cif_index = s_info->cif_info->model_idx;
        setupHdrLink_vidcap(_hdr_mode, cif_index, true);
    }

    sensorHw = mSensorDev.dynamic_cast_ptr<BaseSensorHw>();
    ret = sensorHw->set_working_mode(mode);
    if (ret) {
        LOGW_CAMHW_SUBM(FAKECAM_SUBM, "set sensor mode error !");
        return ret;
    }

    setExpDelayInfo(mode);
    setLensVcmCfg();
    init_mipi_devices(s_info);

    isp20Pollthread = mPollthread.dynamic_cast_ptr<Isp20PollThread>();
    isp20Pollthread->set_working_mode(mode, _linked_to_isp, false);
    isp20Pollthread->setCamHw(this);
    isp20Pollthread->set_mipi_devs(_mipi_tx_devs, _mipi_rx_devs, mIspCoreDev);

    SmartPtr<FakeSensorHw> fakeSensorHw = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
    fakeSensorHw->set_mipi_tx_devs(_mipi_tx_devs);

    _ispp_module_init_ens = 0;

    ret = setupPipelineFmt();
    if (ret < 0) {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM, "setupPipelineFmt err: %d\n", ret);
    }

    if (!_linked_to_isp)
        prepare_cif_mipi();

    isp20Pollthread->set_event_handle_dev(sensorHw);

    _state = CAM_HW_STATE_PREPARED;
    EXIT_CAMHW_FUNCTION();
    return ret;
}

XCamReturn
FakeCamHwIsp20::init_mipi_devices(rk_sensor_full_info_t *s_info)
{
    /*
     * for _mipi_tx_devs, index 0 refer to short frame always, inedex 1 refer
     * to middle frame always, index 2 refert to long frame always.
     * for CIF usecase, because mipi_id0 refert to long frame always, so we
     * should know the HDR mode firstly befor building the relationship between
     * _mipi_tx_devs array and mipi_idx. here we just set the mipi_idx to
     * _mipi_tx_devs, we will build the real relation in start.
     * for CIF usecase, rawwr2_path is always connected to _mipi_tx_devs[0],
     * rawwr0_path is always connected to _mipi_tx_devs[1], and rawwr1_path is always
     * connected to _mipi_tx_devs[0]
     */
    //short frame
    _mipi_tx_devs[0] = new FakeV4l2Device ();
    _mipi_tx_devs[0]->open();
    _mipi_tx_devs[0]->set_mem_type(_tx_memory_type);
    _mipi_tx_devs[0]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

    _mipi_rx_devs[0] = new V4l2Device (s_info->isp_info->rawrd2_s_path);//rkisp_rawrd2_s
    _mipi_rx_devs[0]->open();
    _mipi_rx_devs[0]->set_mem_type(_rx_memory_type);
    //mid frame
    _mipi_tx_devs[1] = new FakeV4l2Device ();
    _mipi_tx_devs[1]->open();
    _mipi_tx_devs[1]->set_mem_type(_tx_memory_type);
    _mipi_tx_devs[1]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

    _mipi_rx_devs[1] = new V4l2Device (s_info->isp_info->rawrd0_m_path);//rkisp_rawrd0_m
    _mipi_rx_devs[1]->open();
    _mipi_rx_devs[1]->set_mem_type(_rx_memory_type);
    //long frame
    _mipi_tx_devs[2] = new FakeV4l2Device ();
    _mipi_tx_devs[2]->open();
    _mipi_tx_devs[2]->set_mem_type(_tx_memory_type);
    _mipi_tx_devs[2]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

    _mipi_rx_devs[2] = new V4l2Device (s_info->isp_info->rawrd1_l_path);//rkisp_rawrd1_l
    _mipi_rx_devs[2]->open();
    _mipi_rx_devs[2]->set_mem_type(_rx_memory_type);
    for (int i = 0; i < 3; i++) {
        if (_linked_to_isp) {
            if (_rawbuf_type == RK_AIQ_RAW_FILE) {
                _mipi_tx_devs[0]->set_use_type(2);
                _mipi_tx_devs[i]->set_buffer_count(1);
                _mipi_rx_devs[i]->set_buffer_count(1);
            } else if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
                 _mipi_tx_devs[0]->set_use_type(1);
                _mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
                _mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
            } else {
                _mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
                _mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
            }
        } else {
            _mipi_tx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
            _mipi_rx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
        }
        _mipi_tx_devs[i]->set_buf_sync (true);
        _mipi_rx_devs[i]->set_buf_sync (true);
    }
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
FakeCamHwIsp20::enqueueRawBuffer(void *rawdata, bool sync)
{
    ENTER_XCORE_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    struct rk_aiq_vbuf vbuf;
    memset(&vbuf, 0, sizeof(vbuf));
    parse_rk_rawdata(rawdata, &vbuf);
    SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
    fakeSensor->enqueue_rawbuffer(&vbuf, sync);
    EXIT_XCORE_FUNCTION();
    return ret;
}

XCamReturn
FakeCamHwIsp20::enqueueRawFile(const char *path)
{
    ENTER_XCORE_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    struct rk_aiq_vbuf vbuf;
    memset(&vbuf, 0, sizeof(vbuf));
    if (0 != access(path, F_OK)) {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM, "file: %s is not exist!", path);
        return XCAM_RETURN_ERROR_PARAM;
    }

    FILE *fp = fopen(path, "rb");
    if (!fp) {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM, "open file: %s failed", path);
        return XCAM_RETURN_ERROR_FAILED;
    }

    parse_rk_rawfile(fp, &vbuf);
    fclose(fp);
    SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
    fakeSensor->enqueue_rawbuffer(&vbuf, true);
    EXIT_XCORE_FUNCTION();
    return ret;
}

void
FakeCamHwIsp20::parse_rk_rawdata(void *rawdata, struct rk_aiq_vbuf *vbuf)
{
    unsigned short tag = 0;
    struct _block_header header;
    uint8_t *p = (uint8_t *)rawdata;
    uint8_t *actual_raw[3];
    int actual_raw_len[3];
    bool is_actual_rawdata = false;
    bool bExit = false;
    while(!bExit){
        tag = *((unsigned short*)p);
        LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
        switch (tag)
        {
        	case START_TAG:
            	p = p+TAG_BYTE_LEN;
            	memset(_st_addr, 0, sizeof(_st_addr));
            	memset(&_rawfmt, 0, sizeof(_rawfmt));
            	memset(&_finfo, 0, sizeof(_finfo));
            	break;
        	case NORMAL_RAW_TAG:
        	{
                header = *((struct _block_header *)p);
                p = p + sizeof(struct _block_header);
                if (header.block_length == sizeof(struct _st_addrinfo)) {
                    _st_addr[0] = *((struct _st_addrinfo*)p);
                }else{
                    //actual raw data
                    is_actual_rawdata = true;
                    actual_raw[0] = p;
                    actual_raw_len[0] = header.block_length;
                }
                p = p + header.block_length;

            	break;
        	}
        	case HDR_S_RAW_TAG:
        	{
                header = *((struct _block_header *)p);
                p = p + sizeof(struct _block_header);
                if (header.block_length == sizeof(struct _st_addrinfo)) {
                    _st_addr[0] = *((struct _st_addrinfo*)p);
                }else{
                    //actual raw data
                    is_actual_rawdata = true;
                    actual_raw[0] = p;
                    actual_raw_len[0] = header.block_length;
                }
                p = p + header.block_length;
        	    break;
        	}
        	case HDR_M_RAW_TAG:
        	{
                header = *((struct _block_header *)p);
                p = p + sizeof(struct _block_header);
                if (header.block_length == sizeof(struct _st_addrinfo)) {
                    _st_addr[1] = *((struct _st_addrinfo*)p);
                }else{
                    //actual raw data
                    is_actual_rawdata = true;
                    actual_raw[1] = p;
                    actual_raw_len[1] = header.block_length;
                }
                p = p + header.block_length;
            	break;
        	}
        	case HDR_L_RAW_TAG:
        	{
                header = *((struct _block_header *)p);
                p = p + sizeof(struct _block_header);
                if (header.block_length == sizeof(struct _st_addrinfo)) {
                    _st_addr[2] = *((struct _st_addrinfo*)p);
                }else{
                    //actual raw data
                    is_actual_rawdata = true;
                    actual_raw[2] = p;
                    actual_raw_len[2] = header.block_length;
                }
                p = p + header.block_length;
            	break;
        	}
        	case FORMAT_TAG:
        	{
            	_rawfmt = *((struct _raw_format *)p);
            	LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
            	p = p + sizeof(struct _block_header) + _rawfmt.size;
            	break;
        	}
        	case STATS_TAG:
        	{
            	_finfo = *((struct _frame_info *)p);
            	p = p + sizeof(struct _block_header) + _finfo.size;
            	break;
        	}
        	case ISP_REG_FMT_TAG:
        	{
        	    header = *((struct _block_header *)p);
        	    p += sizeof(struct _block_header);
        	    p = p + header.block_length;
        	    break;
        	}
        	case ISP_REG_TAG:
        	{
        	    header = *((struct _block_header *)p);
        	    p += sizeof(struct _block_header);
        	    p = p + header.block_length;
        	    break;
        	}
        	case ISPP_REG_FMT_TAG:
        	{
        	    header = *((struct _block_header *)p);
        	    p += sizeof(struct _block_header);
        	    p = p + header.block_length;
        	    break;
        	}
        	case ISPP_REG_TAG:
        	{
        	    header = *((struct _block_header *)p);
        	    p += sizeof(struct _block_header);
        	    p = p + header.block_length;
        	    break;
        	}
        	case PLATFORM_TAG:
        	{
            	header = *((struct _block_header *)p);
        	    p += sizeof(struct _block_header);
        	    p = p + header.block_length;
        	    break;
        	}
        	case END_TAG:
        	{
                bExit = true;
            	break;
            }
            default:
            {
            	LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
            	bExit = true;
            	break;
        	}
        }
    }

     vbuf->frame_width = _rawfmt.width;
     vbuf->frame_height = _rawfmt.height;
     vbuf->base_addr = rawdata;
     if (_rawfmt.hdr_mode == 1) {
         if (is_actual_rawdata) {
            vbuf->buf_info[0].data_addr = actual_raw[0];
            vbuf->buf_info[0].data_fd = 0;
            vbuf->buf_info[0].data_length = actual_raw_len[0];
         }else{
			 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
                 if (sizeof(uint8_t*) == 4)
                    vbuf->buf_info[0].data_addr = (uint8_t*)(_st_addr[0].laddr);
                 else if (sizeof(uint8_t*) == 8)
                    vbuf->buf_info[0].data_addr = (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);

                vbuf->buf_info[0].data_fd = 0;
			 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                 vbuf->buf_info[0].data_fd = _st_addr[0].fd;
				 vbuf->buf_info[0].data_addr = NULL;
			 }
             vbuf->buf_info[0].data_length = _st_addr[0].size;
         }
          LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
                                       vbuf->buf_info[0].data_addr,
                                       vbuf->buf_info[0].data_fd,
                                       vbuf->buf_info[0].data_length);

         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.normal_gain_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.normal_exp_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:0x%x,time:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);
    }else if (_rawfmt.hdr_mode == 2) {
         if (is_actual_rawdata) {
            vbuf->buf_info[0].data_addr = actual_raw[0];
            vbuf->buf_info[0].data_fd = 0;
            vbuf->buf_info[0].data_length = actual_raw_len[0];
         } else {
            if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
             if (sizeof(uint8_t*) == 4)
                vbuf->buf_info[0].data_addr = (uint8_t*)(_st_addr[0].laddr);
             else if (sizeof(uint8_t*) == 8)
                vbuf->buf_info[0].data_addr = (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
                vbuf->buf_info[0].data_fd = 0;
             } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                vbuf->buf_info[0].data_addr = NULL;
                vbuf->buf_info[0].data_fd = _st_addr[0].fd;
             }
             vbuf->buf_info[0].data_length = _st_addr[0].size;
         }
         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.hdr_gain_s_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.hdr_exp_s_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[0]=%p,fd[0]=%d,,length=%d\n",
                                      vbuf->buf_info[0].data_addr,
                                      vbuf->buf_info[0].data_fd,
                                      vbuf->buf_info[0].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[0]:0x%x,time[0]:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);
         if (is_actual_rawdata) {
            vbuf->buf_info[1].data_addr = actual_raw[2];//actual_raw[1]
            vbuf->buf_info[1].data_fd = 0;
            vbuf->buf_info[1].data_length = actual_raw_len[2];//actual_raw_len[1]
         } else {
             if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
                 if (sizeof(uint8_t*) == 4)
                    vbuf->buf_info[1].data_addr = (uint8_t*)(_st_addr[1].laddr);
                 else if (sizeof(uint8_t*) == 8)
                    vbuf->buf_info[1].data_addr = (uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
                 vbuf->buf_info[1].data_fd = 0;
              } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                vbuf->buf_info[1].data_addr = NULL;
                vbuf->buf_info[1].data_fd = _st_addr[1].fd;
              }
              vbuf->buf_info[1].data_length = _st_addr[1].size;
         }
         vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[1].exp_gain = (uint32_t)_finfo.hdr_gain_m_reg;
         vbuf->buf_info[1].exp_time = (uint32_t)_finfo.hdr_exp_m_reg;
         vbuf->buf_info[1].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[1]=%p,fd[1]=%d,,length=%d\n",
                                      vbuf->buf_info[1].data_addr,
                                      vbuf->buf_info[1].data_fd,
                                      vbuf->buf_info[1].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[1]:0x%x,time[1]:0x%x\n",
                                      vbuf->buf_info[1].exp_gain,
                                      vbuf->buf_info[1].exp_time);
    }else if (_rawfmt.hdr_mode == 3) {
         if (is_actual_rawdata) {
            vbuf->buf_info[0].data_addr = actual_raw[0];
            vbuf->buf_info[0].data_fd = 0;
            vbuf->buf_info[0].data_length = actual_raw_len[0];
         } else {
            if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
             if (sizeof(uint8_t*) == 4)
                vbuf->buf_info[0].data_addr = (uint8_t*)(_st_addr[0].laddr);
             else if (sizeof(uint8_t*) == 8)
                vbuf->buf_info[0].data_addr = (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
                vbuf->buf_info[0].data_fd = 0;
             } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                vbuf->buf_info[0].data_addr = NULL;
                vbuf->buf_info[0].data_fd = _st_addr[0].fd;
             }
             vbuf->buf_info[0].data_length = _st_addr[0].size;
         }
         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.hdr_gain_s_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.hdr_exp_s_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[0]=%p,fd[0]=%d,,length=%d\n",
                                      vbuf->buf_info[0].data_addr,
                                      vbuf->buf_info[0].data_fd,
                                      vbuf->buf_info[0].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[0]:0x%x,time[0]:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);

         if (is_actual_rawdata) {
            vbuf->buf_info[1].data_addr = actual_raw[1];
            vbuf->buf_info[1].data_fd = 0;
            vbuf->buf_info[1].data_length = actual_raw_len[1];
         } else {
             if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
                 if (sizeof(uint8_t*) == 4)
                    vbuf->buf_info[1].data_addr = (uint8_t*)(_st_addr[1].laddr);
                 else if (sizeof(uint8_t*) == 8)
                    vbuf->buf_info[1].data_addr = (uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
                 vbuf->buf_info[1].data_fd = 0;
              } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                vbuf->buf_info[1].data_addr = NULL;
                vbuf->buf_info[1].data_fd = _st_addr[1].fd;
              }
              vbuf->buf_info[1].data_length = _st_addr[1].size;
         }
         vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[1].exp_gain = (uint32_t)_finfo.hdr_gain_m_reg;
         vbuf->buf_info[1].exp_time = (uint32_t)_finfo.hdr_exp_m_reg;
         vbuf->buf_info[1].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[1]=%p,fd[1]=%d,,length=%d\n",
                                      vbuf->buf_info[1].data_addr,
                                      vbuf->buf_info[1].data_fd,
                                      vbuf->buf_info[1].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[1]:0x%x,time[1]:0x%x\n",
                                      vbuf->buf_info[1].exp_gain,
                                      vbuf->buf_info[1].exp_time);

         if (is_actual_rawdata) {
            vbuf->buf_info[2].data_addr = actual_raw[2];
            vbuf->buf_info[2].data_fd = 0;
            vbuf->buf_info[2].data_length = actual_raw_len[2];
         }else{
             if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
                 if (sizeof(uint8_t*) == 4)
                    vbuf->buf_info[2].data_addr = (uint8_t*)(_st_addr[2].laddr);
                 else if (sizeof(uint8_t*) == 8)
                    vbuf->buf_info[2].data_addr = (uint8_t*)(((uint64_t)_st_addr[2].haddr << 32) + _st_addr[2].laddr);
                 vbuf->buf_info[2].data_fd = 0;
             } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
                    vbuf->buf_info[2].data_addr = NULL;
                    vbuf->buf_info[2].data_fd = _st_addr[2].fd;
             }
             vbuf->buf_info[2].data_length = _st_addr[2].size;
         }
         vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[2].exp_gain = (uint32_t)_finfo.hdr_gain_l_reg;
         vbuf->buf_info[2].exp_time = (uint32_t)_finfo.hdr_exp_l_reg;
         vbuf->buf_info[2].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[2]=%p,fd[2]=%d,,length=%d\n",
                                      vbuf->buf_info[2].data_addr,
                                      vbuf->buf_info[2].data_fd,
                                      vbuf->buf_info[2].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[2]:0x%x,time[2]:0x%x\n",
                                      vbuf->buf_info[2].exp_gain,
                                      vbuf->buf_info[2].exp_time);
    }

}

void
FakeCamHwIsp20::parse_rk_rawfile(FILE *fp, struct rk_aiq_vbuf *vbuf)
{
    unsigned short tag = 0;
    struct _block_header header;
    bool bExit = false;
    while(!bExit){
        fread(&tag, sizeof(tag), 1, fp);
        fseek(fp, TAG_BYTE_LEN*(-1), SEEK_CUR);//backforwad to tag start
        LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
        switch (tag)
        {
        	case START_TAG:
            	fseek(fp, TAG_BYTE_LEN, SEEK_CUR);
            	memset(_st_addr, 0, sizeof(_st_addr));
            	memset(&_rawfmt, 0, sizeof(_rawfmt));
            	memset(&_finfo, 0, sizeof(_finfo));
            	break;
        	case NORMAL_RAW_TAG:
        	{
                fread(&header, sizeof(header), 1, fp);
                if (header.block_length > 0) {
                    vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
                    fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
                    vbuf->buf_info[0].data_length = header.block_length;
                }
            	break;
        	}
        	case HDR_S_RAW_TAG:
        	{
                fread(&header, sizeof(header), 1, fp);
                if (header.block_length > 0) {
                    vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
                    fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
                    vbuf->buf_info[0].data_length = header.block_length;
                }
        	    break;
        	}
        	case HDR_M_RAW_TAG:
        	{
                fread(&header, sizeof(header), 1, fp);
                if (header.block_length > 0) {
                    vbuf->buf_info[1].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
                    fread(vbuf->buf_info[1].data_addr, header.block_length, 1, fp);
                    vbuf->buf_info[1].data_length = header.block_length;
                }
            	break;
        	}
        	case HDR_L_RAW_TAG:
        	{
                fread(&header, sizeof(header), 1, fp);
                if (header.block_length > 0) {
                    vbuf->buf_info[1].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
                    fread(vbuf->buf_info[1].data_addr, header.block_length, 1, fp);
                    vbuf->buf_info[1].data_length = header.block_length;
                }
            	break;
        	}
        	case FORMAT_TAG:
        	{
            	fread(&_rawfmt, sizeof(_rawfmt), 1, fp);
            	LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
            	break;
        	}
        	case STATS_TAG:
        	{
            	fread(&_finfo, sizeof(_finfo), 1, fp);
            	break;
        	}
        	case ISP_REG_FMT_TAG:
        	{
        	    fread(&header, sizeof(header), 1, fp);
        	    fseek(fp, header.block_length, SEEK_CUR);
        	    break;
        	}
        	case ISP_REG_TAG:
        	{
        	    fread(&header, sizeof(header), 1, fp);
        	    fseek(fp, header.block_length, SEEK_CUR);
        	    break;
        	}
        	case ISPP_REG_FMT_TAG:
        	{
        	    fread(&header, sizeof(header), 1, fp);
        	    fseek(fp, header.block_length, SEEK_CUR);
        	    break;
        	}
        	case ISPP_REG_TAG:
        	{
        	    fread(&header, sizeof(header), 1, fp);
        	    fseek(fp, header.block_length, SEEK_CUR);
        	    break;
        	}
        	case PLATFORM_TAG:
        	{
            	fread(&header, sizeof(header), 1, fp);
        	    fseek(fp, header.block_length, SEEK_CUR);
        	    break;
        	}
        	case END_TAG:
        	{
                bExit = true;
            	break;
            }
            default:
            {
            	LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
            	bExit = true;
            	break;
        	}
        }
    }

     vbuf->frame_width = _rawfmt.width;
     vbuf->frame_height = _rawfmt.height;
     if (_rawfmt.hdr_mode == 1) {
          LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
                                       vbuf->buf_info[0].data_addr,
                                       vbuf->buf_info[0].data_fd,
                                       vbuf->buf_info[0].data_length);

         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.normal_gain_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.normal_exp_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:0x%x,time:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);
    }else if (_rawfmt.hdr_mode == 2) {
         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.hdr_gain_s_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.hdr_exp_s_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[0]=%p,fd[0]=%d,,length=%d\n",
                                      vbuf->buf_info[0].data_addr,
                                      vbuf->buf_info[0].data_fd,
                                      vbuf->buf_info[0].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[0]:0x%x,time[0]:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);

         vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[1].exp_gain = (uint32_t)_finfo.hdr_gain_l_reg;
         vbuf->buf_info[1].exp_time = (uint32_t)_finfo.hdr_exp_l_reg;
         vbuf->buf_info[1].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[1]=%p,fd[1]=%d,,length=%d\n",
                                      vbuf->buf_info[1].data_addr,
                                      vbuf->buf_info[1].data_fd,
                                      vbuf->buf_info[1].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[1]:0x%x,time[1]:0x%x\n",
                                      vbuf->buf_info[1].exp_gain,
                                      vbuf->buf_info[1].exp_time);
    }else if (_rawfmt.hdr_mode == 3) {
         vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[0].exp_gain = (uint32_t)_finfo.hdr_gain_s_reg;
         vbuf->buf_info[0].exp_time = (uint32_t)_finfo.hdr_exp_s_reg;
         vbuf->buf_info[0].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[0]=%p,fd[0]=%d,,length=%d\n",
                                      vbuf->buf_info[0].data_addr,
                                      vbuf->buf_info[0].data_fd,
                                      vbuf->buf_info[0].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[0]:0x%x,time[0]:0x%x\n",
                                      vbuf->buf_info[0].exp_gain,
                                      vbuf->buf_info[0].exp_time);

         vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[1].exp_gain = (uint32_t)_finfo.hdr_gain_m_reg;
         vbuf->buf_info[1].exp_time = (uint32_t)_finfo.hdr_exp_m_reg;
         vbuf->buf_info[1].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[1]=%p,fd[1]=%d,,length=%d\n",
                                      vbuf->buf_info[1].data_addr,
                                      vbuf->buf_info[1].data_fd,
                                      vbuf->buf_info[1].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[1]:0x%x,time[1]:0x%x\n",
                                      vbuf->buf_info[1].exp_gain,
                                      vbuf->buf_info[1].exp_time);

         vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
         vbuf->buf_info[2].exp_gain = (uint32_t)_finfo.hdr_gain_l_reg;
         vbuf->buf_info[2].exp_time = (uint32_t)_finfo.hdr_exp_l_reg;
         vbuf->buf_info[2].valid = true;
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr[2]=%p,fd[2]=%d,,length=%d\n",
                                      vbuf->buf_info[2].data_addr,
                                      vbuf->buf_info[2].data_fd,
                                      vbuf->buf_info[2].data_length);
         LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain[2]:0x%x,time[2]:0x%x\n",
                                      vbuf->buf_info[2].exp_gain,
                                      vbuf->buf_info[2].exp_time);
    }

}

XCamReturn
FakeCamHwIsp20::registRawdataCb(void (*callback)(void *))
{
    ENTER_XCORE_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
    ret = fakeSensor->register_rawdata_callback(callback);
    EXIT_XCORE_FUNCTION();
    return ret;
}

XCamReturn
FakeCamHwIsp20::rawdataPrepare(rk_aiq_raw_prop_t prop)
{
    ENTER_XCORE_FUNCTION();
    XCamReturn ret = XCAM_RETURN_NO_ERROR;


    _rawbuf_type = prop.rawbuf_type;
    if (_rawbuf_type == RK_AIQ_RAW_ADDR)
    {
        _rx_memory_type = V4L2_MEMORY_USERPTR;
        _tx_memory_type = V4L2_MEMORY_USERPTR;
    }
    else if (_rawbuf_type == RK_AIQ_RAW_FD)
    {
        _rx_memory_type = V4L2_MEMORY_DMABUF;
        _tx_memory_type = V4L2_MEMORY_DMABUF;
    }
    else if(_rawbuf_type == RK_AIQ_RAW_DATA)
    {
        _rx_memory_type = V4L2_MEMORY_MMAP;
        _tx_memory_type = V4L2_MEMORY_USERPTR;
    }
    else if(_rawbuf_type == RK_AIQ_RAW_FILE)
    {
        _rx_memory_type = V4L2_MEMORY_MMAP;
        _tx_memory_type = V4L2_MEMORY_USERPTR;
    }
    else {
        LOGE_CAMHW_SUBM(FAKECAM_SUBM,"Not support raw data type:%d", _rawbuf_type);
        return XCAM_RETURN_ERROR_PARAM;
    }
    SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
    ret = fakeSensor->prepare(prop);
    EXIT_XCORE_FUNCTION();
    return ret;
}
}; //namspace RkCam