////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2013-2023 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef __IS_INTERFACE_H__
#define __IS_INTERFACE_H__

#include <stdint.h>
#include <stdbool.h>
#include "ipdefs.h"
#include "NcLibWarpCommonDef.h"
#include "is_interface_error_codes.h"

/*****************************************************************************/
/*         Definitions and Macros                                            */
/*****************************************************************************/

#define IS_API_VERSION_MAJOR        1   /**< Major API version number */
#define IS_API_VERSION_MINOR        6   /**< Minor API version number */
#define IS_API_VERSION_STEP         0   /**< Step API version number */

#if defined(__GNUC__)
#define EIS_VISIBILITY_PUBLIC __attribute__ ((visibility ("default")))
#define EIS_VISIBILITY_LOCAL  __attribute__ ((visibility ("hidden")))
#else
#define EIS_VISIBILITY_PUBLIC __declspec(dllexport)
#define EIS_VISIBILITY_LOCAL
#endif // defined(__GNUC__)


#if (1 == IS_API_VERSION_MAJOR) && (6 == IS_API_VERSION_MINOR) && ((0 == IS_API_VERSION_STEP))

#ifndef top__gravity_vector_offset
#define top__gravity_vector_offset      top.res_lut_param_0[0]     /**< Offset between gravity vector timing and SOF timing in microseconds */
#endif /* top__gravity_vector_offset */

/**
*   @addtogroup     EISv2_snapshot_stabilization_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to EISv2 snapshot stabilization parameters Chromatix parameters
*
*  @{
*/

#ifndef top__eisv2_snapshot_stabilization_output_max_grid_size
#define top__eisv2_snapshot_stabilization_output_max_grid_size  top.res_lut_param_0[1]  /**< Output grid maximal size for snapshot stabilization
                                                                                         *   0      : Default value is used (35x27)
                                                                                         *   1      : 67x51
                                                                                         *
                                                                                         */
#endif /* top__eisv2_snapshot_stabilization_output_max_grid_size */

/*  @} */


/**
*   @addtogroup     EISv2_gradual_start_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to EISv2 gradual start parameters Chromatix parameters
*
*  @{
*/

#ifndef top__eisv2_gradual_start_delay_before_start_sec
#define top__eisv2_gradual_start_delay_before_start_sec     top.res_lut_param_0[16] /**< Amount of seconds to wait before starting the gradual decrees
                                                                                     *   0      : Default value is used (0.167 second)
                                                                                     *
                                                                                     *  @note:
                                                                                     *      1. Common value to all sensors
                                                                                     *      2. Value will be taken from sensor #0
                                                                                     *      3. Units are in seconds
                                                                                     *      4. Must be non-negative value
                                                                                     *
                                                                                     *  @warning: values are relevant only when operation_mode is defined to be IS_OPT_REGULAR_EIS2_GRADUAL_FOV_START
                                                                                     */
#endif /* top__eisv2_gradual_start_delay_before_start_sec */

#ifndef top__eisv2_gradual_start_change_duration_sec
#define top__eisv2_gradual_start_change_duration_sec        top.res_lut_param_0[17] /**< Amount of seconds that gradual change will take
                                                                                     *   0      : Default value is used (0.33 second)
                                                                                     *
                                                                                     *  @note:
                                                                                     *      1. Common value to all sensors
                                                                                     *      2. Value will be taken from sensor #0
                                                                                     *      3. Units are in seconds
                                                                                     *      4. Must be non-negative value
                                                                                     *
                                                                                     *  @warning: values are relevant only when operation_mode is defined to be IS_OPT_REGULAR_EIS2_GRADUAL_FOV_START
                                                                                     */
#endif /* top__eisv2_gradual_start_change_duration_sec */

/*  @} */

/**
*   @addtogroup     EIS_scene_detection_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to EIS scene detection parameters Chromatix parameters
*
*  @{
*/

#ifndef top__eis_scene_detection_use_acc
#define top__eis_scene_detection_use_acc                    top.res_lut_param_0[18] /**< Use accelerometer to calculate the scene type enable bit
                                                                                     *   0  : Default, legacy mode will be used, feature will be disabled
                                                                                     *   1  : Scene detection will use accelerometer (only in case it is present in the system)
                                                                                     *
                                                                                     *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                     *
                                                                                     */
#endif /* top__eis_scene_detection_use_acc */

/*  @} */

/**
*   @addtogroup     EISv3_auxiliary_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to EISv3 auxiliary Chromatix parameters
*
*  @{
*/

#ifndef general__eisv3_margins_usage_enhancement
#define general__eisv3_margins_usage_enhancement    general.res_param_4     /**< EISv3 super steady flavor mode enable bit
                                                                             *   0  : Default, legacy mode will be used, feature will be disabled
                                                                             *   1  : Super Steady flavor mode will be enabled
                                                                             *
                                                                             *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                             */
#endif /* general__eisv3_margins_usage_enhancement */

#ifndef general__super_steady_flavor_z_strength_factor
#define general__super_steady_flavor_z_strength_factor   general.res_param_10   /**< EISv3 strength increase for z axis only and while super steady margins
                                                                                 *   Units: strength units similar to adaptive behavior
                                                                                 *
                                                                                 *   0      : Default feature is off
                                                                                 *   (0,10] : possible valid values of strength factor
                                                                                 *
                                                                                 *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                 */
#endif /* general__z_lock_max_filter_diff_angle_deg */

/*  @} */

/**
*   @addtogroup     EISv2_auxiliary_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to EISv2 auxiliary Chromatix parameters
*
*  @{
*/

#ifndef general__eis2_gen2
#define general__eis2_gen2    general.res_lut_param_1[0]        /**< eisv2 gen2 enable bit
                                                                 *   0  : Default, legacy mode will be used, feature will be disabled
                                                                 *   1  : feature will be enabled
                                                                 *
                                                                 *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                 */
#endif /* top__eis2_gen2 */

/*  @} */

/**
*   @addtogroup     OIS_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to OIS Chromatix parameters
*
*  @{
*/

#ifndef ois__center_command_effective_zoom_factor_th
#define ois__center_command_effective_zoom_factor_th   ois.ois_res_lut_param_1[0] /**< Publish OIS automatic mode command when pre-EIS zoom (e.g. IFE digital zoom) change above this value, regardless to
                                                                                   *   the exposure time threshold, center_exposure_time_th. Response time is depended on center_response_time_ms.
                                                                                   *
                                                                                   *   0        : Default, legacy mode will be used, feature will be disabled
                                                                                   *   (1,100]  : Valid values range, when effective pre-EIS zoom is above this value, EIS algorithm will publish IS_OIS_MODE_AUTOMATIC regardless to the exposure time
                                                                                   *
                                                                                   *  @note: 1. Base zoom factor is per-sensor and assumed to be 1x.
                                                                                   *         2. Only relevant in case center_command_enable is defined to be true.
                                                                                   */
#endif /* ois__center_command_effective_zoom_factor_th */

#ifndef ois__center_command_disable_for_tripod
#define ois__center_command_disable_for_tripod          ois.ois_res_lut_param_1[2] /**< Disable OIS centered mode on tripod.
                                                                                    *   If enable, will ignore the scene detect to let OIS not centered.
                                                                                    *
                                                                                    *   0: Default. According to the scene detect tripod mode let OIS centered or not.
                                                                                    *   1: OIS will always on, even phone on tripod
                                                                                    *
                                                                                    */
#endif /* ois__center_command_disable_for_tripod */

/*  @} */


/**
*   @addtogroup     DIS_Chromatix_translation_extensions
*
*   @brief          Translate existing reserved parameters to DIS Chromatix parameters
*
*  @{
*/

#ifndef dis__turn_off_dis_min_pan_threshold
#define dis__turn_off_dis_min_pan_threshold             dis.dis_res_lut_param[8]  /**< Minimal panning threshold for disabling DIS for specific frames
                                                                                   *
                                                                                   *   0 : Default, legacy mode will be used, feature will be disabled
                                                                                   *   1 : Weak pan, DIS will be disabled for any kind of panning
                                                                                   *   2 : Normal pan, DIS will be disabled only for regular or strong panning
                                                                                   *   3 : Strong pan, DIS will be disabled only for strong panning
                                                                                   *
                                                                                   *    @note: unique per sensor bit
                                                                                   */
#endif /* dis__turn_off_dis_min_pan_threshold */

#ifndef dis__use_cvp_inlieres_min_ratio_threshold
#define dis__use_cvp_inlieres_min_ratio_threshold       dis.dis_res_lut_param[9]    /**< If CVP inlier motion vectors ratio exceed this value, then DIS will be calculated based on CVP inliers.
                                                                                     *   Otherwise, internal outlier rejection methods will be used
                                                                                     *
                                                                                     *   0     : Default, same as 0.8 (80% inliers by CVP)
                                                                                     *   (0,1] : If CVP inlier morion vectors ratio will exceed this value, then DIS will be calculated based
                                                                                     *           on CVP inliers. Otherwise DIS will be calculated based inliers after internal outlier rejection method
                                                                                     *
                                                                                     *    @note: 1. Unique per sensor bit
                                                                                     *           2. For CVP outlier rejection method only, use low value, for example: 1e-4
                                                                                     *           3. For DIS internal outlier rejection method only, use 1
                                                                                     */
#endif /* dis__use_cvp_inlieres_min_ratio_threshold */

#ifndef dis__turn_off_dis_while_indoor_pan_enable
#define dis__turn_off_dis_while_indoor_pan_enable       dis.dis_res_lut_param[0]  /**< Disable DIS for specific indoor panning frames enable bit
                                                                                   *
                                                                                   *   0 : Default, legacy mode will be used, feature will be disabled
                                                                                   *   1 : DIS will be turned off for indoor panning case only (in addition to other preexisting triggers)
                                                                                   *
                                                                                   *    @note: unique per sensor bit
                                                                                   */
#endif /* dis__turn_off_dis_while_indoor_pan_enable */

#ifndef dis__strong_pan_min_distance_for_dis_enabled
#define dis__strong_pan_min_distance_for_dis_enabled    dis.dis_res_lut_param[1]    /**< Below this values in case of indoor (exposure time above 8ms) and strong pan DIS will be disabled, otherwise enabled
                                                                                      *
                                                                                      *   0 :  Default value will be used (Default = 2.1 [meter])
                                                                                      *
                                                                                      *    @note:
                                                                                      *     1. Units are meters
                                                                                      *     2. Unique per sensor bit
                                                                                      */
#endif /* dis__strong_pan_min_distance_for_dis_enabled */

#ifndef dis__regular_pan_min_distance_for_dis_enabled
#define dis__regular_pan_min_distance_for_dis_enabled   dis.dis_res_lut_param[2]    /**< Below this values in case of indoor (exposure time above 8ms) and regular pan DIS will be disabled, otherwise enabled
                                                                                     *
                                                                                     *   0 :  Default value will be used (Default = 1.7 [meter])
                                                                                     *
                                                                                     *    @note:
                                                                                     *     1. Units are meters
                                                                                     *     2. Unique per sensor bit
                                                                                     */
#endif /* dis__regular_pan_min_distance_for_dis_enabled */

#ifndef dis__linear_blend_filter_disable
#define dis__linear_blend_filter_disable                dis.dis_res_lut_param[3]    /**< Enable bit for DIS convergence type from / to enable / disable modes. If disabled then linear
                                                                                     *   filter will be used, otherwise legacy mode will be taken
                                                                                     *
                                                                                     *   0 : Default, Linear filter mode will be selected
                                                                                     *   1 : legacy mode will be used
                                                                                     *
                                                                                     *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                     */
