enum ia_css_err
sh_css_fill_binary_info(const struct ia_css_binary_info *info,
		 bool online,
		 bool two_ppc,
		 enum ia_css_stream_format stream_format,
		 const struct ia_css_frame_info *in_info, /* can be NULL */
		 const struct ia_css_frame_info *out_info, /* can be NULL */
		 const struct ia_css_frame_info *vf_info, /* can be NULL */
		 struct sh_css_binary *binary,
		 bool continuous,
		 struct ia_css_resolution *dvs_env)
{
	unsigned int dvs_env_width = 0,
		     dvs_env_height = 0,
		     vf_log_ds = 0,
		     s3a_log_deci = 0,
		     bits_per_pixel = 0,
		     ds_input_width = 0,
		     ds_input_height = 0,
		     isp_input_width,
		     isp_input_height,
		     isp_internal_width,
		     isp_internal_height,
		     isp_output_width = 0,
		     isp_output_height = 0,
		     s3a_isp_width;
	unsigned char enable_ds = info->enable.ds;
	bool enable_yuv_ds = enable_ds & 2;
	bool enable_hus = false;
	bool enable_vus = false;
	bool is_out_format_rgba888 = false;
	unsigned int tmp_width, tmp_height;

	assert(info != NULL);
	assert(binary != NULL);

	if (in_info != NULL) {
		bits_per_pixel = in_info->raw_bit_depth;
		if (out_info != NULL) {
			enable_hus = in_info->res.width < out_info->res.width;
			enable_vus = in_info->res.height < out_info->res.height;
		}
	}
	if (out_info != NULL) {
		isp_output_width  = out_info->padded_width;
		isp_output_height = out_info->res.height;
		is_out_format_rgba888 =
			out_info->format == IA_CSS_FRAME_FORMAT_RGBA888;
	}
	if (info->enable.dvs_envelope) {
		assert(dvs_env != NULL);
		dvs_env_width  = max(dvs_env->width, SH_CSS_MIN_DVS_ENVELOPE);
		dvs_env_height = max(dvs_env->height, SH_CSS_MIN_DVS_ENVELOPE);
	}
	binary->dvs_envelope.width  = dvs_env_width;
	binary->dvs_envelope.height = dvs_env_height;
	if (vf_info != NULL) {
		enum ia_css_err err;
		err = sh_css_vf_downscale_log2(out_info, vf_info, &vf_log_ds);
		if (err != IA_CSS_SUCCESS)
			return err;
		vf_log_ds = min(vf_log_ds, info->max_vf_log_downscale);
	}
	if (online) {
		bits_per_pixel = sh_css_input_format_bits_per_pixel(
			stream_format, two_ppc);
	}
	if (in_info != NULL) {
		ds_input_width  = in_info->padded_width + info->left_cropping;
		ds_input_height = in_info->res.height + info->top_cropping;
	}
	if (enable_hus) /* { */
		ds_input_width  += dvs_env_width;
	/* } */
	if (enable_vus) /* { */
		ds_input_height += dvs_env_height;
	/* } */
	tmp_width  = (enable_yuv_ds && (ds_input_width > isp_output_width)) ?
			ds_input_width  : isp_output_width;
	tmp_height = (enable_yuv_ds && (ds_input_height > isp_output_height)) ?
			ds_input_height : isp_output_height;

