diff --git a/xcore/aiq_handler.cpp b/xcore/aiq_handler.cpp
index dc3ec7a..50b8309 100644
--- a/xcore/aiq_handler.cpp
+++ b/xcore/aiq_handler.cpp
@@ -445,8 +445,8 @@
 
 bool AiqAeHandler::ensure_ae_manual ()
 {
-    _input.manual_exposure_time_us = this->_manual_exposure_time;
-    _input.manual_analog_gain = this->_manual_analog_gain;
+    _input.manual_exposure_time_us = get_manual_exposure_time_unlock ();
+    _input.manual_analog_gain = get_manual_analog_gain_unlock ();
     return true;
 }
 
@@ -582,11 +582,12 @@
 AiqAeHandler::adjust_ae_limitation (ia_aiq_exposure_sensor_parameters &cur_res)
 {
     ia_aiq_exposure_sensor_descriptor * desc = &_sensor_descriptor;
-    uint64_t exposure_min = this->_exposure_time_min;
-    uint64_t exposure_max = this->_exposure_time_max;
-    double analog_max = this->_max_analog_gain;
+    uint64_t exposure_min = 0, exposure_max = 0;
+    double analog_max = get_max_analog_gain_unlock ();
     uint32_t min_coarse_value = 0, max_coarse_value = 0;
 
+    get_exposure_time_range_unlock (exposure_min, exposure_max);
+
     if (exposure_min) {
         min_coarse_value =  _time_to_coarse_line (desc, exposure_min);
         if (min_coarse_value < desc->coarse_integration_time_min)
@@ -713,15 +714,18 @@
     case XCAM_AWB_MODE_AUTO:
         _input.scene_mode = ia_aiq_awb_operation_mode_auto;
         break;
-    case XCAM_AWB_MODE_MANUAL:
-        if (this->_cct_min && this->_cct_max) {
+    case XCAM_AWB_MODE_MANUAL: {
+        uint32_t cct_min = 0, cct_max = 0;
+        get_cct_range_unlock (cct_min, cct_max);
+        if (cct_min  && cct_max) {
             _input.scene_mode = ia_aiq_awb_operation_mode_manual_cct_range;
-            _cct_range.max_cct = this->_cct_max;
-            _cct_range.min_cct = this->_cct_min;
+            _cct_range.max_cct = cct_min;
+            _cct_range.min_cct = cct_max;
             _input.manual_cct_range = &_cct_range;
         } else
             _input.scene_mode = ia_aiq_awb_operation_mode_auto;
         break;
+    }
     case XCAM_AWB_MODE_DAYLIGHT:
         _input.scene_mode = ia_aiq_awb_operation_mode_daylight;
         break;
diff --git a/xcore/aiq_handler.h b/xcore/aiq_handler.h
index 3920daa..3ee70fc 100644
--- a/xcore/aiq_handler.h
+++ b/xcore/aiq_handler.h
@@ -202,6 +202,7 @@
 class AiqCommonHandler
     : public CommonHandler
 {
+    friend class AiqCompositor;
 public:
     explicit AiqCommonHandler (SmartPtr<AiqCompositor> &aiq_compositor);
     ~AiqCommonHandler () {}
diff --git a/xcore/handler_interface.cpp b/xcore/handler_interface.cpp
index 6fdf586..09da323 100644
--- a/xcore/handler_interface.cpp
+++ b/xcore/handler_interface.cpp
@@ -23,31 +23,40 @@
 namespace XCam {
 
 AeHandler::AeHandler()
-    : _mode (XCAM_AE_MODE_AUTO)
-    , _metering_mode ()
-    , _window ()
-    , _flicker_mode ()
-    , _speed (1.0)
-    , _exposure_time_min (UINT64_C(0))
-    , _exposure_time_max (UINT64_C(0))
-    , _max_analog_gain (0.0)
-    , _manual_exposure_time (UINT64_C (0))
-    , _manual_analog_gain (0.0)
-    , _aperture_fn (0.0)
-    , _ev_shift (0.0)
 {
-    _window.x_start = 0;
-    _window.y_start = 0;
-    _window.x_end = 0;
-    _window.y_end = 0;
-    _window.weight = 0;
+    reset_parameters ();
+}
+
+void
+AeHandler::reset_parameters ()
+{
+    // in case missing any parameters
+    xcam_mem_clear (&_params);
+
+    _params.mode = XCAM_AE_MODE_AUTO;
+    _params.metering_mode = XCAM_AE_METERING_MODE_AUTO;
+    _params.flicker_mode = XCAM_AE_FLICKER_MODE_AUTO;
+    _params.speed = 1.0;
+    _params.exposure_time_min = UINT64_C(0);
+    _params.exposure_time_max = UINT64_C(0);
+    _params.max_analog_gain = 0.0;
+    _params.manual_exposure_time = UINT64_C (0);
+    _params.manual_analog_gain = 0.0;
+    _params.aperture_fn = 0.0;
+    _params.ev_shift = 0.0;
+
+    _params.window.x_start = 0;
+    _params.window.y_start = 0;
+    _params.window.x_end = 0;
+    _params.window.y_end = 0;
+    _params.window.weight = 0;
 }
 
 bool
 AeHandler::set_mode (XCamAeMode mode)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _mode = mode;
+    _params.mode = mode;
 
     XCAM_LOG_DEBUG ("ae set mode [%d]", mode);
     return true;
@@ -57,7 +66,7 @@
 AeHandler::set_metering_mode (XCamAeMeteringMode mode)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _metering_mode = mode;
+    _params.metering_mode = mode;
 
     XCAM_LOG_DEBUG ("ae set metering mode [%d]", mode);
     return true;
@@ -67,7 +76,7 @@
 AeHandler::set_window (XCam3AWindow *window)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _window = *window;
+    _params.window = *window;
 
     XCAM_LOG_DEBUG ("ae set metering mode window [x:%d, y:%d, x_end:%d, y_end:%d, weight:%d]",
                     window->x_start,
@@ -82,7 +91,7 @@
 AeHandler::set_ev_shift (double ev_shift)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _ev_shift = ev_shift;
+    _params.ev_shift = ev_shift;
 
     XCAM_LOG_DEBUG ("ae set ev shift:%.03f", ev_shift);
     return true;
@@ -92,7 +101,7 @@
 AeHandler::set_speed (double speed)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _speed = speed;
+    _params.speed = speed;
 
     XCAM_LOG_DEBUG ("ae set speed:%.03f", speed);
     return true;
@@ -102,7 +111,7 @@
 AeHandler::set_flicker_mode (XCamFlickerMode flicker)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _flicker_mode = flicker;
+    _params.flicker_mode = flicker;
 
     XCAM_LOG_DEBUG ("ae set flicker:%d", flicker);
     return true;
@@ -112,15 +121,15 @@
 AeHandler::get_flicker_mode ()
 {
     AnalyzerHandler::HanlderLock lock(this);
-    return _flicker_mode;
+    return _params.flicker_mode;
 }
 
 int64_t
 AeHandler::get_current_exposure_time ()
 {
     AnalyzerHandler::HanlderLock lock(this);
-    if (_mode == XCAM_AE_MODE_MANUAL)
-        return _manual_exposure_time;
+    if (_params.mode == XCAM_AE_MODE_MANUAL)
+        return _params.manual_exposure_time;
     return INT64_C(-1);
 }
 
@@ -128,8 +137,8 @@
 AeHandler::get_current_analog_gain ()
 {
     AnalyzerHandler::HanlderLock lock(this);
-    if (_mode == XCAM_AE_MODE_MANUAL)
-        return _manual_analog_gain;
+    if (_params.mode == XCAM_AE_MODE_MANUAL)
+        return _params.manual_analog_gain;
     return 0.0;
 }
 
@@ -137,7 +146,7 @@
 AeHandler::set_manual_exposure_time (int64_t time_in_us)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _manual_exposure_time = time_in_us;
+    _params.manual_exposure_time = time_in_us;
 
     XCAM_LOG_DEBUG ("ae set manual exposure time: %lldus", time_in_us);
     return true;
@@ -147,7 +156,7 @@
 AeHandler::set_manual_analog_gain (double gain)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _manual_analog_gain = gain;
+    _params.manual_analog_gain = gain;
 
     XCAM_LOG_DEBUG ("ae set manual analog gain: %.03f", gain);
     return true;
@@ -157,7 +166,7 @@
 AeHandler::set_aperture (double fn)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _aperture_fn = fn;
+    _params.aperture_fn = fn;
 
     XCAM_LOG_DEBUG ("ae set aperture fn: %.03f", fn);
     return true;
@@ -167,7 +176,7 @@
 AeHandler::set_max_analog_gain (double max_gain)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _max_analog_gain = max_gain;
+    _params.max_analog_gain = max_gain;
 
     XCAM_LOG_DEBUG ("ae set max analog_gain: %.03f", max_gain);
     return true;
@@ -176,14 +185,14 @@
 double AeHandler::get_max_analog_gain ()
 {
     AnalyzerHandler::HanlderLock lock(this);
-    return _max_analog_gain;
+    return _params.max_analog_gain;
 }
 
 bool AeHandler::set_exposure_time_range (int64_t min_time_in_us, int64_t max_time_in_us)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _exposure_time_min = min_time_in_us;
-    _exposure_time_max = max_time_in_us;
+    _params.exposure_time_min = min_time_in_us;
+    _params.exposure_time_max = max_time_in_us;
 
     XCAM_LOG_DEBUG ("ae set exposrue range[%lldus, %lldus]", min_time_in_us, max_time_in_us);
     return true;
@@ -195,28 +204,42 @@
     XCAM_ASSERT (min_time_in_us && max_time_in_us);
 
     AnalyzerHandler::HanlderLock lock(this);
-    *min_time_in_us = _exposure_time_min;
-    *max_time_in_us = _exposure_time_max;
+    *min_time_in_us = _params.exposure_time_min;
+    *max_time_in_us = _params.exposure_time_max;
 
     return true;
 }
 
 AwbHandler::AwbHandler()
-    : _mode (XCAM_AWB_MODE_AUTO)
-    , _speed (1.0)
-    , _cct_min (0)
-    , _cct_max (0)
-    , _gr_gain (0.0)
-    , _r_gain (0.0)
-    , _b_gain (0.0)
-    , _gb_gain (0.0)
-{}
+{
+    reset_parameters ();
+}
+
+void
+AwbHandler::reset_parameters ()
+{
+    xcam_mem_clear (&_params);
+    _params.mode = XCAM_AWB_MODE_AUTO;
+    _params.speed = 1.0;
+    _params.cct_min = 0;
+    _params.cct_max = 0;
+    _params.gr_gain = 0.0;
+    _params.r_gain = 0.0;
+    _params.b_gain = 0.0;
+    _params.gb_gain = 0.0;
+
+    _params.window.x_start = 0;
+    _params.window.y_start = 0;
+    _params.window.x_end = 0;
+    _params.window.y_end = 0;
+    _params.window.weight = 0;
+}
 
 bool
 AwbHandler::set_mode (XCamAwbMode mode)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _mode = mode;
+    _params.mode = mode;
 
     XCAM_LOG_DEBUG ("awb set mode [%d]", mode);
     return true;
@@ -232,7 +255,7 @@
         "awb speed(%f) is out of range, suggest (0.0, 1.0]", speed);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _speed = speed;
+    _params.speed = speed;
 
     XCAM_LOG_DEBUG ("awb set speed [%f]", speed);
     return true;
@@ -248,8 +271,8 @@
         "awb set wrong cct(%u, %u) parameters", cct_min, cct_max);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _cct_min = cct_min;
-    _cct_max = cct_max;
+    _params.cct_min = cct_min;
+    _params.cct_max = cct_max;
 
     XCAM_LOG_DEBUG ("awb set cct range [%u, %u]", cct_min, cct_max);
     return true;
@@ -265,32 +288,41 @@
         "awb manual gain value must >= 0.0");
 
     AnalyzerHandler::HanlderLock lock(this);
-    _gr_gain = gr;
-    _r_gain = r;
-    _b_gain = b;
-    _gb_gain = gb;
+    _params.gr_gain = gr;
+    _params.r_gain = r;
+    _params.b_gain = b;
+    _params.gb_gain = gb;
     XCAM_LOG_DEBUG ("awb set manual gain value(gr:%.03f, r:%.03f, b:%.03f, gb:%.03f)", gr, r, b, gb);
     return true;
 }
 
 CommonHandler::CommonHandler()
-    : _is_manual_gamma (false)
-    , _nr_level (0.0)
-    , _tnr_level (0.0)
-    , _brightness (0.0)
-    , _contrast (0.0)
-    , _hue (0.0)
-    , _saturation (0.0)
-    , _sharpness (0.0)
-    , _enable_dvs (false)
-    , _enable_gbce (false)
-    , _enable_night_mode (false)
-{}
+{
+    reset_parameters ();
+}
+
+void
+CommonHandler::reset_parameters ()
+{
+    xcam_mem_clear (&_params);
+
+    _params.is_manual_gamma = false;
+    _params.nr_level = 0.0;
+    _params.tnr_level = 0.0;
+    _params.brightness = 0.0;
+    _params.contrast = 0.0;
+    _params.hue = 0.0;
+    _params.saturation = 0.0;
+    _params.sharpness = 0.0;
+    _params.enable_dvs = false;
+    _params.enable_gbce = false;
+    _params.enable_night_mode = false;
+}
 
 bool CommonHandler::set_dvs (bool enable)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _enable_dvs = enable;
+    _params.enable_dvs = enable;
 
     XCAM_LOG_DEBUG ("common 3A enable dvs:%s", XCAM_BOOL2STR(enable));
     return true;
@@ -300,7 +332,7 @@
 CommonHandler::set_gbce (bool enable)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _enable_gbce = enable;
+    _params.enable_gbce = enable;
 
     XCAM_LOG_DEBUG ("common 3A enable gbce:%s", XCAM_BOOL2STR(enable));
     return true;
@@ -310,7 +342,7 @@
 CommonHandler::set_night_mode (bool enable)
 {
     AnalyzerHandler::HanlderLock lock(this);
-    _enable_night_mode = enable;
+    _params.enable_night_mode = enable;
 
     XCAM_LOG_DEBUG ("common 3A enable night mode:%s", XCAM_BOOL2STR(enable));
     return true;
@@ -327,7 +359,7 @@
         "set NR levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _nr_level = level;
+    _params.nr_level = level;
 
     XCAM_LOG_DEBUG ("common 3A set NR level:%.03f", level);
     return true;
@@ -343,7 +375,7 @@
         "set TNR levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _tnr_level = level;
+    _params.tnr_level = level;
 
     XCAM_LOG_DEBUG ("common 3A set TNR level:%.03f", level);
     return true;
@@ -359,7 +391,7 @@
         "set brightness levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _brightness = level;
+    _params.brightness = level;
 
     XCAM_LOG_DEBUG ("common 3A set brightness level:%.03f", level);
     return true;
@@ -374,7 +406,7 @@
         "set contrast levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _contrast = level;
+    _params.contrast = level;
 
     XCAM_LOG_DEBUG ("common 3A set contrast level:%.03f", level);
     return true;
@@ -389,7 +421,7 @@
         "set hue levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _hue = level;
+    _params.hue = level;
 
     XCAM_LOG_DEBUG ("common 3A set hue level:%.03f", level);
     return true;
@@ -405,7 +437,7 @@
         "set saturation levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _saturation = level;
+    _params.saturation = level;
 
     XCAM_LOG_DEBUG ("common 3A set saturation level:%.03f", level);
     return true;
@@ -420,7 +452,7 @@
         "set sharpness levlel(%.03f) out of range[-1.0, 1.0]", level);
 
     AnalyzerHandler::HanlderLock lock(this);
-    _sharpness = level;
+    _params.sharpness = level;
 
     XCAM_LOG_DEBUG ("common 3A set sharpness level:%.03f", level);
     return true;
@@ -431,7 +463,7 @@
 {
     AnalyzerHandler::HanlderLock lock(this);
     if (!r_table && ! g_table && !b_table) {
-        _is_manual_gamma = false;
+        _params.is_manual_gamma = false;
         XCAM_LOG_DEBUG ("common 3A disabled gamma");
         return true;
     }
@@ -442,11 +474,11 @@
     }
 
     for (uint32_t i = 0; i < XCAM_GAMMA_TABLE_SIZE; ++i) {
-        _r_gamma [i] = r_table [i];
-        _g_gamma [i] = g_table [i];
-        _b_gamma [i] = b_table [i];
+        _params.r_gamma [i] = r_table [i];
+        _params.g_gamma [i] = g_table [i];
+        _params.b_gamma [i] = b_table [i];
     }
-    _is_manual_gamma = true;
+    _params.is_manual_gamma = true;
 
     XCAM_LOG_DEBUG ("common 3A enabled RGB gamma");
     return true;
diff --git a/xcore/handler_interface.h b/xcore/handler_interface.h
index 0f5a1cc..9756bdb 100644
--- a/xcore/handler_interface.h
+++ b/xcore/handler_interface.h
@@ -26,6 +26,7 @@
 #include "xcam_mutex.h"
 #include "x3a_result.h"
 #include "xcam_3a_types.h"
+#include "xcam_params.h"
 
 namespace XCam {
 
@@ -79,47 +80,55 @@
     virtual double get_max_analog_gain ();
 
 protected:
+    const XCamAeParam &get_params_unlock () const {
+        return _params;
+    }
+
     XCamAeMode get_mode_unlock() const {
-        return _mode;
+        return _params.mode;
     }
     XCamAeMeteringMode get_metering_mode_unlock() const {
-        return _metering_mode;
+        return _params.metering_mode;
     }
     const XCam3AWindow &get_window_unlock() const {
-        return _window;
+        return _params.window;
     }
     XCamFlickerMode get_flicker_mode_unlock() const {
-        return _flicker_mode;
+        return _params.flicker_mode;
     }
     double get_speed_unlock() const {
-        return _speed;
+        return _params.speed;
     }
     double get_ev_shift_unlock() const {
-        return _ev_shift;
+        return _params.ev_shift;
+    }
+
+    uint64_t get_manual_exposure_time_unlock () const {
+        return _params.manual_exposure_time;
+    }
+    double get_manual_analog_gain_unlock () const {
+        return _params.manual_analog_gain;
+    }
+
+    double get_aperture_fn_unlock () const {
+        return _params.aperture_fn;
+    }
+
+    void get_exposure_time_range_unlock (uint64_t &min, uint64_t &max) const {
+        min = _params.exposure_time_min;
+        max = _params.exposure_time_max;
+    }
+
+    double get_max_analog_gain_unlock () const {
+        return _params.max_analog_gain;
     }
 
 private:
+    void reset_parameters ();
     XCAM_DEAD_COPY (AeHandler);
 
 protected:
-    XCamAeMode              _mode;
-    XCamAeMeteringMode      _metering_mode;
-    XCam3AWindow            _window;
-    XCamFlickerMode         _flicker_mode;
-    double                  _speed;
-
-    /* exposure limitation */
-    uint64_t                _exposure_time_min, _exposure_time_max; // exposure time range
-    double                  _max_analog_gain;
-
-    /* exposure manual values */
-    uint64_t                _manual_exposure_time;
-    double                  _manual_analog_gain;
-
-    double                  _aperture_fn;
-
-    /*ev*/
-    double                  _ev_shift;
+    XCamAeParam   _params;
 };
 
 class AwbHandler
@@ -135,27 +144,32 @@
     bool set_manual_gain (double gr, double r, double b, double gb);
 
 protected:
+    const XCamAwbParam &get_params_unlock () const {
+        return _params;
+    }
+
     XCamAwbMode get_mode_unlock() const {
-        return _mode;
+        return _params.mode;
     }
     double get_speed_unlock () const {
-        return _speed;
+        return _params.speed;
+    }
+
+    const XCam3AWindow &get_window_unlock () const {
+        return _params.window;
+    }
+
+    void get_cct_range_unlock (uint32_t &cct_min, uint32_t &cct_max) const {
+        cct_min = _params.cct_min;
+        cct_max = _params.cct_max;
     }
 
 private:
+    void reset_parameters ();
     XCAM_DEAD_COPY (AwbHandler);
 
 protected:
-    XCamAwbMode             _mode;
-    double                  _speed;
-    uint32_t                _cct_min, _cct_max;
-    XCam3AWindow            _window;
-
-    /* manual gain */
-    double                  _gr_gain;
-    double                  _r_gain;
-    double                  _b_gain;
-    double                  _gb_gain;
+    XCamAwbParam _params;
 };
 
 class AfHandler