#endif /* dis__linear_blend_filter_disable */


#ifndef dis__linear_blend_filter_num_frames_to_dec
#define dis__linear_blend_filter_num_frames_to_dec      dis.dis_res_lut_param[4]    /**< Number for frames to decrease blend effect from maximal possible value (1) to minimal possible value (0)
                                                                                     *
                                                                                     *   0 :  Default value will be used (Default = 6 [frames])
                                                                                     *
                                                                                     *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                     */
#endif /* dis__linear_blend_filter_num_frames_to_dec */

#ifndef dis__linear_blend_filter_num_frames_to_inc
#define dis__linear_blend_filter_num_frames_to_inc      dis.dis_res_lut_param[5]    /**< Number for frames to increase blend effect from minimal possible value (0) to maximal possible value (1)
                                                                                     *
                                                                                     *   0 :  Default value will be used (Default = 7 [frames])
                                                                                     *
                                                                                     *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                     */
#endif /* dis__linear_blend_filter_num_frames_to_inc */

#ifndef dis__linear_blend_filter_num_frames_before_invalid
#define dis__linear_blend_filter_num_frames_before_invalid   dis.dis_res_lut_param[6]   /**< Number of frames to disable DIS effect before required from raw decision
                                                                                         *
                                                                                         *   0 :  Default value will be used (Default = 4 [frames])
                                                                                         *
                                                                                         *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                         */
#endif /* dis__linear_blend_filter_num_frames_before_invalid */

#ifndef dis__linear_blend_filter_num_frames_after_invalid
#define dis__linear_blend_filter_num_frames_after_invalid   dis.dis_res_lut_param[7]   /**< Number of frames to disable DIS effect after required from raw decision
                                                                                         *
                                                                                         *   0 :  Default value will be used (Default = 3 [frames])
                                                                                         *
                                                                                         *  @note: Common value to all sensors. Value will be taken from sensor #0
                                                                                         */
#endif /* dis__linear_blend_filter_num_frames_before_invalid */

/*  @} */

#endif /* API version is 1.6.x */