	/* We first calculate the resolutions used by the ISP. After that,
	 * we use those resolutions to compute sizes for tables etc. */
	isp_internal_width = __ISP_INTERNAL_WIDTH(tmp_width,
		(int)dvs_env_width, /* the typecast here is added to avoid a signed/unsigned warning in visual studio */
		info->left_cropping, info->mode,
		info->c_subsampling,
		info->output_num_chunks, info->pipelining,
		is_out_format_rgba888);
	isp_internal_height = __ISP_INTERNAL_HEIGHT(tmp_height,
		info->top_cropping,
		dvs_env_height);
	isp_input_width = _ISP_INPUT_WIDTH(isp_internal_width,
		ds_input_width,
		enable_ds || enable_hus);
	isp_input_height = _ISP_INPUT_HEIGHT(isp_internal_height,
		ds_input_height,
		enable_ds || enable_vus);
	s3a_isp_width = _ISP_S3A_ELEMS_ISP_WIDTH(isp_input_width,
		isp_internal_width, enable_hus || enable_yuv_ds,
		info->left_cropping);
	if (info->fixed_s3a_deci_log) {
/* */
		s3a_log_deci = info->fixed_s3a_deci_log;
	}
	else {
/* */
		s3a_log_deci = sh_css_grid_deci_factor_log2(s3a_isp_width,
							    isp_input_height);
	}

	binary->vf_downscale_log2 = vf_log_ds;
	binary->deci_factor_log2  = s3a_log_deci;
	binary->input_buf_vectors =
			SH_CSS_NUM_INPUT_BUF_LINES * _ISP_VECS(isp_input_width);
	binary->online            = online;
	binary->input_format      = stream_format;
	/* input info */
	if (in_info != NULL) {
		binary->in_frame_info.format = in_info->format;
		binary->in_frame_info.res.width = in_info->res.width +
			info->left_cropping + dvs_env_width;
	}
	binary->in_frame_info.padded_width  = isp_input_width;
	binary->in_frame_info.res.height    = isp_input_height;
	binary->in_frame_info.raw_bit_depth = bits_per_pixel;
	/* internal frame info */
	if (out_info != NULL) /* { */
		binary->internal_frame_info.format          = out_info->format;
	/* } */
	binary->internal_frame_info.res.width       = isp_internal_width;
	binary->internal_frame_info.padded_width    = isp_internal_width;
	binary->internal_frame_info.res.height      = isp_internal_height;
	binary->internal_frame_info.raw_bit_depth   = bits_per_pixel;
	/* output info */
	if (out_info != NULL) {
		binary->out_frame_info.format        = out_info->format;
		binary->out_frame_info.res.width     = out_info->res.width;
	}
	binary->out_frame_info.padded_width  = isp_output_width;
	binary->out_frame_info.res.height    = isp_output_height;
	binary->out_frame_info.raw_bit_depth = bits_per_pixel;