@@ -168,6 +182,12 @@
     XCAM_DEAD_COPY (AfHandler);
 
 protected:
+    const XCamAfParam &get_params_unlock () const {
+        return _params;
+    }
+
+protected:
+    XCamAfParam _params;
 };
 
 class CommonHandler
@@ -191,66 +211,48 @@
     bool set_manual_sharpness (double level);
     bool set_gamma_table (double *r_table, double *g_table, double *b_table);
 
-public:
+protected:
+    const XCamCommonParam &get_params_unlock () const {
+        return _params;
+    }
     bool has_gbce_unlock () const {
-        return _enable_gbce;
+        return _params.enable_gbce;
     }
     bool has_dvs_unlock () const {
-        return _enable_dvs;
+        return _params.enable_dvs;
     }
     bool has_night_mode_unlock () const {
-        return _enable_night_mode;
+        return _params.enable_night_mode;
     }
 
     double get_nr_level_unlock () const {
-        return _nr_level;
+        return _params.nr_level;
     }
     double get_tnr_level_unlock () const {
-        return _tnr_level;
+        return _params.tnr_level;
     }
     double get_brightness_unlock () const {
-        return _brightness;
+        return _params.brightness;
     }
     double get_contrast_unlock () const {
-        return _contrast;
+        return _params.contrast;
     }
     double get_hue_unlock () const {
-        return _hue;
+        return _params.hue;
     }
     double get_saturation_unlock () const {
-        return _saturation;
+        return _params.saturation;
     }
     double get_sharpness_unlock () const {
-        return _sharpness;
+        return _params.sharpness;
     }
 
 private:
+    void reset_parameters ();
     XCAM_DEAD_COPY (CommonHandler);
 
 protected:
-    /* R, G, B gamma table, size = XCAM_GAMMA_TABLE_SIZE */
-    bool                      _is_manual_gamma;
-    double                    _r_gamma [XCAM_GAMMA_TABLE_SIZE];
-    double                    _g_gamma [XCAM_GAMMA_TABLE_SIZE];
-    double                    _b_gamma [XCAM_GAMMA_TABLE_SIZE];
-
-    /*
-     * manual brightness, contrast, hue, saturation, sharpness
-     * -1.0 < value < 1.0
-     */
-    double                     _nr_level;
-    double                     _tnr_level;
-
-    double                     _brightness;
-    double                     _contrast;
-    double                     _hue;
-    double                     _saturation;
-    double                     _sharpness;
-
-    /* others */
-    bool                       _enable_dvs;
-    bool                       _enable_gbce;
-    bool                       _enable_night_mode;
+    XCamCommonParam _params;
 };
 
 };
diff --git a/xcore/xcam_params.h b/xcore/xcam_params.h
new file mode 100644
index 0000000..f572c26
--- /dev/null
+++ b/xcore/xcam_params.h
@@ -0,0 +1,97 @@
+/*
+ * xcam_params.h - 3A parameters
+ *
+ *  Copyright (c) 2015 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Wind Yuan <feng.yuan@intel.com>
+ */
+
+#ifndef C_XCAM_PARAMS_H
+#define C_XCAM_PARAMS_H
+
+#include <xcam_defs.h>
+#include <xcam_common.h>
+
+XCAM_BEGIN_DECLARE
+
+typedef struct _XCamAeParam {
+    XCamAeMode              mode;
+    XCamAeMeteringMode      metering_mode;
+    XCam3AWindow            window;
+    XCamFlickerMode         flicker_mode;
+    /* speed, default 1.0 */
+    double                  speed;
+
+    /* exposure limitation */
+    uint64_t                exposure_time_min, exposure_time_max;
+    double                  max_analog_gain;
+
+    /* exposure manual values */
+    uint64_t                manual_exposure_time;
+    double                  manual_analog_gain;
+
+    double                  aperture_fn;
+
+    /*ev*/
+    double                  ev_shift;
+} XCamAeParam;
+
+typedef struct _XCamAwbParam {
+    XCamAwbMode             mode;
+    /* speed, default 1.0 */
+    double                  speed;
+    uint32_t                cct_min, cct_max;
+    XCam3AWindow            window;
+
+    /* manual gain, default 0.0 */
+    double                  gr_gain;
+    double                  r_gain;
+    double                  b_gain;
+    double                  gb_gain;
+} XCamAwbParam;
+
+typedef struct _XCamAfParam {
+
+} XCamAfParam;
+
+typedef struct _XCamCommonParam {
+    /* R, G, B gamma table, size = XCAM_GAMMA_TABLE_SIZE */
+    bool                      is_manual_gamma;
+    double                    r_gamma [XCAM_GAMMA_TABLE_SIZE];
+    double                    g_gamma [XCAM_GAMMA_TABLE_SIZE];
+    double                    b_gamma [XCAM_GAMMA_TABLE_SIZE];
+
+    /*
+     * manual brightness, contrast, hue, saturation, sharpness
+     * -1.0 < value < 1.0
+     */
+    double                     nr_level;
+    double                     tnr_level;
+
+    double                     brightness;
+    double                     contrast;
+    double                     hue;
+    double                     saturation;
+    double                     sharpness;
+
+    /* others */
+    bool                       enable_dvs;
+    bool                       enable_gbce;
+    bool                       enable_night_mode;
+} XCamCommonParam;
+
+XCAM_END_DECLARE
+
+#endif //C_XCAM_PARAMS_H