#ifdef __cplusplus
extern "C" {
#endif

/*****************************************************************************/
/*         Chromatix data structures                                         */
/*****************************************************************************/


typedef struct EIS_TOP_V16_TAG
{
    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_fhd_30;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_fhd_30;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_fhd_60;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_fhd_60;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_fhd_120;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_fhd_120;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_4k_30;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_4k_30;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_4k_60;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_4k_60;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_4k_120;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_4k_120;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_8k_30;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_8k_30;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_8k_60;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_8k_60;

    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_8k_120;

    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_8k_120;

    // For preview of snapshot and snapshot itself.
    // Requested physical margins ratio for x axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual x total margins would be between [requested_total_margins_x, minimal_total_margin]
    // format: float
    float requested_total_margins_x_preview;

    // For preview of snapshot and snapshot itself.
    // Requested total margins ratio for y axis, with respect to input image size and represent sum of both sides.
    // This is used for requesting physical margins and also to be sent to GeoLib.
    // Actual y margins would be between [minimal_total_margin, requested_total_margins_y]
    // format: float
    float requested_total_margins_y_preview;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_fhd_30;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_fhd_60;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_fhd_120;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_4k_30;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_4k_60;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_4k_120;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_8k_30;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_8k_60;

    // future looking buffer size
    // format: 16u
    uint32_t future_buffer_size_8k_120;

    // Requested gyro sampling frequency in Hz. Has to match actual gyro sampling frequency.
    // format: 16u
    uint32_t gyro_frequency;

    // Requested OIS sampling frequency in Hz. Has to match actual OIS sampling frequency.
    // If no OIS for sensor, must configure zero.
    // format: 16u
    uint32_t ois_frequency;

    // Requested accelerometer sampling frequency in Hz. Has to match actual accelerometer sampling frequency.
    // 0 value is disable accelerometer.
    // format: 16u
    uint32_t acc_frequency;

    // Requested magnetometer sampling frequency in Hz. Has to match actual magnetometer sampling frequency.
    // 0 value is disable magnetometer.
    // format: 16u
    uint32_t mag_frequency;

    // Requested iFOVC sampling frequency in Hz. Has to match actual iFOVC sampling frequency.
    // 0 value is disable iFOVC.
    // format: 16u
    uint32_t ifovc_frequency;

    // Requested Gravity vector sampling frequency in Hz. Has to match actual Gravity vector sampling frequency.
    // 0 value is disable Gravity vector.
    // format: 16u
    uint32_t gravity_frequency;

    // Delay to display. Used to gather OIS data for OIS filtering. Units are millisecond.
    // format: 8u
    uint32_t ois_delay_to_display_ms;

    // Number of axis to assign to axis lens position x. Minus sign is negative that axis.
    // format: 3s
    int32_t lens_pos_orientation_axis_x;

    // Number of axis to assign to axis lens position y. Minus sign is negative that axis.
    // format: 3s
    int32_t lens_pos_orientation_axis_y;

    // Number of axis to assign to axis lens position z. Minus sign is negative that axis.
    // format: 3s
    int32_t lens_pos_orientation_axis_z;

    // Error margin of frequency estimation ratio w.r.t requested sample rate
    // format: float
    float gyro_frequency_est_ratio_error_margin_vs_init;

    // Error margin of frequency estimation ratio w.r.t average sample rate
    // format: float
    float gyro_frequency_est_ratio_error_margin_vs_avg;

    // Error margin of frequency estimation ratio w.r.t requested sample rate
    // format: float
    float ois_frequency_est_ratio_error_margin_vs_init;

    // Error margin of frequency estimation ratio w.r.t average sample rate
    // format: float
    float ois_frequency_est_ratio_error_margin_vs_avg;

    // Error margin of frequency estimation ratio w.r.t requested sample rate
    // format: float
    float acc_frequency_est_ratio_error_margin_vs_init;

    // Error margin of frequency estimation ratio w.r.t average sample rate
    // format: float
    float acc_frequency_est_ratio_error_margin_vs_avg;

    // Error margin of frequency estimation ratio w.r.t requested sample rate
    // format: float
    float mag_frequency_est_ratio_error_margin_vs_init;

    // Error margin of frequency estimation ratio w.r.t average sample rate
    // format: float
    float mag_frequency_est_ratio_error_margin_vs_avg;

    // Error margin of frequency estimation ratio w.r.t requested sample rate
    // format: float
    float ifovc_frequency_est_ratio_error_margin_vs_init;

    // Error margin of frequency estimation ratio w.r.t average sample rate
    // format: float
    float ifovc_frequency_est_ratio_error_margin_vs_avg;

    //  Zoom factor smoothing enable bit
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : Zoom factoring smoothening will be enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t zoom_factor_smoothing_enable;

    //  SAT matrix smoothing enable bit
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : SAT matrix smoothening will be enabled
    //
    // @note: 1. Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    //        2. If is_sat_enabled is false then this bit will be ignored
    // format: 1u
    uint32_t sat_matrix_smoothing_enable;

    // Top Reserved LUT parameter 0
    // format: float
    float res_lut_param_0[32];

} eis_top;

/** EIS general configurations */
typedef struct EIS_GENERAL_V16_TAG
{
    // Minimal total margins ratio for x/y axis (physical + virtual), with respect to input image size and represent sum of both sides.
    // If physical margins are not sufficient, virtual margins will be used to get to the minimal_total_margin.
    // format: float
    float minimal_total_margin;

    // For preview of snapshot and snapshot itself.
    // Minimal total margins ratio for x/y axis (physical + virtual), with respect to input image size and represent sum of both sides.
    // If physical margins are not sufficient, virtual margins will be used to get to the minimal_total_margin.
    // format: float
    float minimal_total_margin_preview;

    // Focal length in pixel units for horizontal size of 1920. This value is scaled for other resolutions.
    // format: 16u
    uint32_t focal_length;

    // Gyro noise floor [rad/sec]
    // format: float
    float gyro_noise_floor;

    // OIS noise floor per channel [ois input units]
    // Per each channel. May use same value for all channels.
    // format: float
    float ois_noise_floor[6];

    // Accelerometer noise floor [m/s2]
    // format: float
    float acc_noise_floor;

    // Magnetometer noise floor [uT]
    // format: float
    float mag_noise_floor;

    // Precision of the EIS output grid (will be overridden by 0 if HW not supports grid precision 1).
    //     0: 35x27 samples (945 samples are used).
    //     1: 67x51 samples (3417 samples are used).
    // format: 1u
    uint32_t output_grid_precision;

    // Reserved parameter 1
    // format: float
    float res_param_1;

    // Reserved parameter 2
    // format: float
    float res_param_2;

    // Reserved parameter 3
    // format: float
    float res_param_3;

    // Reserved parameter 4
    // format: float
    float res_param_4;

    // Reserved parameter 5
    // format: float
    float res_param_5;

    // Reserved parameter 6
    // format: float
    float res_param_6;

    // Reserved parameter 7
    // format: float
    float res_param_7;

    // Reserved parameter 8
    // format: float
    float res_param_8;

    // Reserved parameter 9
    // format: float
    float res_param_9;

    // Reserved parameter 10
    // format: float
    float res_param_10;

    // Reserved LUT parameter 1
    // format: float
    float res_lut_param_1[32];

    // Reserved LUT parameter 2
    // format: float
    float res_lut_param_2[32];

    // Reserved LUT parameter 3
    // format: 32u
    uint32_t res_lut_param_3[16];

} eis_general;

/** EIS timing related configurations */
typedef struct EIS_TIMING_V16_TAG
{
    // Offset between gyro timing and SOF timing in microseconds
    // format: 32s
    int32_t s3d_offset;

    // Offset between OIS angles timing and SOF timing in microseconds
    // format: 32s
    int32_t ois_offset;

    // Offset between accelerometer timing and SOF timing in microseconds
    // format: 32s
    int32_t acc_offset;

    // Offset between magnetometer timing and SOF timing in microseconds
    // format: 32s
    int32_t mag_offset;

    // Offset between iFOVC angles timing and SOF timing in microseconds
    // format: 32s
    int32_t ifovc_offset;

} eis_timing;

/** EIS blur masking configurations */
typedef struct EIS_BLUR_MASKING_V16_TAG
{
    // Enable blur masking mechanism
    // 0 is disable mechanism
    // 1 is enable current mechanism
    // 2 is enable experimental mechanism with adaptive behavior
    // format: 2u
    uint32_t enable;

    // Minimal stabilization strength for strong blur ( estimated_blur >= end_decrease_at_blur )
    // format: float
    float min_strength;

    // if (exp_time > exposure_time_th) then blur masking feature is enabled.
    // Otherwise disabled
    // Units are seconds
    // format: float
    float exposure_time_th;

    // Blur below this point won't decrease strength. Units are pixels out of 1920 resolutions.
    // Blur above this point will cause min_strength stabilization (in between start/end interpolate) Units are pixels out of 1920 resolutions.
    // If (end_decrease_at_blur>start_decrease_at_blur) then feature will be disabled.
    // format: float
    float start_decrease_at_blur;

    // Blur below this point won't decrease strength. Units are pixels out of 1920 resolutions.
    // Blur above this point will cause min_strength stabilization (in between start/end interpolate) Units are pixels out of 1920 resolutions.
    // If (end_decrease_at_blur>start_decrease_at_blur) then feature will be disabled.
    // format: float
    float end_decrease_at_blur;

    // Threshold for pan detection on the filter result [rad/sec].
    // Lower than pan_min_threshold is not a pan. Higher than pan_max_threshold is a full pan. In between the weight is linear.
    // Blur masking mechanism is only active when no pan is detected.
    // format: float
    float pan_min_threshold;

    // Threshold for pan detection on the filter result [rad/sec].
    // Lower than pan_min_threshold is not a pan. Higher than pan_max_threshold is a full pan. In between the weight is linear.
    // Blur masking mechanism is only active when no pan is detected.
    // format: float
    float pan_max_threshold;

    // Above this value a constant strength is picked to be min_strength_exp_th_2. Units are [seconds].
    // If value is defined to be 0 (Default Chromatix value) legacy mode will be used, and feature will be disabled
    // format: float
    float exposure_time_th_2;

    // Lower strength to pick in case of exposure time >= blur_masking__exposure_time_th_2. Valid values are in (0,1].
    // Only used in case (blur_masking__exposure_time_th_2 > 0).
    // format: float
    float min_strength_exp_th_2;

    // Above this value a constant strength is picked to be min_strength_exp_th_3. Units are [seconds].
    // If value is defined to be 0 (Default Chromatix value) legacy mode will be used, and feature will be disabled
    // format: float
    float exposure_time_th_3;

    // Lower strength to pick in case of exposure time >= blur_masking__exposure_time_th_3. Valid values are in (0,1].
    // Only used in case (blur_masking__exposure_time_th_3 > 0).
    // format: float
    float min_strength_exp_th_3;

    // Reserved LUT parameter
    // format: float
    float blur_masking_res_lut[32];

} eis_blur_masking;


/** EIS lens distortion correction configurations */
typedef struct EIS_LENS_DISTORTION_CORRECTION_V16_TAG
{
    // 0 = use grids defined here (local grid, only if ldc_grid_enable == 1, , otherwise no LDC)
    // 1 = use grids defined in ICA/LDC Chromatix (only if its valid, otherwise no LDC)
    // Comment: Usually take grids from ICA Chromatix unless the input FOV is different between Video with EIS or video without EIS. Or if the chip doesn't contains ICA Chromatix.
    // format: 1u
    uint32_t ldc_grid_source;

    // Enable/validity for the grids below (defined under EIS Chromatix)
    // format: 1u
    uint32_t ldc_grid_enable;

    // 0 = EIS local grid is calibrated on Full Sensor domain (FOV)
    // 1 = EIS local grid is calibrated on IFE Input    @ DZ X1 domain (FOV)
    // 2 = EIS local grid is calibrated on IFE Output @ DZ X1 domain (FOV)
    // Comment: EIS local grid means the grid defined below and not the one coming from ICA Chromatix
    // format: 2u
    uint32_t ldc_calib_domain;

    // LDC grid in2out. Grid coordinates are defined on image_size_undistorted.
    // format: float
    float distorted_input_to_undistorted_ldc_grid_x[3417];

    // LDC grid in2out. Grid coordinates are defined on image_size_undistorted.
    // format: float
    float distorted_input_to_undistorted_ldc_grid_y[3417];

    // Precision of the LDC in2out grid.
    //     0: 35x27 samples (945 samples are used).
    //     1: 67x51 samples (3417 samples are used).
    // format: 1u
    uint32_t distorted_input_to_undistorted_ldc_grid_geometry;

    // LDC grid out2in. Grid coordinates are defined on image_size_distorted.
    // format: float
    float undistorted_to_distorted_input_ldc_grid_x[3417];

    // LDC grid out2in. Grid coordinates are defined on image_size_distorted.
    // format: float
    float undistorted_to_distorted_input_ldc_grid_y[3417];

    // Precision of the LDC out2in grid.
    //     0: 35x27 samples (945 samples are used).
    //     1: 67x51 samples (3417 samples are used).
    // format: 1u
    uint32_t undistorted_to_distorted_input_ldc_grid_geometry;

    // Distorted image size, image used for LDC calibration
    // format: 16u
    uint32_t image_size_distorted_x;

    // Distorted image size, image used for LDC calibration
    // format: 16u
    uint32_t image_size_distorted_y;

    // Un-Distorted image size, image used for LDC calibration
    // format: 16u
    uint32_t image_size_undistorted_x;

    // Un-Distorted image size, image used for LDC calibration
    // format: 16u
    uint32_t image_size_undistorted_y;

    // 0 = custom/no model (grid is not by any of the following models model ), 1 = regular, 2= fisheye, 3 = reserved for a new model
    // format: 3u
    uint32_t ldc_model_type;

    // Model parameters to be used with the selected model.
    // Parameters interpretation per model:
    // For model 1: [k1 k2 p1 p2 k3]
    // For model 2: [k1 k2 k3 k4]
    // format: float
    float model_parameters[32];

    // Camera matrix \ Focal length that was extracted during camera calibration for LDC. Image sizes (image_size_distorted) are as defined above and are not normalized and according to calibration images.
    // format: float
    float focal_length_x;

    // Camera matrix \ Focal length that was extracted during camera calibration for LDC. Image sizes (image_size_distorted) are as defined above and are not normalized and according to calibration images.
    // format: float
    float focal_length_y;

    // Camera matrix \ Optical center that was extracted during camera calibration for LDC. Image sizes (image_size_distorted) are as defined below and are not normalized and according to calibration images.
    // format: float
    float optical_center_x;

    // Camera matrix \ Optical center that was extracted during camera calibration for LDC. Image sizes (image_size_distorted) are as defined below and are not normalized and according to calibration images.
    // format: float
    float optical_center_y;

} eis_lens_distortion_correction;

/** EIS OIS configurations */
typedef struct EIS_OIS_V16_TAG
{
    // Type 0 is lens shift
    // Type 1 is general model
    // Type 2 is general model 2
    // Type 3 is gimbal (tilt-rotation)
    // Type 4 is gimbal prism
    // Types 5 to 15 are reserved
    // format: 4u
    uint32_t module_type;

    // Conversion polynomial coefficients between hall data x and hall data y to x axis pixels. Polynomial result is normalized to horizontal image size of 1920 (then scale by algorithm per resolution).
    // ois_conversion_func(hall_x,hall_y) = p00 + p10*hall_x + p01*hall_y + p20*hall_x^2 + p11*hall_x*hall_y + p02*hall_y^2 + p30*hall_x^3 + p21*hall_x^2*hall_y + p12*hall_x*hall_y^2 + p03*hall_y^3
    //
    // Notes:
    // - Used for module types 0,2
    // - In case of rotational OIS, this function is still used but converts angles to angles.
    // format: float
    float data_conversion_x[10];

    // Conversion polynomial coefficients between hall data x and hall data y to y axis pixels. Polynomial result is normalized to horizontal image size of 1920 (then scale by algorithm per resolution).
    // ois_conversion_func(hall_x,hall_y) = p00 + p10*hall_x + p01*hall_y + p20*hall_x^2 + p11*hall_x*hall_y + p02*hall_y^2 + p30*hall_x^3 + p21*hall_x^2*hall_y + p12*hall_x*hall_y^2 + p03*hall_y^3
    //
    // Notes:
    // - Used for module types 0,2
    // - In case of rotational OIS, this function is still used but converts angles to angles.
    // format: float
    float data_conversion_y[10];

    // ois_conversion_func(hall_x,hall_y,hall_z) =  p100*hall_x + p010*hall_y + p001*hall_z + p003*hall_z^3
    // For prism we get hall_z = -ois_conversion_func_y(hall_x, hall_y)   (Change of y angle which is shift  in x axis caused rotation around z axis with same rotation angle of y axis )
    // For gimbal we get hall_z from OIS input
    // format: float
    float data_conversion_z[4];

    // Add this offset to OIS raw readings before entering to data conversion function or before entering to general model.
    // It is used in order to have 0,0 when OIS is centered.
    //
    // format: float
    float data_raw_offset_x;

    // Add this offset to OIS raw readings before entering to data conversion function or before entering to general model.
    // It is used in order to have 0,0 when OIS is centered.
    //
    // format: float
    float data_raw_offset_y;

    // General model parameters
    // format: float
    float general_model_parameters[512];

    // General model parameters defined on image size
    // format: 16u
    uint32_t general_model_transform_defined_on_x;

    // General model parameters defined on image size
    // format: 16u
    uint32_t general_model_transform_defined_on_y;

    // Enable OIS centering mechanism (option to center \ automatic modes)
    // format: 1u
    uint32_t center_command_enable;

    // If (exp_time > exposure_time_th) then OIS is set to automatic mode, otherwise OIS is fixed to center. Units are microsecond [us]
    // format: 16u
    uint32_t center_exposure_time_th;

    // Response time of OIS centering mechanism between centering \ automatic operation mode. Units are millisecond [ms]
    // format: 16u
    uint32_t center_response_time_ms;

    // 0 is default
    // Other are reserved and should be set according to QIS team recommendation only
    // format: 5u
    uint32_t ois_filter_mode;

    // OIS filter parameters are required in case ois_filter_mode is not using default settings
    // format: float
    float ois_filter_parameters[64];

    // Publish OIS center command during zoom change or before / after sensor switch. OIS will be centered for at least center_response_time_ms
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : OIS center command during zoom feature is enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t center_during_zoom_transition;

    // For exposure time larger than this value sync OIS shall be turned off.
    // Change OIS filter mode according to the exposure time threshold.
    // If frame exposure time is larger than the parameter value, will use non sync-OIS filter mode.
    // Otherwise will use filter according to ois_filter_mode
    //
    // 0          : Default, will according to parameter ois_filter_mode choose OIS filter mode.
    // [1, 42000] : Valid values, if frame exposure time is larger than the parameter value, will use non sync-OIS filter mode
    //
    // @note: Units are microseconds [us]
    // format: 32u
    uint32_t disable_sync_ois_exposure_time_th;

    // Reserved LUT parameter
    // format: float
    float ois_res_lut_param_1[16];

    // Reserved LUT parameter
    // format: float
    float ois_res_lut_param_2[16];

} eis_ois;

/** EIS DIS configurations */
typedef struct EIS_DIS_V16_TAG
{
    // Enable DIS
    // format: 1u
    uint32_t enable;

    // Enable DIS for selfie front cam
    // format: 1u
    uint32_t enable_for_selfie;

    // if (exp_time[sec] <= exposure_time_threshold[sec]) then DIS feature is enabled.
    // Otherwise disabled
    // Units are seconds
    // format: float
    float exposure_time_threshold;

    // if (focus_distance[meter] >= focus_distance_threshold[meter]) then DIS feature is enabled.
    // Otherwise disabled
    // Units are meters
    // if value == 0 then DIS will never be disabled due to this mechanism
    // format: float
    float focus_distance_threshold;

    // Robustness value above or equal which the motion vector result is valid.
    // format: 4s
    int32_t robustness_threshold;

    // When calculated transform confidence is below this threshold, the transform is ignored and DIS is not used. Hysteresis is used on this parameter to avoid excessive switching.
    // format: 8u
    uint32_t confidence_threshold;

    // Reserved LUT parameter
    // format: float
    float dis_res_lut_param[32];

} eis_dis;

/** EIS z-lens position configurations */
typedef struct EIS_Z_LENS_POS_V16_TAG
{
    // Enable FOVC scaling in EIS
    // format: 1u
    uint32_t enable;

    // Options to calculate scale:
    // 0 is external scale from AF\FOVC
    // 1 is derive scale from z_lens_pos input and internal iFOVC LUT scale parameters
    // format: 1u
    uint32_t scale_source;

    // The source of z_lens_pos in case of using z_lens_pos
    // 0: Take z_lens_pos from iFOVC input struct (estimation if from AF or real reading if coming from lens_pos controller)
    // 1: Take z_lens_pos from OIS input struct (third field, real readings)
    // format: 1u
    uint32_t z_lens_pos_source;

    // Scale vs z_lens_pos function: this LUT is for z_lens_pos
    // format: float
    float lut_z_lens_pos[16];

    // Scale vs z_lens_pos function: this LUT is for scale to bring any focus FOV to infinity focus FOV
    // (1 for focus infinity , <1 is what scale to do to be like infinity fov)
    // format: float
    float lut_scale_vs_z_lens_pos[16];

    // Number of entries in scale vs z_lens_pos LUT to use
    // format: 5u
    uint32_t lut_len;

    // Limitation of the correction. If set to higher value it will limit the correction accordingly. Set to 1 will disable feature.
    // format: float
    float min_scale_limit;

    // z lens position readings noise floor (reading noise while focus is constant)
    // format: float
    float z_lens_pos_noise_floor;

    // if you enable ldc or not for the iFOVC ldc only mode
    // format: 1u
    uint32_t enable_ldc_in_ifovc_ldc_only_mode;

    // 0 is constant scale for entire frame
    // 1 is different scale per image line
    // format: 1u
    uint32_t fovc_mode;

} eis_z_lens_position;

/** EIS selfie configurations */
typedef struct EIS_SELFIE_V16_TAG
{
    // Enable selfie_distortion_prevention_enable for front sensors
    // format: 1u
    uint32_t face_distortion_prevention_enable;

    // Movement below this feature will get no feature impact
    // format: float
    float face_distortion_prevention_angle_delta_th_low;

    // Movement above this value will get feature max result
    // format: float
    float face_distortion_prevention_angle_delta_th_high;

    // Max factor for feature when movement is higher than face_distortion_prevention_angle_delta_th_high
    // format: float
    float face_distortion_prevention_factor_high;

    // Kernel weight if need to decrease mechanism strength for current frame
    // format: float
    float face_distortion_prevention_kernel_decrease;

    // Kernel weight if need to increase mechanism strength for current frame
    // format: float
    float face_distortion_prevention_kernel_increase;

    // Selfie distortion prevention, in case of strong selfie distortion, distortion correction grid will be re-calculated
    // according to selfie distortion prevention mechanism decision.
    // 0  : Default, legacy mode will be used, feature will be disabled
    // 1  : grid distortion correction recalculation will be enabled
    //
    // Note:  - Only relevant for EISv3
    //        - Might affect EIS+MCTF quality in some cases
    //        - Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    //        - If camera is not on selfie mode then this bit will be ignored
    // format: float
    float face_distortion_prevention_allow_grid_recalc;

    // Face detection ROIs will be used for selfie distortion prevention mechanism
    // 0  : Default, legacy mode will be used, feature will be disabled
    // 1  : Face detection ROIs will be used for selfie distortion prevention
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t face_detection_enable;

    // Minimal face detection confidence for which ROI will be treated as face.
    // Below this value ROIs will be disregarded for selfie distortion prevention mechanism.
    // Valid values are in [0,1000], where 0 means that ROI is most definitively not a face and 1000 means that ROI is almost surly containing a face.
    //
    // @note: Unique value per, sensor in case there are more than one selfie sensors in the system.
    // format: 10u
    uint32_t face_detection_minimal_confidence_threshold;

    // Minimal face detection ROI area ratio with respect to face detection full frame size.
    // Below this value ROIs will be disregarded for selfie distortion prevention mechanism.
    // Valid values are in [0,1], where 0 means that ROI is empty and 1 means that it covers the full face detection frame FOV.
    //
    // @note: Unique value per, sensor in case there are more than one selfie sensors in the system.
    // format: float
    float face_detection_minimal_roi_area_ratio;

    // Number of frames without face before selfie distortion preventions mechanism is disabled.
    // When number of frames without face counter is strictly below this value will selfie distortion prevention mechanism
    // will be enabled, otherwise mechanism will be disabled.
    //
    // 0      : Default values is used, 15 frames without face will be used
    // (1:60) : Valid values. Recommended value is 15 frames
    //          Note that when 1 is picked then for the first frame without face selfie distortion
    //          prevention feature will be disabled for this frame.
    //
    // @note: Unique value per, sensor in case there are more than one selfie sensors in the system.
    // format: 10u
    uint32_t face_detection_max_num_frames_without_face;

    // Reserved LUT parameter
    // format: float
    float face_distortion_prevention_res_lut_param[32];

} eis_selfie;

typedef struct EIS_HORIZON_LEVELING_V16_TAG
{
    // Enable horizon leveling
    // format: 1u
    uint32_t enable;

    // Limit horizon leveling by minimum between this limit and WarpEngine limit in degrees
    // format: float
    float max_roll_leveling_deg;

    // Maximal angle in degrees that describes pointing to horizon (not to the sky or ground) for activating horizon leveling
    // 0      : Default value is used
    // (0,85] : Valid values
    //
    // @note:
    //     1. Common value to all sensors
    //     2. Units are degrees
    //     3. Recommended value is 30 degrees.
    //     4. If set to 0, angle_horizon_sky_stop,angle_horizon_roll_start,angle_horizon_roll_stop must also be set to zero
    // format: float
    float angle_horizon_sky_start;

    // Minimal angle in degrees that describes pointing to sky or ground (not horizon) for stopping horizon leveling
    // 0      : Default value is used
    // (0,85] : Valid values
    //
    // @note:
    //     1. Common value to all sensors
    //     2. Units are degrees
    //     3. Recommended value is 45 degrees
    //     4. if set to 0, angle_horizon_sky_start,angle_horizon_roll_start,angle_horizon_roll_stop must also be set to zero
    //
    // @warning Values lower than angle_horizon_sky_start may disable horizon leveling, and therefore will be overridden
    // format: float
    float angle_horizon_sky_stop;

    // Maximal roll angle in degrees (between device and horizon) for activating horizon leveling
    // 0      : Default value is used
    // (0,45) : Valid values
    //
    // @warning The recommended order relation should be:
    //              0 < angle_horizon_roll_start <= max_roll_leveling_deg < angle_horizon_roll_stop < 45
    //
    //  @note:
    //      1. Common value to all sensors
    //      2. Units are degrees
    //      3. Recommended value is 30 degrees
    //      4. if set to 0, angle_horizon_roll_stop,angle_horizon_sky_start,angle_horizon_sky_stop must also be set to zero
    // format: float
    float angle_horizon_roll_start;

    // Minimal roll in degrees (between device and horizon) that stops horizon leveling.
    // 0      : Default value is used
    // (0,45) : Valid values
    //
    // @note:
    //     1. Common value to all sensors
    //     2. Units are degrees
    //     3. Recommended value 40 degrees
    //     4. if set to 0: angle_horizon_roll_start,angle_horizon_sky_start,angle_horizon_sky_stop must also be set to zero
    //
    // @warning: values lower than angle_horizon_roll_start may disable horizon leveling, and therefore will be overridden
    // format: float
    float angle_horizon_roll_stop;

    // Reserved LUT parameter
    // format: float
    float horizon_leveling_res_lut[8];

} eis_horizon_leveling;

typedef struct EIS_ADAPTIVE_BEHAVIOR_V16_TAG
{
    //  Adaptively enabling handheld stabilization boost
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : Adaptive stabilization boost for handheld case will be enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t eisv2_handheld_boost_enable;

    //  Adaptively enabling panning stabilization boost
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : Adaptive stabilization boost for panning case will be enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t eisv2_panning_boost_enable;

    //  Adaptively enabling handheld stabilization boost
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : Adaptive stabilization boost for handheld case will be enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t eisv3_handheld_boost_enable;

    //  Adaptively enabling panning stabilization boost
    //  0  : Default, legacy mode will be used, feature will be disabled
    //  1  : Adaptive stabilization boost for panning case will be enabled
    //
    // @note: Common bit to all sensor. If one enabled for one sensor feature will be enabled for all other sensors as well.
    // format: 1u
    uint32_t eisv3_panning_boost_enable;

    // EISv3 scene vs. exposure time LUT enable/disable flag
    //
    // @note: If this bit is enabled for this sensor, then it will override eis_blur_masking flag to be disabled
    // format: 1u
    uint32_t eisv3_scene_vs_exposure_time_lut_enable;

    // EISv3 Number of entries in scene type LUT, bounded by 8
    // format: 4u
    uint32_t eisv3_scene_type_lut_length;

    // EISv3 Number of entries in exposure time LUT, bounded by 8
    // format: 4u
    uint32_t eisv3_exposure_time_lut_length;

    // Each entry in the array is an activity scene type from: is_scene_types.
    //
    // @note:
    //    1. If a scene is not present in the LUT default stabilization value will used
    //    2. IS_SCENE_TRIPOD (0) is not supported and will be ignored
    //    3. If handheld_boost_enable is defined to be true, then IS_SCENE_HANDHELD (1) scene is ignored
    //    4. If pan_boost_enable is defined to be true, then IS_SCENE_PANNING and IS_SCENE_STRONG_PANNING scenes are ignored
    // format: 4u
    uint32_t eisv3_scene_type_lut[8];

    // Exposure time half close half open interval leftmost point, where the first entry is in [0,x1), second point is in [x1, x2), etc.
    // Units are in milliseconds.
    //
    // @note: 1. Values must be monotonically increasing
    //        2. Distance between intervals must be at least 3ms apart
    // format: 10u
    uint32_t eisv3_exposure_time_lut[8];

    // EISv3 stabilization intensity according to scene type and exposure time entry.
    // Units are float in (-15, 15), where 0 is default stabilization and -15 is for least stabilization effect. +6 is steadier handheld, more than that is not advised.
    // format: float
    float eisv3_scene_vs_exposure_time_lut[64];

    // Reserved LUT parameter
    // format: float
    float adaptive_behavior_res_lut[128];

} eis_adaptive_behavior;

/** Chromatix configuration data structure */
typedef struct is_chromatix_info_s
{
    eis_top                         top;                        /**< EIS top level parameters configurations struct */
    eis_general                     general;                    /**< General Chromatix configuration struct */
    eis_timing                      timing;                     /**< Timing related Chromatix configuration struct */
    eis_blur_masking                blur_masking;               /**< Blur masking related Chromatix configuration struct */
    eis_lens_distortion_correction  lens_distortion_correction; /**< Lens distortion correction configuration struct */
    eis_ois                         ois;                        /**< OIS related Chromatix configuration struct */
    eis_dis                         dis;                        /**< DIS related Chromatix configuration struct */
    eis_z_lens_position             z_lens_position;            /**< Z-lens position related Chromatix configuration struct */
    eis_selfie                      selfie;                     /**< Selfie related Chromatix configuration struct */
    eis_horizon_leveling            horizon_leveling;           /**< Horizon leveling related Chromatix configuration struct */
    eis_adaptive_behavior           adaptive_behavior;          /**< Adaptive behavior related Chromatix configuration struct */
} is_chromatix_info_t;



/*****************************************************************************/
/*         EIS Algorithm data structures                                     */
/*****************************************************************************/

/** Frame time data structure */
typedef struct frame_times_s
{
    uint64_t sof;                          /**< Start of frame in microseconds */
    uint32_t frame_time;                   /**< Total frame time in microseconds */
    uint32_t exposure_time;                /**< Exposure time in microseconds */
    uint32_t sensor_rolling_shutter_skew;  /**< sensor_rolling_shutter_skew in microseconds */
} frame_times_t;

/** Location of camera enumerator */
typedef enum CameraPosition_e
{
    CAM_REAR      = 0,        /**< Rear camera */
    CAM_FRONT     = 1,        /**< Front camera */
} CameraPosition;

/** EIS algorithm type */
typedef enum cam_is_type_e
{
    IS_TYPE_EIS_2_0                     = 4,                /**< EIS 2.x */
    IS_TYPE_EIS_NFL                     = IS_TYPE_EIS_2_0,  /**< EIS Non-Future looking */
    IS_TYPE_EIS_3_0                     = 5,                /**< EIS 3.x */
    IS_TYPE_EIS_FL                      = IS_TYPE_EIS_3_0,  /**< EIS Future looking */
    IS_TYPE_DISTORTION_CORRECTION_ONLY  = 6,                /**< EIS algorithm will output only distortion correction grid (without stabilization matrix) */
} cam_is_type_t;

/** EIS deployment type */
typedef enum cam_is_deployment_type_e
{
    DEP_TYPE_ICA_V20    = 0,                /**< EIS warp is done in ICA_V20 */
    DEP_TYPE_ICA_V30    = 1,                /**< EIS warp is done in ICA_V30 */
    DEP_TYPE_ICA_V40    = DEP_TYPE_ICA_V30, /**< EIS warp is done in ICA_V40 */
    DEP_TYPE_GPU_PRE    = 10,                /**< EIS warp is done in GPU pre IPE */
    DEP_TYPE_GPU_POST   = 11,                /**< EIS warp is done in GPU post IPE/OPE */
} cam_is_deployment_type_t;

/** EIS algorithm initialization type */
typedef enum cam_is_operation_mode_e
{
    IS_OPT_REGULAR                          = 0,    /**< Regular operation mode, Stabilizer works as expected. */
    IS_OPT_CALIBRATION_SYMMETRIC            = 1,    /**< @deprecated */
    IS_OPT_CALIBRATION_ASYMMETRIC           = 2,    /**< Calibration mode (asymmetric Downscale) - Stabilizer won't act but instead downscale
                                                     *   Input image to output image size for later tuning or simulations.
                                                     *   Downscale is asymmetric for both axes. In case of different margins
                                                     *   per axis there will be need for different upscale per axis before simulations or tuning.
                                                     */

    IS_OPT_CALIBRATION_ASYMMETRIC_ROBUST    = 3,    /**< Same as IS_OPT_CALIBRATION_ASYMMETRIC but no return even if have
                                                     *   internal fail due to invalid input etc.
                                                     */

    IS_OPT_UNDISTORTION_ONLY                = 10,   /**< Distortion correction only mode, no stabilization will be applied.
                                                     *   Outputs Grid will correct only rolling shutter skew and lens distortion.
                                                     *
                                                     *   @note For optimal operation flow Either init the algorithm with
                                                     *         IS_TYPE_DISTORTION_CORRECTION_ONLY or use IS_OPT_TEST_DISTORTION_CORRECTION_ONLY
                                                     */
    IS_OPT_IDENTITY_ONLY_ROBUST             = 11,   /**< Output identity matrix. Will also output the OIS center command and CVP alignment.*/
    IS_OPT_IFOVC_LDC_ONLY                   = 12,   /**< EIS algorithm will output only iFVOC + LDC distortion correction grid for iFOVC (without stabilization matrix). gyro based alignment is not functional for this mode. */

    IS_OPT_REGULAR_EIS2_GRADUAL_FOV_START   = 13,    /**< Quick take for display only. will have mimic of 0% margins for first frame and full margins after 10 frames. */

    IS_OPT_TEST_SAT_PASS_THROUGH            = 101,  /**< Test Mode : SAT matrix pass through */
    IS_OPT_TEST_MARGINS_LIMITS              = 102,  /**< Test Mode : Margin limit */
    IS_OPT_TEST_DISTORTION_CORRECTION_ONLY  = IS_OPT_UNDISTORTION_ONLY,  /**< Test Mode : Distortion correction only mode, no stabilization will be applied.
                                                                          *               Outputs Grid will correct only rolling shutter skew and lens distortion.
                                                                          */
    IS_OPT_TEST_REGULAR_MERGE_DIS_EIS       = 104,  /**< Test Mode :  Merge DIS grid and stabilization matrix into a single grid transform */
} cam_is_operation_mode_t;

/** OIS operation mode */
typedef enum cam_is_ois_mode_e
{
    IS_OIS_MODE_INVALID     = 0,                /**< Output OIS mode is invalid and should be ignored by CamX node,
                                                 *   in case previous decision exists in the system use it
                                                 */
    IS_OIS_MODE_CENTER      = 1,                /**< OIS mode should be switched to center */
    IS_OIS_MODE_AUTOMATIC   = 2                 /**< OIS mode should be switched to automatic operation mode */
}cam_is_ois_mode;

/**< Scene types enumerator */
typedef enum is_scene_types_e
{
    IS_SCENE_TRIPOD         = 0,    /**< Device is mounted on tripod, without user is touching the device at all */
    IS_SCENE_HANDHELD       = 1,    /**< Device is hand held, while user is trying to be as steady is possible */
    IS_SCENE_WALKING        = 2,    /**< Device is held while the person is walking in normal phase */
    IS_SCENE_RUNNING        = 3,    /**< Device is held while the person is running (light running) */
    IS_SCENE_PANNING        = 4,    /**< Panning is done in at least one direction */

    IS_SCENE_STRONG_PANNING = 5,    /**< @deprecated Strong panning is done in at least one direction */

    IS_SCENE_OTHER          = 6,    /**< All other use-cases */

    IS_SCENE_NUM_OF_SCENE_TYPES, /**< Invalid value, must be the last member */
    IS_SCENE_INVALID    = IS_SCENE_NUM_OF_SCENE_TYPES,
}is_scene_types;

/**< Scene types data structure */
typedef struct scene_detection_s
{
    is_scene_types  scene_type;
    uint8_t         is_panning[3]; /**< In case panning was detected contains the pan direction
                                    *       0: pitch
                                    *       1: yaw
                                    *       2: roll
                                    */
}scene_detection_t;

/** single sample structure, contains information per axis and time-stamp */
typedef struct _sample_data_s
{
    double      data[6];    /**< in case 4 or elements exists: 0==x, 1==y, 2==z, 3==w,
                             *   in case 6 elements exists: 0==x1, 1==y1, 2==z1, 3==x2, 4==y2, 5==z2,
                             */
    uint64_t    ts;         /**< time stamp in microseconds */
} sample_data_t;

/** Samples array structures */
typedef struct _samples_data_s
{
    sample_data_t*  samples;        /**< Per axis data array */
    uint32_t        num_elements;   /**< Number of elements in the buffer */
} samples_data_t;

typedef samples_data_t  gyro_data_t;            /**< Gyro samples array. Measures device angular velocity [Rad/sec] */
typedef samples_data_t  acc_data_t;             /**< Accelerometer samples array. Measures device acceleration [g] */
typedef samples_data_t  mag_data_t;             /**< Magnetometer samples array. Measures device acceleration [Volt * sec/meter^2] */
typedef samples_data_t  ois_data_t;             /**< OIS samples array. */
typedef samples_data_t  ifovc_data_t;           /**< iFOVC samples array. */

typedef samples_data_t  linear_acc_data_t;      /**< Linear accelerometer samples array. Measures device acceleration [g] */
typedef samples_data_t  abs_orientation_data_t; /**< Absolute orientation samples array. */
typedef samples_data_t  rel_orientation_data_t; /**< Relative orientation samples array. */
typedef acc_data_t      gravity_vector_data_t;  /**< Gravity vector samples array. */

/** Samples interval data structure */
typedef struct samples_times_s
{
    uint64_t first_ts;  /**< First sample timestamps [microseconds] in a batch of samples */
    uint64_t last_ts;   /**< Last sample timestamps [microseconds] in a batch of samples */
} samples_times_t;

typedef samples_times_t  gyro_times_t;      /** Gyro interval data structure */
typedef samples_times_t  ois_times_t;       /** OIS interval data structure */
typedef samples_times_t  ifovc_times_t;     /** iFOVC interval data structure */
typedef samples_times_t  acc_times_t;       /** Accelerometer interval data structure */
typedef samples_times_t  mag_times_t;       /** Magnetometer interval data structure */
typedef acc_times_t      gravity_times_t;   /** Gravity vector interval data structure */

/** Time intervals data structure */
typedef struct is_time_intervals_s
{
    gyro_times_t    gyro;       /**< Gyro interval  */
    ois_times_t     ois;        /**< OIS interval   */
    ifovc_times_t   ifovc;      /**< iFOVC interval */
    acc_times_t     acc;        /**< Accelerometer interval */
    mag_times_t     mag;        /**< Magnetometer interval */
    gravity_times_t gravity;    /**< Gravity vector interval */
} is_time_intervals;

/** DIS motion vectors domain */
typedef enum DisMotionVectorDomain_e
{
    MV_DOMAIN_UNDISTORTED  = 0, /**< Default mode of operation EVA consumes QIS distortion correction grid and then calculates motion vectors */
    MV_DOMAIN_DISTORTED    = 1  /**< EVA motion vectors are calculated in distorted domain. That is, no distortion correction grid
                                  *   is applied in EVA before calculating the motion vectors.
                                  *
                                  *  @note sub-optimal mode of operation, will consume more CPU cycles and could produce
                                  */
} DisMotionVectorDomain ;

/** Face detection domain */
typedef enum FaceDetectionDomain_e
{
    FD_DOMAIN_DISTORTED    = 0, /**< Face properties are calculated in distorted domain, That is, no distortion correction grid
                                 *   is applied before calculating the face properties.
                                 */

    FD_DOMAIN_UNDISTORTED  = 1  /**< Face detection algorithm consumes QIS distortion correction grid and then calculates face properties */
} FaceDetectionDomain;

/** HDR pre alignment flow type */
typedef enum hdr_pre_align_flow_type_e
{
    HDR_PRE_ALIGN_FLOW_NONE                 = 0, /**< No need to consider alignment in EIS calculation - best flow.
                                                  *   Expected to get the pre_eis_transform_margins_reduction as NULL at all times, if non-NULL then it will be ignored
                                                  */
    HDR_PRE_ALIGN_FLOW_ALING_IN_DISTORTED   = 1, /**< HDR alignment is before EIS in distorted domain.
                                                  *   Examples are Kona, Kodiak sHDR SW flow:
                                                  *     Alignment other image to anchor -> distortion correction grid anchor -> stab matrix anchor
                                                  */
    HDR_ALIGN_FLOW_ALING_IN_UNDISTORTED     = 2,  /**< Regular MFHDR flow, EIS works on Long but Short is HDR anchor
                                                   *
                                                   *   ICA Short := UD Grid Short -> align matrix short to long -> Stabilization matrix Long
                                                   *   ICA Long  := UD Grid Long                                -> Stabilization matrix Long
                                                   *
                                                   *   Input pre_eis_transform_margins_reduction := UD Grid Short -> align matrix short to long
                                                   */
} hdr_pre_align_flow_type;

typedef enum LDCCalibDomain_e
{
    DOMAIN_FULL_SENSOR      = 0,
    DOMAIN_IFE_INPUT        = 1, /**< a.k.a DOMAIN_SENSOR_OUTPUT per sensor mode */
    DOMAIN_EIS_INPUT_DZX1   = 2, /**< a.k.a DOMAIN_EIS_INPUT_DZX1.*/
    DOMAIN_IFE_OUTPUT_DZX1  = 2  /**< a.k.a DOMAIN_IFE_OUTPUT_DZX1. Only supported configuration. Need to sample grid by GeoLib to get this. */
} LDCCalibDomain;

/** WindowRegionF - Crop region of interest*/
typedef struct WindowRegionF_s
{
    float    fullWidth;
    float    fullHeight;
    float    windowWidth;
    float    windowHeight;
    float    windowLeft;
    float    windowTop;
} WindowRegionF;

/** Per sensor configuration data structure */
typedef struct is_init_data_sensor_s
{
    /**  @addtogroup    LDC_grids
      *  @brief         Lens Distortion Correction grids from ICA Chromatix
      *                 Must be defined on FOV of EIS Input for zoom X1 (as sampled by GeoLib to that FOV at init).
      *                 FOV dimension: is_input_frame_width X is_input_frame_height
      *
      * @warning        This will be used only in case enable bit in EIS Chromatix lens_distortion_correction struct is set to 1 and ldc_grid_source is set to 1
      *
      *  @{
      */
    const NcLibWarpGrid* ldc_in2out;        /**< input to output lens distortion correction grid */
    const NcLibWarpGrid* ldc_out2in;        /**< output to input lens distortion correction grid */
    LDCCalibDomain       ldc_calib_domain;  /**< 0 = full sensor; 1 = IFE input; 2 = IFE output at digital zoom X1 */

    /** @} */

    WindowRegionF image_sensor_crop;            /**< Sensor crop, output FOV of sensor vs full FOV of sensor */

    uint32_t ife_input_frame_width;                 /**< IFE input frame width  == Sensor output width  */
    uint32_t ife_input_frame_height;                /**< IFE input frame height == Sensor output height */
    uint32_t ife_input_frame_undistorted_width;     /**< IFE input frame width in undistorted domain    */
    uint32_t ife_input_frame_undistorted_height;    /**< IFE input frame height in undistorted domain   */

    uint32_t is_input_frame_width;               /**< EIS input frame width  */
    uint32_t is_input_frame_height;              /**< EIS input frame height */

    uint32_t sensor_mount_angle;            /**< Sensor mount angle (0, 90, 180, 270) */
    CameraPosition camera_position;         /**< Camera position (front, back, etc.) */

    float optical_center_x;                 /**< Lens optical center shift w.r.t. input image origin defined on image center in x-axis direction [pixels of input image] */
    float optical_center_y;                 /**< Lens optical center shift w.r.t. input image origin defined on image center in y-axis direction [pixels of input image] */

    float sensor_width_millimeter;       /**< Sensor dimension in millimeter */
    float sensor_height_millimeter;      /**< Sensor dimension in millimeter */

    is_chromatix_info_t is_chromatix_info;  /**< Chromatix configurations */

} is_init_data_sensor;

/** Common configurations for all sensors data structure */
typedef struct is_init_data_common_s
{
    uint32_t                 is_api_version_major;  /**< EIS algorithm API version as taken from: IS_API_VERSION_MAJOR */
    uint32_t                 is_api_version_minor;  /**< EIS algorithm API version as taken from: IS_API_VERSION_MINOR */
    uint32_t                 is_api_version_step;   /**< EIS algorithm API version as taken from: IS_API_VERSION_STEP */

    cam_is_type_t            is_type;               /**< EIS algorithm version */
    cam_is_operation_mode_t  operation_mode;        /**< EIS operation mode */
    cam_is_deployment_type_t deployment_type;       /**< EIS stabilization transform deployment type.*/
    hdr_pre_align_flow_type  hdr_pre_align_flow;    /**< HDR per alignment flow */

    uint32_t is_output_frame_width;            /**< EIS output frame width after virtual margin upscale */
    uint32_t is_output_frame_height;           /**< EIS output frame height after virtual margin upscale  */

    uint16_t frame_fps;                        /**< Frame rate */

    bool do_virtual_upscale_in_transform;  /**< If true then upscale is done by ICA transform, otherwise by SW chosen up-scaler
                                            *
                                            *   @warning In case this value is true, IQ and performance degradation and could occur.
                                            *
                                            *   @note Flag is relevant only when IS_TYPE_EIS_NFL or IS_TYPE_EIS_NF are defined
                                            */

    bool force_split_grid_matrix;   /**< If true then transform will be separated to un-distortion grid and a single stabilization matrix.
                                     *   Otherwise, un-distortion + stabilization will be done using grid only.
                                     *
                                     *   @warning This value is configurable only in case cam_is_deployment_type_t is supported
                                     *
                                     *   @note If is_sat_enabled is true and cam_is_deployment_type_t supports splitting
                                     *         then this value will be overridden by algorithm to true.
                                     *
                                     *   @note Flag is relevant only when IS_TYPE_EIS_NFL or IS_TYPE_EIS_NF are defined
                                     *
                                     */

    bool unify_undistortion_grid;   /**< If true then the un-distortion grid part will be same between NFL / FL. i.e. not use future data for un-distortion,
                                     *   use true in order to get same un-distortion for future looking and non future looking.
                                     *
                                     *   @warning Since future information is not utilized, distortion correction could be sub-optimal.
                                     *
                                     *   @note flag is relevant only when IS_TYPE_EIS_NFL or IS_TYPE_EIS_NF are defined
                                     */

    bool is_sat_enabled;            /**< If true, sensor alignment transform, SAT will be applied in EIS transform along with
                                     *   EIS transform. EIS output matrices are already combined with SAT matrix on this case.
                                     *   Otherwise it is assumed that there is no SAT in the system.
                                     *
                                     *   @warning In case SAT exists in the system and it is not passed to EIS algorithm, and therefore
                                     *            not merged into EIS transform, IQ / power performance degeneration is expected
                                     *
                                     *   @note Flag is relevant only when IS_TYPE_EIS_NFL or IS_TYPE_EIS_NF are defined
                                     */

    bool is_mag_enabled;               /**< if true, then magnetometer support is enabled. Otherwise disabled */
    bool is_acc_enabled;               /**< if true, then accelerometer support is enabled. Otherwise disabled */
    bool is_ois_enabled;               /**< if true, then OIS support is enabled. Otherwise disabled */
    bool is_ifovc_enabled;             /**< if true, then iFOVC support is enabled. Otherwise disabled */
    bool is_dis_enabled;               /**< if true, then DIS support is enabled. Otherwise disabled */
    bool is_dis_dmm_enabled;           /**< if true, then DIS DMM support is enabled. Otherwise disabled */

    bool is_linear_acc_enabled;        /**< if true, then linear accelerometer support is enabled. Otherwise disabled */
    bool is_abs_orientation_enabled;   /**< if true, then absolute orientation support is enabled. Otherwise disabled */
    bool is_rel_orientation_enabled;   /**< if true, then relative orientation support is enabled. Otherwise disabled */
    bool is_gravity_vector_enabled;    /**< if true, then Gravity vector support is enabled. Otherwise disabled */

    bool is_face_detection_enabled;    /**< if true, then face detection support is enabled. Otherwise disabled */
    bool is_facial_landmarks_enabled;  /**< if true, then facial landmarks support is enabled. Otherwise disabled */

    bool is_early_crop_enabled;         /**< if true, then early crop is supported */
    bool is_snapshot_stabilization_enabled;    /**< if true, then EISv2 snapshot stabilization support is enabled. Otherwise disabled */

    /*          EIS 2.x specific configurations             */

    /*          EIS 3.x specific configurations             */
    uint16_t                buffer_delay;       /**< For EIS3 future looking only */
    DisMotionVectorDomain   dis_mv_domain;      /**< DIS motion vectors domain */

    float    init_common_reserve[16];

} is_init_data_common;

typedef struct eis_roi_windows_s
{
    WindowRegionF        image_sensor_crop; /**< Sensor crop, output FOV of sensor vs full FOV of sensor */

    WindowRegionF        eis_pre_crop_vIN;  /**< eis_pre_crop window at vIN. Relative to IFE input size and FOV, i.e.
                                             *   This is the actual crop window done in IFE for DSX
                                             *    - fullWidth,   fullHeight   == IFE input size
                                             *    - windowWidth, windowHeight == pre crop size (actual)
                                             *    - windowLeft,  windowTop    == pre crop left, top (actual)
                                             *
                                             * for Inline EIS      : eis_pre_crop == ife_crop_dsx                (at_CSID_out)
                                             * for postIPE/OPE EIS : eis_pre_crop == ife_crop_dsx * ipe_crop     (at_CSID_out)
                                             *
                                             * crop FOV of the DSX not full.
                                             * == DSX FOV vs IFE input FOV
                                             *
                                             * In case of EIS Post IPE/OPE: we fill here the total crop done prior to EIS.
                                             */


    WindowRegionF        eis_pre_crop_vOUT;  /**< eis_pre_crop window at vOUT.
                                              *   Same window as eis_pre_crop_vIN but in UnDistorted Domain (after LDC)
                                              */

    // output_crop_fov == dzFOV_vOUT  relative to eis_pre_digital_zoom_at_vOUT
    // output_crop_fov is ICA output ROI vs Virtual domain out ROI ???
    // todo(kona) : change description....
    WindowRegionF        output_crop_fov;       /* crop ROI that ICA/GPU is actually doing
                                                * ?????? This is the ICA output FOV with regard to its input FOV.
                                                * Its the total crop ICA is doing.
                                                * The FOV reduction is : physical + virtual margins + IPE DZ + FOVC + any other crop in ICA.
                                                * This could include a changing margins.
                                                *
                                                *    - fullWidth,   fullHeight   == EIS Input size (ICA1  input for inline / GPU input for post)
                                                *    - windowWidth, windowHeight == ICA1 output size
                                                *    - windowLeft,  windowTop    == ICA1 output crop left, top
                                                */
} eis_roi_windows;

#ifndef IS_MAX_FACE_ROIS
#define   IS_MAX_FACE_ROIS      10   ///< Maximum index for face ROIs.
#endif /* IS_MAX_FACE_ROIS */

/// @brief Contains the ROI rectangle dimensions.
typedef struct IsRectangleCoordinate_s
{
    uint32_t    left;      ///< X coordinate of the rectangle.
    uint32_t    top;       ///< Y coordinate of the rectangle.
    uint32_t    width;     ///< Width of the rectangle.
    uint32_t    height;    ///< Height of the rectangle.
} IsRectangleCoordinate;

/// @brief Contains face ROI data. This structure is used with #IsFaceROIInformation.
typedef struct IsFaceROIData_s
{
    uint32_t                    id;           ///< ID used to track a face in a scene.
    uint32_t                    confidence;   ///< Confidence of this face.
    IsRectangleCoordinate       faceRect;     ///< Detected face rectangle.
    int32_t                     rollAngle;    ///< Roll angle of the face.
    int32_t                     pose;         ///< Pose angle of the face.
    int32_t                     pitch;        ///< Pitch angle of the face.
                                                ///  @newpagetable
} IsFaceROIData;

/// @brief Contains Face ROI information.
typedef struct IsFaceROIInformation_s
{
    uint64_t                    requestId;                          ///< Identifier for the processed frame request.
    uint64_t                    frameNumber;                        ///< Identifier for the processed frame.
    uint32_t                    ROICount;                           ///< Total number of ROIs.
    IsFaceROIData               unstabilizedROI[IS_MAX_FACE_ROIS];  ///< Array of unstabilized face ROI data.
    IsFaceROIData               stabilizedROI[IS_MAX_FACE_ROIS];    ///< Array of stabilized face ROI data.
} IsFaceROIInformation;

/// @brief Represents a pixel.
typedef struct IsCHIPoint_s
{
    int32_t   x;  ///< X coordinate of the point.
    int32_t   y;  ///< Y coordinate of the point.
} IsCHIPoint;

#ifndef IS_FD_MAX_FACE_COUNT
#define IS_FD_MAX_FACE_COUNT            10      ///< Maximum number of faces that the FD solution can detect.
#endif /* IS_FD_MAX_FACE_COUNT  */

#ifndef IS_FD_CONTOUR_MAX_NUM_FACES
#define IS_FD_CONTOUR_MAX_NUM_FACES     5
#endif /* IS_FD_CONTOUR_MAX_NUM_FACES */

#ifndef IS_FD_CONTOUR_MAX_PER_FACE
#define IS_FD_CONTOUR_MAX_PER_FACE      300
#endif /* IS_FD_CONTOUR_MAX_PER_FACE */

#ifndef IS_FD_CONTOUR_POINT_MAX
#define IS_FD_CONTOUR_POINT_MAX         (IS_FD_CONTOUR_MAX_NUM_FACES * IS_FD_CONTOUR_MAX_PER_FACE) /**< max 300 contour points per face and maximal of 5 faces per frame */
#endif /* IS_FD_CONTOUR_POINT_MAX */

/// @brief Structure Facial Contour results with version number for backward compatibility
///        Counterpart of FDMetaDataVersionedFaceContourResults for CamX and FD internal use
typedef struct IsFDFaceContourResults_s
{
    int32_t             status;                             /**< Status of facial contour result.
                                                             *      0: Result of FD contour detection is successful.
                                                             *      1: Result of FD contour detection is an unspecified error.
                                                             *      2: Result of FD contour detection version is not supported.
                                                             */

    int32_t             version;                            /**< Version number of the facial contour point definition, valid values are: 0,1,2,3 */
    int32_t             numPointsPerFace;                   /**< Number of contour points per face */
    uint32_t            numFaces;                           /**< Number of faces with contour info */
    int32_t             reserved[4];                        /**< Reserved fields */
    int32_t             faceID[IS_FD_MAX_FACE_COUNT];       /**< Array of face IDs of face contours. same as fameId in IsFaceROIData::id */
    IsCHIPoint          points[IS_FD_CONTOUR_POINT_MAX];    /**< Array of contour points */
} IsFDFaceContourResults;

#ifndef IS_UD_GRID_META_DATA_SZ
#define IS_UD_GRID_META_DATA_SZ     64
#endif /* !IS_UD_GRID_META_DATA_SZ */

typedef struct is_input_distortion_correction_grid_meta_data_t
{
    uint32_t            header[4];          /**< Packet header */

    eis_roi_windows     window_regions;     /**< If ROIs are not matching we have to recalculate the grid */
    uint64_t            last_gyro_ts;       /**< If gyro samples are not the same almost surely we have to recalculate the grid as well */
    uint64_t            last_ois_ts;        /**< If OIS samples are not the same almost surely we have to recalculate the grid as well */
    uint64_t            last_ifovc_ts;      /**< If iFOVC samples are not the same almost surely we have to recalculate the grid as well */

    uint32_t            reserverd[26];      /**< Reserved parameters */

    uint32_t            footer[4];          /**< Packet footer */
}distortion_correction_grid_meta_data;

/** IS input data structure for distortion correction grid optimization */
typedef struct distortion_correction_grid_meta_data_s
{
    NcLibWarpGrid*                          distortion_correction_grid; /**< Distortion correction grid as in is_output_distortion_correction_t */
    distortion_correction_grid_meta_data    meta_data;                  /**< meta data as in is_output_distortion_correction_t */
} is_input_distortion_correction_grid;

typedef struct face_detection_inputs_data_s
{
    const IsFaceROIInformation* face_detection;         /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                         *   Contains the face detection rectangle parameters
                                                         */

    uint32_t        face_detection_defined_on_width;    /**< Input image width on which face detection were calculated */
    uint32_t        face_detection_defined_on_height;   /**< Input image height on which face detection were calculated */
    uint32_t        face_detection_active_sensor_idx;   /**< Input image active sensor index on which face detection were calculated */
    uint32_t        face_detection_size_byte;           /**< Face detection buffer size in bytes */
} face_detection_inputs_data;

typedef struct face_landmarks_inputs_data_s
{
    const IsFDFaceContourResults*   face_landmarks;     /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                         *   Contains the face landmark parameters
                                                         */

    uint64_t                        requestId;                          /**< Identifier for the processed frame request */
    uint32_t                        face_landmarks_defined_on_width;    /**< Input image width on which face landmarks were calculated */
    uint32_t                        face_landmarks_defined_on_height;   /**< Input image height on which face landmarks were calculated */
    uint32_t                        face_landmarks_active_sensor_idx;   /**< Input image active sensor index on which face landmarks were calculated */
    uint32_t                        face_landmarks_size_byte;           /**< Face landmarks buffer size in bytes */
} face_landmarks_inputs_data;

/* IS input data structure for eis2_process() */
typedef struct is_input_s
{
    uint32_t                frame_id;               /**< Frame ID */
    uint32_t                active_sensor_idx;      /**< Active sensor index */

    frame_times_t           frame_times;            /**< Frame time */

    gyro_data_t             gyro_data;              /**< Gyro data */
    mag_data_t              mag_data;               /**< Magnetometer data */
    acc_data_t              acc_data;               /**< Accelerometer data */
    ois_data_t              ois_data;               /**< OIS data */
    ifovc_data_t            ifovc_data;             /**< iFOVC data : ts, data[4] = {z_lens_pos, ifovc_correction_factor, 0, 0} */

    linear_acc_data_t       linear_acc_data;        /**< Linear Accelerometer data */
    abs_orientation_data_t  abs_orientation_data;   /**< Absolute orientation data */
    rel_orientation_data_t  rel_orientation_data;   /**< Relative orientation data */

    gravity_vector_data_t   gravity_vector_data;    /**< Gravity vector data */

    face_detection_inputs_data  face_detection_data;    /**< Face detection data */
    face_landmarks_inputs_data  face_landmarks_data;    /**< Face landmarks data */

    eis_roi_windows         window_regions;         /**< Input and Output ROI's */

    float                   focus_distance;         /**< Focus distance in Diopter. Distance from object on which focus is locked on */

    float                   effective_focal_length_mm;  /**< Effective focal length in millimeter */

    uint32_t                recording_state;            /**< Recording state as seen by CamX */

    const NcLibWarp*        sat;                    /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                     *
                                                     * - Order of matrices operators from in->out is first SAT and then EIS.
                                                     * - In order to align current sensor to previous sensor,
                                                     *   use SAT matrix which is OUT2IN, thus the matrix direction is from
                                                     *   previous sensor geometry to current sensor geometry.
                                                     * - SAT transform shall be defined on resolution of input to EIS.
                                                     * - SAT transform shall define center of image as origin (0,0).
                                                     */

    const NcLibWarp*        pre_eis_transform_margins_reduction; /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                                  *
                                                                  *   Used for HDR pre alignment in HDR SW flow.
                                                                  *   This represent transform applied on image before EIS,
                                                                  *   EIS need to consider this in order not to breach.
                                                                  *
                                                                  *   @warning  This reduces EIS margins dynamically.
                                                                  *
                                                                  *   @warning  Transform must be defined on virtual domain, otherwise conversion will be
                                                                  *             done internally which can consume many CPU cycles.
                                                                  *             To convert to virtual domain use the following API: NcLibWarpConvertToVirtualDomain()
                                                                  */

    is_input_distortion_correction_grid*  distortion_correction_grid;   /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                                         *
                                                                         *   Used for runtime optimization, GME node will calculate distortion correction grid and meta data by eis3_process_distortion_correction() API.
                                                                         *   Same data will be passed by CamX to eis3_process_distortion_correction(), in EISv3 CamX node.
                                                                         *
                                                                         *   @warning  In case struct values will not be as expected, distortion correction grid will be re-calculated internally again.
                                                                         *
                                                                         */

    float                   input_dist_corr_reserve[16];
    float                   input_stabilize_reserve[16];
} is_input_t;

/* IS input data structure for eis2_snapshot_stabilize_to_target() */
typedef struct is_input_snapshot_stabilize_s
{
    uint32_t                frame_id;                   /**< Frame ID of the snapshot frame to Stabilize */
    uint32_t                active_sensor_idx;          /**< Active sensor index of that frame ID*/

    uint32_t                input_frame_width;          /**< Snapshot stabilization input frame width  */
    uint32_t                input_frame_height;         /**< Snapshot stabilization input frame height */

    eis_roi_windows         window_regions_snapshot;    /**< Input and Output ROI's of the snapshot.
                                                         *
                                                         *   @note In some cases snapshot (window_regions_snapshot) and video (is_input_t.window_regions) values might be different.
                                                         */
} is_input_snapshot_stabilize_t;

/** IS input data structure for eis3_process_distortion_correction() */
typedef struct is_input_distortion_correction_s
{
    uint32_t                frame_id;                   /**< Frame ID */
    uint32_t                active_sensor_idx;          /**< Active sensor index */
    frame_times_t           frame_times;                /**< Frame times */

    gyro_data_t             gyro_data;                  /**< Gyro data */
    mag_data_t              mag_data;                   /**< Magnetometer data */
    acc_data_t              acc_data;                   /**< Accelerometer data */
    ois_data_t              ois_data;                   /**< OIS data */
    ifovc_data_t            ifovc_data;                 /**< iFOVC data : ts, data[4] = {z_lens_pos, ifovc_correction_factor, 0, 0} */

    linear_acc_data_t       linear_acc_data;            /**< Linear Accelerometer data */
    abs_orientation_data_t  abs_orientation_data;       /**< Absolute orientation data */
    rel_orientation_data_t  rel_orientation_data;       /**< Relative orientation data */

    gravity_vector_data_t   gravity_vector_data;        /**< Gravity vector data */

    face_detection_inputs_data  face_detection_data;    /**< Face detection data */
    face_landmarks_inputs_data  face_landmarks_data;    /**< Face landmarks data */

    eis_roi_windows         window_regions;             /**< Input and Output ROI's */

    float                   focus_distance;             /**< Focus distance in meters. Distance from object on which focus is locked on */

    float                   effective_focal_length_mm;  /**< Effective focal length in millimeter */

    uint32_t                recording_state;            /**< Recording state as seen by CamX */

    const NcLibWarp*        pre_eis_transform_margins_reduction; /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                                  *
                                                                  *   Used for HDR pre alignment in HDR SW flow.
                                                                  *   This represent transform applied on image before EIS,
                                                                  *   EIS need to consider this in order not to breach.
                                                                  *
                                                                  *   @warning  This reduces EIS margins dynamically.
                                                                  *
                                                                  *   @warning  Transform must be defined on virtual domain, otherwise conversion will be
                                                                  *             done internally which can consume many CPU cycles.
                                                                  *             To convert to virtual domain use the following API: NcLibWarpConvertToVirtualDomain()
                                                                  */

    is_input_distortion_correction_grid*  distortion_correction_grid;   /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                                         *
                                                                         *   Used for runtime optimization, GME node will calculate distortion correction grid and meta data by eis3_process_distortion_correction() API.
                                                                         *   Same data will be passed by CamX to eis3_process_distortion_correction(), in EISv3 CamX node.
                                                                         *
                                                                         *   @warning  In case struct values will not be as expected, distortion correction grid will be re-calculated internally again.
                                                                         *
                                                                         */

    float                   input_dist_corr_reserve[16];

} is_input_distortion_correction_t;

/** IS input data structure for motion vectors */
typedef struct is_input_dis_s
{
    NcLibWarpMatrices       alignment_matrix;                   /**< CVP alignment matrix between current and previous frame before fusion with gyro (DME based only) , output matrix of DME RANSAC*/
    NcLibWarpMatrices       alignment_gmv_matrix;               /**< CVP alignment matrix between current and previous frame after fusion with gyro. output of EVA fusion, input to DMM */
// todo: do we need both matrices or only after fusion
// todo: check with roee if image sizes are always same between dme and dmm

    uint32_t                motion_vectors_input_image_width;   /**< Input image width on which motion vectors were calculated */
    uint32_t                motion_vectors_input_image_height;  /**< Input image height on which motion vectors were calculated */

    uint32_t                motion_vectors_buff_size_byte;      /**< Motion vectors buffer size in bytes */
    const void*             motion_vectors;                     /**< Motion vectors used for DIS */

    uint32_t                dense_motion_map_buff_size_byte;    /**< DMM buffer size in bytes */
    const void*             dense_motion_map;                   /**< DMM buffer */
} is_input_dis_t;

// todo:
// check with david if we need to just add the dmm data inside lahaina void* and just add under eis_internal_CVP_header.h
// or if we need to add some more daa here

/** IS input data structure for eis3_process_stabilize() */
typedef struct is_input_stabilize_s
{
    uint32_t                frame_id;               /**< Frame ID */
    uint32_t                active_sensor_idx;      /**< Active sensor index */
    frame_times_t           frame_times;            /**< Frame times */

    const NcLibWarp*        sat;                    /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                     *
                                                     * - Order of matrices operators from in->out is first SAT and then EIS.
                                                     * - In order to align current sensor to previous sensor,
                                                     *   use SAT matrix which is OUT2IN, thus the matrix direction is from
                                                     *   previous sensor geometry to current sensor geometry.
                                                     * - SAT transform shall be defined on resolution of input to EIS.
                                                     * - SAT transform shall define center of image as origin (0,0).
                                                     */

    is_input_dis_t*         dis_motion_vectors;     /**< Optional - if equal to NULL then EIS disregards this parameter.
                                                     *
                                                     *   @warning   If algorithm was initialized with is_dis_enabled flag enabled,
                                                     *              this value cannot be NULL. Otherwise value is ignored.
                                                     */

    uint32_t                recording_state;        /**< Recording state as seen by CamX */

    float                   input_stabilize_reserve[16];

} is_input_stabilize_t;

/** IS output data structure, outputted by eis2_process() */
typedef struct is_output_s
{
    uint32_t            frame_id;                   /**< Processed frame index  */
    uint32_t            active_sensor_idx;          /**< Active sensor index, synced with frame_id */

    NcLibWarpGrid       distortion_correction_grid; /**< distortion_correction Grid transform, synced with frame_id */

    NcLibWarp           stabilization_transform;    /**< Stabilization transform, as passed to NcLib.
                                                     *   Transforms are synced with frame_id.
                                                     *   Structure contains stabilization matrix and DIS grid in OUT_2_IN
                                                     */

    NcLibWarpMatrices   alignment_matrix_domain_undistorted;    /**< Undistorted frame alignment matrix using gyro instead of
                                                                 *   CVP/LRME, a matrix between "undistorted current" domain to "undistorted previous" domain.
                                                                 *   Transforms are synced with frame_id.
                                                                 */

    NcLibWarpMatrices   alignment_matrix_domain_stabilized;     /**< Stabilized frame alignment matrix using gyro target, a final
                                                                 *   matrix for MCTF matrix between "stabilized current" domain to "stabilized previous" domain.
                                                                 *   Transforms are synced with frame_id.
                                                                 */

    float               Mind_margins_blender_geolib;            /**< blender between maximal and minimal margins for GeoLib
                                                                 *   0 is minimal margins (== only physical margins); 1 is maximal margins (== total margins including virtual and maybe more in case of zoom).
                                                                 *   TODO (rgaizman): set this to 1 for calibration mode so we wont get unwanted VSR/IFE zoom.
                                                                 */

    float               cvp_motion_index_raw;                   /**< Amount of movement from previous frame to current frame in undistorted domain. units are in image pixels */

    cam_is_ois_mode     ois_mode;                               /**< When OIS is active in system, this will contain recommended OIS operation mode. Otherwise will contain an invalid output */

    scene_detection_t   scene_detection;                        /**< Contains the scene detection as calculated by EIS algorithm. Output is synced with frame_id */

    float               output_dist_corr_reserve[16];
    float               output_stabilize_reserve[16];

    bool                has_output;                             /**< if true, a frame was processed. Otherwise frame was not processed */
} is_output_t;

/** IS output data structure, outputted by eis2_process() */
typedef struct is_output_snapshot_stabilize_s
{
    uint32_t            frame_id;                   /**< Processed frame index  */
    uint32_t            active_sensor_idx;          /**< Active sensor index, synced with frame_id */

    NcLibWarpGrid       distortion_correction_grid; /**< distortion_correction Grid transform, synced with frame_id */

    NcLibWarp           stabilization_transform;    /**< Stabilization transform, as passed to NcLib.
                                                     *   Transforms are synced with frame_id.
                                                     *   Structure contains stabilization matrix and DIS grid in OUT_2_IN
                                                     */

    uint64_t            mof_gyro_time;              /**< Middle of frame (MOF) time in gyro timing axis
                                                     *   Will be used to feed two times to any QIS instance to get alignment between those times
                                                     *   in eis3_get_device_rotation_delta()
                                                     */

    bool                has_output;                             /**< if true, a frame was processed. Otherwise frame was not processed */
} is_output_snapshot_stabilize_t;

#define is_output_type is_output_t  /** @deprecated kept for backwards compatibility, will be removed in next release. Use is_output_t instead */

/** Maximal number of points in polygon_undistorted */
#define IS_POLYGON_MAX_SIZE (32)

/** IS output data structure for depth processing  */
typedef struct is_output_depth_post_processing_s
{
    uint32_t            polygon_undistorted_num_of_points;          /**< Polygon number of used points, bounded by is_polygon_max_size */
    NcLibWarpGridCoord  polygon_undistorted[IS_POLYGON_MAX_SIZE];   /**< Polygon of valid image in undistorted domain
                                                                     *    Start with top left point (from distorted domain) and go clockwise
                                                                     *    Points origin [0,0] is top left pixel of the distorted image
                                                                     *    Bottom right pixels is pointsDefinedOnSize
                                                                     */

    NcLibImageSize      polygon_defined_on;                         /**< Polygon points defined on dimension */

} is_output_depth_post_processing_t;

/** IS output data structure of eis3_process_distortion_correction() */
typedef struct is_output_distortion_correction_s
{
    uint32_t            frame_id;                               /**< Processed frame index  */
    uint32_t            active_sensor_idx;                      /**< Active sensor index, synced with frame_id */

    NcLibWarpGrid       distortion_correction_grid;             /**< distortion_correction Grid transform, synced with frame_id */

    NcLibWarpMatrices   alignment_matrix_domain_undistorted;    /**< Undistorted frame alignment matrix using gyro instead of
                                                                 *   CVP/LRME, a matrix between "undistorted current" domain to "undistorted previous" domain.
                                                                 *   Transforms are synced with frame_id.
                                                                 */

    uint64_t            mof_gyro_time;                          /**< Middle of frame (MOF) time in gyro timing axis
                                                                 *   Will be used to feed two times to any QIS instance to get alignment between those times
                                                                 *   in eis3_get_device_rotation_delta()
                                                                 */

    is_output_depth_post_processing_t   depth_valid_polygon;    /**< Depth post processing output struct */

    float               Mind_margins_blender_geolib;            /**< blender between maximal and minimal margins for GeoLib
                                                                 *   0 is minimal margins (== only physical margins); 1 is maximal margins (== total margins including virtual and maybe more in case of zoom).
                                                                 *   TODO (rgaizman): set this to 1 for calibration mode so we wont get unwanted VSR/IFE zoom.
                                                                 */

    float               cvp_motion_index_raw;                   /**< Amount of movement from previous frame to current frame in undistorted domain. units are in image pixels */

    cam_is_ois_mode     ois_mode;                               /**< When OIS is active, this will contain recommended OIS operation mode. Otherwise will contain an invalid output */

    scene_detection_t   scene_detection;                        /**< Contains the scene detection as calculated by EIS algorithm. Output is synced with frame_id */

    distortion_correction_grid_meta_data            distortion_correction_grid_meta_data; /**< meta data as is_output_distortion_correction_t */

    float               output_dist_corr_reserve[16];

    bool                has_output;                             /**< if true, a frame was processed. Otherwise frame was not processed */
} is_output_distortion_correction_t;

/** IS output data structure of eis3_process_stabilize() */
typedef struct is_output_stabilize_s
{
    uint32_t            frame_id;                               /**< Processed frame index  */
    uint32_t            active_sensor_idx;                      /**< Active sensor index, synced with frame_id */

    NcLibWarpGrid       distortion_correction_grid;             /**< distortion_correction Grid transform, synced with frame_id */

    NcLibWarp           stabilization_transform;                /**< Stabilization transform, as passed to NcLib.
                                                                 *   Transforms are synced with frame_id
                                                                 *
                                                                 *   stabilization matrix and DIS grid transforms domain: OUT_2_IN
                                                                 */

    NcLibWarpMatrices   alignment_matrix_domain_undistorted;    /**< Undistorted frame alignment matrix using gyro instead of
                                                                 *   CVP/LRME, a matrix between "undistorted current" domain to "undistorted previous" domain.
                                                                 *   Transforms are synced with frame_id.
                                                                 */

    NcLibWarpMatrices   alignment_matrix_domain_stabilized;     /**< Stabilized frame alignment matrix using gyro target, a final
                                                                 *   matrix for MCTF matrix between "stabilized current" domain to "stabilized previous" domain.
                                                                 *   Transforms are synced with frame_id.
                                                                 */

    scene_detection_t   scene_detection;                        /**< Contains the scene detection as calculated by EIS algorithm. Output is synced with frame_id */

    bool                was_distortion_correction_grid_recalculated; /**< In case values is different from 0 then distortion correction grid was recalculated
                                                                      *   and is different from then one that was produced in distortion correction part
                                                                      */

    float               output_stabilize_reserve[16];

    bool                has_output;                             /**< if true, a frame was processed. Otherwise frame was not processed */
} is_output_stabilize_t;

/** IS get stabilization margin input struct. Used by eis3_get_stabilization_margin_ex() */
typedef struct is_get_stabilization_margin_s
{
    uint32_t common_is_output_frame_height;             /**< Output frame height - Common to all sensors */
    uint32_t common_is_output_frame_width;              /**< Output frame width - Common to all sensors */
    bool     common_do_virtual_upscale_in_transform;    /**< If true then upscale is done using transform. Common to all sensors */

    uint32_t sensor_is_input_frame_height;              /**< Sensor input frame height */
    uint32_t sensor_is_input_frame_width;               /**< Sensor input frame width */

    float    sensor_requested_total_margin_x;           /**< Minimal total margins as supplied to chromatix struct */
    float    sensor_requested_total_margin_y;           /**< Minimal total margins as supplied to chromatix struct */

    float    sensor_minimal_total_margin_x;             /**< Minimal total margins as supplied to chromatix struct */
    float    sensor_minimal_total_margin_y;             /**< Minimal total margins as supplied to chromatix struct */
} is_get_stabilization_margin;

#ifdef __cplusplus
}
#endif

#endif /* _IS_INTERFACE_H_ */