	/* viewfinder output info */
	binary->vf_frame_info.format = IA_CSS_FRAME_FORMAT_YUV_LINE;
	if (vf_info != NULL) {
		unsigned int vf_out_vecs, vf_out_width, vf_out_height;
		vf_out_vecs = __ISP_VF_OUTPUT_WIDTH_VECS(isp_output_width,
			vf_log_ds);
		vf_out_width = _ISP_VF_OUTPUT_WIDTH(vf_out_vecs);
		vf_out_height = _ISP_VF_OUTPUT_HEIGHT(isp_output_height,
			vf_log_ds);
		/* If we are in continuous preview mode, then out port is
		 * active instead of vfout port
		 */
		if (info->enable.raw_binning && continuous) {
			if (in_info == NULL)
				return IA_CSS_ERR_INTERNAL_ERROR;
			binary->out_frame_info.res.width =
				(in_info->res.width >> vf_log_ds);
			binary->out_frame_info.padded_width = vf_out_width;
			binary->out_frame_info.res.height   = vf_out_height;
		} else {
		/* we also store the raw downscaled width. This is used for
		 * digital zoom in preview to zoom only on the width that
		 * we actually want to keep, not on the aligned width. */
			if (out_info == NULL)
static enum sh_css_err
fill_binary_info(const struct sh_css_binary_info *info,
                 bool online,
                 bool two_ppc,
                 enum sh_css_input_format stream_format,
                 const struct sh_css_frame_info *in_info,
                 const struct sh_css_frame_info *out_info,
                 const struct sh_css_frame_info *vf_info,
                 struct sh_css_binary *binary)
{
    unsigned int dvs_env_width = 0,
    dvs_env_height = 0,
    vf_log_ds = 0,
    s3a_log_deci = 0,
    bits_per_pixel = in_info->raw_bit_depth,
    ds_input_width = 0,
    ds_input_height = 0,
    isp_input_width,
    isp_input_height,
    isp_internal_width,
    isp_internal_height,
    isp_output_width  = out_info->padded_width,
    isp_output_height = out_info->height,
    s3a_isp_width;
    bool enable_ds = info->enable_ds;
    bool enable_hus = in_info->width < out_info->width;
    bool enable_vus = in_info->height < out_info->height;

    if (info->enable_dvs_envelope) {
        sh_css_video_get_dis_envelope(&dvs_env_width, &dvs_env_height);
        dvs_env_width  = MAX(dvs_env_width, SH_CSS_MIN_DVS_ENVELOPE);
        dvs_env_height = MAX(dvs_env_height, SH_CSS_MIN_DVS_ENVELOPE);
        binary->dvs_envelope_width  = dvs_env_width;
        binary->dvs_envelope_height = dvs_env_height;
    }
    if (vf_info) {
        enum sh_css_err err;
        err = sh_css_vf_downscale_log2(out_info, vf_info, &vf_log_ds);
        if (err != sh_css_success)
            return err;
        vf_log_ds = min(vf_log_ds, info->max_vf_log_downscale);
    }
    if (online) {
        bits_per_pixel = sh_css_input_format_bits_per_pixel(
            stream_format, two_ppc);
    }
    ds_input_width  = in_info->padded_width + info->left_cropping;
    ds_input_height = in_info->height + info->top_cropping;
    if (enable_hus)
        ds_input_width  += dvs_env_width;
    if (enable_vus)
        ds_input_height += dvs_env_height;

    /* We first calculate the resolutions used by the ISP. After that,
     * we use those resolutions to compute sizes for tables etc. */
    isp_internal_width  =
    __ISP_INTERNAL_WIDTH(isp_output_width, dvs_env_width,
    info->left_cropping, info->mode,
    info->c_subsampling,
    info->output_num_chunks, info->pipelining,
    out_info->format ==
    SH_CSS_FRAME_FORMAT_RGBA888);
    isp_internal_height =
    __ISP_INTERNAL_HEIGHT(isp_output_height, info->top_cropping,
    dvs_env_height);
    isp_input_width = _ISP_INPUT_WIDTH(isp_internal_width,
    ds_input_width,
    enable_ds || enable_hus);
    isp_input_height = _ISP_INPUT_HEIGHT(isp_internal_height,
    ds_input_height,
    enable_ds || enable_vus);

    s3a_isp_width = _ISP_S3A_ELEMS_ISP_WIDTH(isp_input_width,
    isp_internal_width, enable_hus, info->left_cropping);
    if (info->fixed_s3a_deci_log)
        s3a_log_deci = info->fixed_s3a_deci_log;
    else
        s3a_log_deci = sh_css_grid_deci_factor_log2(s3a_isp_width,
        isp_input_height);

    binary->vf_downscale_log2 = vf_log_ds;
    binary->deci_factor_log2  = s3a_log_deci;
    binary->input_buf_vectors =
    SH_CSS_NUM_INPUT_BUF_LINES * _ISP_VECS(isp_input_width);
    binary->online            = online;
    binary->input_format      = stream_format;
    /* input info */
    binary->in_frame_info.format = in_info->format;
    binary->in_frame_info.width = in_info->width + info->left_cropping +
    dvs_env_width;
    binary->in_frame_info.padded_width  = isp_input_width;
    binary->in_frame_info.height        = isp_input_height;
    binary->in_frame_info.raw_bit_depth = bits_per_pixel;
    /* internal frame info */
    binary->internal_frame_info.format          = out_info->format;
    binary->internal_frame_info.width           = isp_internal_width;
    binary->internal_frame_info.padded_width    = isp_internal_width;
    binary->internal_frame_info.height          = isp_internal_height;
    binary->internal_frame_info.raw_bit_depth   = bits_per_pixel;
    /* output info */
    binary->out_frame_info.format        = out_info->format;
    binary->out_frame_info.width         = out_info->width;
    binary->out_frame_info.padded_width  = isp_output_width;
    binary->out_frame_info.height        = isp_output_height;
    binary->out_frame_info.raw_bit_depth = bits_per_pixel;

    /* viewfinder output info */
    binary->vf_frame_info.format = SH_CSS_FRAME_FORMAT_YUV_LINE;
    if (vf_info) {
        unsigned int vf_out_vecs, vf_out_width, vf_out_height;
        vf_out_vecs = __ISP_VF_OUTPUT_WIDTH_VECS(isp_output_width,
        vf_log_ds);
        vf_out_width = _ISP_VF_OUTPUT_WIDTH(vf_out_vecs);
        vf_out_height = _ISP_VF_OUTPUT_HEIGHT(isp_output_height,
        vf_log_ds);
        /* we also store the raw downscaled width. This is used for
         * digital zoom in preview to zoom only on the width that
         * we actually want to keep, not on the aligned width. */
        binary->vf_frame_info.width = (out_info->width >> vf_log_ds);
        binary->vf_frame_info.padded_width = vf_out_width;
        binary->vf_frame_info.height       = vf_out_height;
    } else {
enum ia_css_err
ia_css_binary_fill_info(const struct ia_css_binary_xinfo *xinfo,
		 bool online,
		 bool two_ppc,
		 enum ia_css_stream_format stream_format,
		 const struct ia_css_frame_info *in_info, /* can be NULL */
		 const struct ia_css_frame_info *bds_out_info, /* can be NULL */
		 const struct ia_css_frame_info *out_info[], /* can be NULL */
		 const struct ia_css_frame_info *vf_info, /* can be NULL */
		 struct ia_css_binary *binary,
		 struct ia_css_resolution *dvs_env,
		 int stream_config_left_padding,
		 bool accelerator)
{
	const struct ia_css_binary_info *info = &xinfo->sp;
	unsigned int dvs_env_width = 0,
		     dvs_env_height = 0,
		     vf_log_ds = 0,
		     s3a_log_deci = 0,
		     bits_per_pixel = 0,
		     /* Resolution at SC/3A/DIS kernel. */
		     sc_3a_dis_width = 0,
		     /* Resolution at SC/3A/DIS kernel. */
		     sc_3a_dis_padded_width = 0,
		     /* Resolution at SC/3A/DIS kernel. */
		     sc_3a_dis_height = 0,
		     isp_internal_width = 0,
		     isp_internal_height = 0,
		     s3a_isp_width = 0;

	bool need_scaling = false;
	struct ia_css_resolution binary_dvs_env, internal_res;
	enum ia_css_err err;
	unsigned int i;
	const struct ia_css_frame_info *bin_out_info = NULL;

	assert(info != NULL);
	assert(binary != NULL);

	binary->info = xinfo;
	if (!accelerator) {
		/* binary->css_params has been filled by accelerator itself. */
		err = ia_css_isp_param_allocate_isp_parameters(
			&binary->mem_params, &binary->css_params,
			&info->mem_initializers);
		if (err != IA_CSS_SUCCESS) {
			return err;
		}
	}
	for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) {
		if (out_info[i] && (out_info[i]->res.width != 0)) {
			bin_out_info = out_info[i];
			break;
		}
	}
	if (in_info != NULL && bin_out_info != NULL) {
		need_scaling = (in_info->res.width != bin_out_info->res.width) ||
			(in_info->res.height != bin_out_info->res.height);
	}


	/* binary_dvs_env has to be equal or larger than SH_CSS_MIN_DVS_ENVELOPE */
	binary_dvs_env.width = 0;
	binary_dvs_env.height = 0;
	ia_css_binary_dvs_env(info, dvs_env, &binary_dvs_env);
	dvs_env_width = binary_dvs_env.width;
	dvs_env_height = binary_dvs_env.height;
	binary->dvs_envelope.width  = dvs_env_width;
	binary->dvs_envelope.height = dvs_env_height;

	/* internal resolution calculation */
	internal_res.width = 0;
	internal_res.height = 0;
	ia_css_binary_internal_res(in_info, bds_out_info, bin_out_info, dvs_env,
				   info, &internal_res);
	isp_internal_width = internal_res.width;
	isp_internal_height = internal_res.height;

	/* internal frame info */
	if (bin_out_info != NULL) /* { */
		binary->internal_frame_info.format = bin_out_info->format;
	/* } */
	binary->internal_frame_info.res.width       = isp_internal_width;
	binary->internal_frame_info.padded_width    = CEIL_MUL(isp_internal_width, 2*ISP_VEC_NELEMS);
	binary->internal_frame_info.res.height      = isp_internal_height;
	binary->internal_frame_info.raw_bit_depth   = bits_per_pixel;

	if (in_info != NULL) {
		binary->effective_in_frame_res.width = in_info->res.width;
		binary->effective_in_frame_res.height = in_info->res.height;

		bits_per_pixel = in_info->raw_bit_depth;

		/* input info */
		binary->in_frame_info.res.width = in_info->res.width + info->pipeline.left_cropping;
		binary->in_frame_info.res.height = in_info->res.height + info->pipeline.top_cropping;

#if !defined(HAS_RES_MGR) /* dvs env is included already */
		binary->in_frame_info.res.width += dvs_env_width;
		binary->in_frame_info.res.height += dvs_env_height;
#endif

		binary->in_frame_info.padded_width =
			binary_in_frame_padded_width(in_info->res.width,
						     isp_internal_width,
						     dvs_env_width,
						     stream_config_left_padding,
						     info->pipeline.left_cropping,
						     need_scaling);

		binary->in_frame_info.format = in_info->format;
		binary->in_frame_info.raw_bayer_order = in_info->raw_bayer_order;
		binary->in_frame_info.crop_info = in_info->crop_info;
	}

	if (online) {
		bits_per_pixel = ia_css_util_input_format_bpp(
			stream_format, two_ppc);
	}
	binary->in_frame_info.raw_bit_depth = bits_per_pixel;

	for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) {
		if (out_info[i] != NULL) {
			binary->out_frame_info[i].res.width     = out_info[i]->res.width;
			binary->out_frame_info[i].res.height    = out_info[i]->res.height;
			binary->out_frame_info[i].padded_width  = out_info[i]->padded_width;
			if (info->pipeline.mode == IA_CSS_BINARY_MODE_COPY) {
				binary->out_frame_info[i].raw_bit_depth = bits_per_pixel;
			} else {
				/* Only relevant for RAW format.
				 * At the moment, all outputs are raw, 16 bit per pixel, except for copy.
				 * To do this cleanly, the binary should specify in its info
				 * the bit depth per output channel.
				 */
				binary->out_frame_info[i].raw_bit_depth = 16;
			}
			binary->out_frame_info[i].format        = out_info[i]->format;
		}
	}

#ifndef IS_ISP_2500_SYSTEM
	if (vf_info && (vf_info->res.width != 0)) {
		err = ia_css_vf_configure(binary, bin_out_info, (struct ia_css_frame_info *)vf_info, &vf_log_ds);
		if (err != IA_CSS_SUCCESS) {
			if (!accelerator) {
				ia_css_isp_param_destroy_isp_parameters(
					&binary->mem_params,
					&binary->css_params);
			}
			return err;
		}
	}
#else
	(void)err;
#endif
	binary->vf_downscale_log2 = vf_log_ds;

	binary->online            = online;
	binary->input_format      = stream_format;

	/* viewfinder output info */
	if ((vf_info != NULL) && (vf_info->res.width != 0)) {
		unsigned int vf_out_vecs, vf_out_width, vf_out_height;
		binary->vf_frame_info.format = vf_info->format;
		if (bin_out_info == NULL)
			return IA_CSS_ERR_INTERNAL_ERROR;
		vf_out_vecs = __ISP_VF_OUTPUT_WIDTH_VECS(bin_out_info->padded_width,
			vf_log_ds);
		vf_out_width = _ISP_VF_OUTPUT_WIDTH(vf_out_vecs);
		vf_out_height = _ISP_VF_OUTPUT_HEIGHT(bin_out_info->res.height,
			vf_log_ds);

		/* For preview mode, output pin is used instead of vf. */
		if (info->pipeline.mode == IA_CSS_BINARY_MODE_PREVIEW) {
			binary->out_frame_info[0].res.width =
				(bin_out_info->res.width >> vf_log_ds);
			binary->out_frame_info[0].padded_width = vf_out_width;
			binary->out_frame_info[0].res.height   = vf_out_height;

			binary->vf_frame_info.res.width    = 0;
			binary->vf_frame_info.padded_width = 0;
			binary->vf_frame_info.res.height   = 0;
		} else {
enum sh_css_err
sh_css_fill_binary_info(const struct sh_css_binary_info *info,
		 bool online,
		 bool two_ppc,
		 enum sh_css_input_format stream_format,
		 const struct sh_css_frame_info *in_info, /* can be NULL */
		 const struct sh_css_frame_info *out_info, /* can be NULL */
		 const struct sh_css_frame_info *vf_info, /* can be NULL */
		 struct sh_css_binary *binary,
		 bool continuous)
{
	unsigned int dvs_env_width = 0,
		     dvs_env_height = 0,
		     vf_log_ds = 0,
		     s3a_log_deci = 0,
		     bits_per_pixel = 0,
		     ds_input_width = 0,
		     ds_input_height = 0,
		     isp_input_width,
		     isp_input_height,
		     isp_internal_width,
		     isp_internal_height,
		     isp_output_width = 0,
		     isp_output_height = 0,
		     s3a_isp_width;
	unsigned char enable_ds = info->enable.ds;
	bool enable_yuv_ds = enable_ds & 2;
	bool enable_hus = false;
	bool enable_vus = false;
	bool is_out_format_rgba888 = false;
	bool is_in_format_rawreordered = false;
	unsigned int tmp_width, tmp_height;

assert(info != NULL);

	if (in_info != NULL) {
		bits_per_pixel = in_info->raw_bit_depth;
		if (out_info != NULL) {
			enable_hus = in_info->width < out_info->width;
			enable_vus = in_info->height < out_info->height;
		}
		is_in_format_rawreordered =
			in_info->format == SH_CSS_FRAME_FORMAT_RAW_REORDERED;
	}
	if (out_info != NULL) {
		isp_output_width  = out_info->padded_width;
		isp_output_height = out_info->height;
		is_out_format_rgba888 =
			out_info->format == SH_CSS_FRAME_FORMAT_RGBA888;
	}
	if (info->enable.dvs_envelope) {
		sh_css_video_get_dis_envelope(&dvs_env_width, &dvs_env_height);
		dvs_env_width  = MAX(dvs_env_width, SH_CSS_MIN_DVS_ENVELOPE);
		dvs_env_height = MAX(dvs_env_height, SH_CSS_MIN_DVS_ENVELOPE);
	}
	binary->dvs_envelope.width  = dvs_env_width;
	binary->dvs_envelope.height = dvs_env_height;
	if (vf_info != NULL) {
		enum sh_css_err err;
		err = sh_css_vf_downscale_log2(out_info, vf_info, &vf_log_ds);
		if (err != sh_css_success)
			return err;
		vf_log_ds = min(vf_log_ds, info->max_vf_log_downscale);
	}
	if (online) {
		bits_per_pixel = sh_css_input_format_bits_per_pixel(
			stream_format, two_ppc);
	}
	if (in_info != NULL) {
		ds_input_width  = in_info->padded_width + info->left_cropping;
		ds_input_height = in_info->height + info->top_cropping;
	}
	if (enable_hus) /* { */
		ds_input_width  += dvs_env_width;
	/* } */
	if (enable_vus) /* { */
		ds_input_height += dvs_env_height;
	/* } */
	tmp_width  = (enable_yuv_ds && (ds_input_width > isp_output_width)) ?
			ds_input_width  : isp_output_width;
	tmp_height = (enable_yuv_ds && (ds_input_height > isp_output_height)) ?
			ds_input_height : isp_output_height;

	/* We first calculate the resolutions used by the ISP. After that,
	 * we use those resolutions to compute sizes for tables etc. */
	isp_internal_width = __ISP_INTERNAL_WIDTH(tmp_width,
		dvs_env_width,
		info->left_cropping, info->mode,
		info->c_subsampling,
		info->output_num_chunks, info->pipelining,
		is_out_format_rgba888);
	isp_internal_height = __ISP_INTERNAL_HEIGHT(tmp_height,
		info->top_cropping,
		dvs_env_height);
	isp_input_width = _ISP_INPUT_WIDTH(isp_internal_width,
		ds_input_width,
		enable_ds || enable_hus);
	isp_input_height = _ISP_INPUT_HEIGHT(isp_internal_height,
		ds_input_height,
		enable_ds || enable_vus);
	s3a_isp_width = _ISP_S3A_ELEMS_ISP_WIDTH(isp_input_width,
		isp_internal_width, enable_hus || enable_yuv_ds,
		info->left_cropping);
	if (info->fixed_s3a_deci_log) /* { */
		s3a_log_deci = info->fixed_s3a_deci_log;
	/* } */
	else /* { */
		s3a_log_deci = sh_css_grid_deci_factor_log2(s3a_isp_width,
							    isp_input_height);
	/* } */

	binary->vf_downscale_log2 = vf_log_ds;
	binary->deci_factor_log2  = s3a_log_deci;
	binary->input_buf_vectors =
			SH_CSS_NUM_INPUT_BUF_LINES * _ISP_VECS(isp_input_width);
	binary->online            = online;
	binary->input_format      = stream_format;
	/* input info */
	if (in_info != NULL) {
		binary->in_frame_info.format = in_info->format;
		binary->in_frame_info.width = in_info->width +
			info->left_cropping + dvs_env_width;
	}
	binary->in_frame_info.padded_width  = isp_input_width;
	binary->in_frame_info.height        = isp_input_height;
	binary->in_frame_info.raw_bit_depth = bits_per_pixel;
	/* internal frame info */
	if (out_info != NULL) /* { */
		binary->internal_frame_info.format          = out_info->format;
	/* } */
	binary->internal_frame_info.width           = isp_internal_width;
	binary->internal_frame_info.padded_width    = isp_internal_width;
	binary->internal_frame_info.height          = isp_internal_height;
	binary->internal_frame_info.raw_bit_depth   = bits_per_pixel;
	/* output info */
	if (out_info != NULL) {
		binary->out_frame_info.format        = out_info->format;
		binary->out_frame_info.width         = out_info->width;
	}
	binary->out_frame_info.padded_width  = isp_output_width;
	binary->out_frame_info.height        = isp_output_height;
	binary->out_frame_info.raw_bit_depth = bits_per_pixel;

	/* viewfinder output info */
	binary->vf_frame_info.format = SH_CSS_FRAME_FORMAT_YUV_LINE;
	if (vf_info != NULL) {
		unsigned int vf_out_vecs, vf_out_width, vf_out_height;
		vf_out_vecs = __ISP_VF_OUTPUT_WIDTH_VECS(isp_output_width,
			vf_log_ds);
		vf_out_width = _ISP_VF_OUTPUT_WIDTH(vf_out_vecs);
		vf_out_height = _ISP_VF_OUTPUT_HEIGHT(isp_output_height,
			vf_log_ds);
		/* If we are in continuous preview mode, then out port is
		 * active instead of vfout port
		 */
		if (info->enable.rawdeci && continuous) {
			binary->out_frame_info.width =
				(in_info->width >> vf_log_ds);
			binary->out_frame_info.padded_width = vf_out_width;
			binary->out_frame_info.height       = vf_out_height;
		} else {