audio_service: effect tool Adds the dts vx 4 debug tool [1/1]

PD#SWPL-161098

Problem:
current effect_tool not support vx v4

Solution:
1 support both vx V4
2 sync code sync from 405896

Verify:
yocto

Change-Id: I4a60cb084856f1290bddac7baa5f2d0d8e63fd7c
Signed-off-by: hui.liu <hui.liu@amlogic.com>
diff --git a/Makefile b/Makefile
index 01180b5..d6b6d1b 100644
--- a/Makefile
+++ b/Makefile
@@ -45,7 +45,7 @@
 TEST_HAL_DUMP_OBJS=$(AML_BUILD_DIR)/hal_dump.o
 TEST_HAL_PATCH_OBJS=$(AML_BUILD_DIR)/hal_patch.o
 TEST_MASTER_VOL_OBJS=$(AML_BUILD_DIR)/master_vol.o
-EFFECT_TOOL_OBJS=$(AML_BUILD_DIR)/effect_tool.o
+EFFECT_TOOL_OBJS=$(AML_BUILD_DIR)/effect_tool.o $(AML_BUILD_DIR)/vx_v4_ctr.o
 TEST_AUDIO_CLIENT_BINDER_OBJS=$(AML_BUILD_DIR)/audio_client_binder_test.o
 
 PROTOC=$(HOST_DIR)/bin/protoc
diff --git a/include/audio_effect_if.h b/include/audio_effect_if.h
index a9e38da..d9c305d 100644
--- a/include/audio_effect_if.h
+++ b/include/audio_effect_if.h
@@ -17,6 +17,7 @@
     AML_EFFECT_HPEQ,
     AML_EFFECT_AVL,
     AML_EFFECT_VIRTUALX,
+    AML_EFFECT_VIRTUALX_v4,
     AML_EFFECT_MAX,
 } aml_audio_effect_type_e;
 
diff --git a/src/effect_tool.c b/src/effect_tool.c
index 5561d2a..964f26b 100644
--- a/src/effect_tool.c
+++ b/src/effect_tool.c
@@ -18,10 +18,12 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <Virtualx_v4.h>
 #include "audio_if_client.h"
 #include "audio_effect_if.h"
 #include "audio_effect_params.h"
 
+
 #ifdef LOG
 #undef LOG
 #endif
@@ -176,6 +178,7 @@
 };
 const char *VXStatusstr[] = {"Disable", "Enable"};
 
+
 //-------------function--------------------------
 static int Balance_effect_func(int gParamIndex, int gParamValue)
 {
@@ -1331,12 +1334,47 @@
     }
 }
 
+// -vx4 set param
+int Virtualx_v4_effect_func(void)
+{
+    VX_Cmd_Param *vxCmd = getVxCmdParamInstance();
+    if (!vxCmd) {
+        LOG("Warning, VxCmd is NULL!\n");
+        return -1;
+    }
+
+    //vxParam will update by init_effect_param_data()
+    Virtualx_v4_param_t *vxParam = getVxParamInstance();
+    int ret =audio_effect_set_parameters(AML_EFFECT_VIRTUALX_v4, &vxParam->param);//Set DTS VX parameters
+    LOG("rc is %d\n",ret);
+
+    if ((vxCmd->userId == PARAM_CHANNEL_NUM) ||
+        (vxCmd->userId == PARAM_OUT_CHANNEL_NUM) ||
+        (vxCmd->userId == VIRTUALX_PARAM_ENABLE) ||
+        (vxCmd->userId == VIRTUALX4_PARAM_SURROUND_MODE) ||
+        (vxCmd->userId == VIRTUALX4_PARAM_DIALOGCLARITY_MODE) ||
+        (vxCmd->userId == AUDIO_PARAM_TYPE_TRU_VOLUME) ||
+        (vxCmd->userId == PARAM_LOUDNESS_CONTROL_ENABLE_I32) ||
+        (vxCmd->userId == PARAM_LOUDNESS_CONTROL_IO_MODE_I32) ||
+        (vxCmd->userId == PARAM_AEQ_ENABLE_I32) ||
+        (vxCmd->userId == VIRTUALX_EFFECT_ENABLE))
+    {
+        LOG("->[%s] ParamIndex:%d ParamValType:Int %s = %d\n", (ret == 0? "OK" : "NG"), vxParam->command, vxCmd->param, vxParam->v);
+    }
+    else
+    {
+        LOG("->[%s] ParamIndex:%d ParamValType:CStr %s = %s\n", (ret == 0? "OK" : "NG"), vxParam->command, vxCmd->param, vxParam->str);
+    }
+    return 0;
+}
+
 int GetIntData (int *data)
 {
     int status = scanf("%d", data);
     if (status == 0) {
-        scanf("%*s");
-        LOG("Error input! Pls Retry!\n");
+        int status_temp=scanf("%*s");
+        if (status_temp < 0)
+            LOG("Error input! Pls Retry!\n");
         return -1;
     }
     return 0;
@@ -1631,6 +1669,7 @@
             LOG("             3: Amlogic HPEQ\n");
             LOG("             4: Amlogic AVL\n");
             LOG("             5: DTS VIRTUALX\n");
+            LOG("             6: DTS VIRTUALX4\n");
             LOG("Usage: %s <EffectIndex>\n", argv[0]);
             LOG("******************************************************************************\n");
             return 0;
@@ -1730,6 +1769,13 @@
             LOG("EffectIndex:%d, ParamIndex:%d, Paramvalue:%d\n", gEffectIndex, gParamIndex, gParamValue);
         }
         break;
+     case AML_EFFECT_VIRTUALX_v4:
+        ret = set_param_from_cmd_line(argc, argv);//Parse input parameter
+        if (ret < 0) {
+            LOG("main() Virtualx parse cmd line for VX Param fail!\n");
+        }
+        gParamIndex = ret;
+        break;;
     default:
         LOG("EffectIndex = %d is invalid\n", gEffectIndex);
         return -1;
@@ -1767,6 +1813,10 @@
             if (Virtualx_effect_func(gParamIndex, gParamValue,gParamScale,grange) < 0)
                 LOG("Virtualx Test failed\n");
             break;
+       case AML_EFFECT_VIRTUALX_v4:
+            //------------set Virtualx v4 parameters-------------------------------------------
+            Virtualx_v4_effect_func();
+            break;
         default:
             break;
         }
@@ -1786,8 +1836,14 @@
             break;
         }
 
-        if (GetIntData(&gParamIndex) < 0)
-            goto Retry_input;
+        /* AML_EFFECT_VIRTUALX_v4 gParamIndex support string
+         * so GetIntData not used at AML_EFFECT_VIRTUALX_v4
+         * use set_param_from_scanf () to parse the parameters of DTS V4
+        */
+        if (gEffectIndex != AML_EFFECT_VIRTUALX_v4) {
+            if (GetIntData(&gParamIndex) < 0)
+                goto Retry_input;
+        }
 
         switch (gEffectIndex) {
         case AML_EFFECT_BALANCE:
@@ -1850,6 +1906,15 @@
                 LOG("EffectIndex:%d, ParamIndex:%d, Paramvalue:%d\n", gEffectIndex, gParamIndex, gParamValue);
             }
             break;
+        case AML_EFFECT_VIRTUALX_v4:
+            //------------get Virtualx parameters--------------------------------------
+            ret = set_param_from_scanf(AML_EFFECT_VIRTUALX_v4);
+            if (ret < 0) {
+                goto Retry_input;
+            }
+            gParamIndex = ret;
+            break;
+
         case AML_EFFECT_AVL:
             //------------get Avl parameters-------------------------------------------
             if (GetIntData(&gParamValue) < 0)
diff --git a/src/vx_v4_ctr.c b/src/vx_v4_ctr.c
new file mode 100644
index 0000000..1ea28ce
--- /dev/null
+++ b/src/vx_v4_ctr.c
@@ -0,0 +1,1220 @@
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <ctype.h>
+
+#include <errno.h>
+#include "audio_effect_params.h"
+#include <Virtualx_v4.h>
+
+
+#define AM_ARRAY_SIZE(_a)       (sizeof(_a)/sizeof((_a)[0]))
+#define BITS                    16
+#define MAXbit                  (1 << (BITS - 1))
+#define INT2FLOAT(a)            ((float)a / MAXbit)
+#define FLOAT2INT(a)            (int)((float)a * MAXbit)
+
+#ifdef LOG
+#undef LOG
+#endif
+#define LOG(x...) printf("[AudioEffect_vx4] " x)
+
+
+#ifdef LOGV
+#undef LOGV
+#endif
+#define LOGV(format,...)
+
+const char *VX4Statusstr[] = {"Disable", "Enable"};
+
+
+static Virtualx_v4_param_t gVxParamInstance;
+static VX_Cmd_Param*    gPVxCmdParam = NULL;
+
+Virtualx_v4_param_t *getVxParamInstance()
+{
+    return &gVxParamInstance;
+}
+
+VX_Cmd_Param *getVxCmdParamInstance()
+{
+    return gPVxCmdParam;
+}
+
+void setVxCmdParamInstance(VX_Cmd_Param *data)
+{
+    gPVxCmdParam = data;
+}
+
+/*** parameter index to parameter name map ***/
+#define CMD_NAME_USERID_INIT(_param, _key, _userId)    {.param = _param, .key = _key, .userId = _userId}
+
+/*** VirtualX normal control parameters ***/
+enum virtualx_force_id {
+    VX_frame_size = 0,
+    VX_input_pcm_stride,
+    VX_output_pcm_stride,
+};
+
+static VX_Cmd_Param virtualx_force_params[] = {
+    CMD_NAME_USERID_INIT("--frame-size", VX_frame_size, PARAM_VX_FRAME_SIZE),
+    CMD_NAME_USERID_INIT("--input-pcm-stride", VX_input_pcm_stride, PARAM_VX_INPUT_PCM_STRIDE),
+    CMD_NAME_USERID_INIT("--output-pcm-stride", VX_output_pcm_stride, PARAM_VX_OUTPUT_PCM_STRIDE),
+};
+
+/*** VirtualX general control parameters ***/
+enum virtualx_general_id {
+    VIRTUALX_en = 0,
+    VIRTUALX_in_mode,
+    VIRTUALX_out_mode,
+    VIRTUALX_headroom_gain,
+    VIRTUALX_processing_output_gain,
+    VIRTUALX_reference_level,
+    VIRTUALX_discard,
+    VIRTUALX_multirate_processing_type,
+};
+
+static VX_Cmd_Param virtualx_general_params[] = {
+    CMD_NAME_USERID_INIT("--virtualx-en", VIRTUALX_en, PARAM_VX_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-in-mode", VIRTUALX_in_mode, PARAM_VX_INPUT_MODE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-out-mode", VIRTUALX_out_mode, PARAM_VX_OUTPUT_MODE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-headroom-gain", VIRTUALX_headroom_gain, PARAM_VX_HEADROOM_GAIN_I32),
+    CMD_NAME_USERID_INIT("--virtualx-processing-output-gain", VIRTUALX_processing_output_gain, PARAM_VX_PROC_OUTPUT_GAIN_I32),
+    CMD_NAME_USERID_INIT("--virtualx-reference-level", VIRTUALX_reference_level, PARAM_VX_REFERENCE_LEVEL_I32),
+    CMD_NAME_USERID_INIT("--virtualx-discard", VIRTUALX_discard, PARAM_VX_PROCESS_DISCARD_I32),
+    CMD_NAME_USERID_INIT("--virtualx-multirate-processing-type", VIRTUALX_multirate_processing_type, PARAM_VX_PROCESS_MULTIRATE_PROC_TYPE_I32),
+};
+
+/*** VirtualX True surroundX control parameters ***/
+enum virtualx_truSurroundX_id {
+    VIRTUALX_tsx_en = 0,
+    VIRTUALX_tsx_pssv_mtrx_en,
+    VIRTUALX_tsx_horiznt_effect_ctrl,
+    VIRTUALX_tsx_phantom_ctrgain,
+    VIRTUALX_tsx_ctrgain,
+    VIRTUALX_tsx_heightmix_coeff,
+    VIRTUALX_tsx_height_out_gain,
+    VIRTUALX_tsx_precond_front,
+    VIRTUALX_tsx_precond_surnd,
+    VIRTUALX_tsx_vxtopspk_loc,
+    VIRTUALX_tsx_frnt_wide_en,
+    VIRTUALX_tsx_hght_virtualizer_en,
+    VIRTUALX_tsx_frnt_srnd_en,
+    VIRTUALX_tsx_hght_upmix_en,
+    VIRTUALX_tsx_lrmix_ratio2ctr,
+    VIRTUALX_tsx_lfe_gain,
+    VIRTUALX_tsx_height_discard,
+    //TSX APP
+    VIRTUALX_tsx_app_lstnr_dist,
+    VIRTUALX_tsx_app_bttmspktoctr_dist,
+    VIRTUALX_tsx_app_topspktoctr_dist,
+};
+
+static VX_Cmd_Param virtualx_truSurroundX_params[] = {
+    CMD_NAME_USERID_INIT("--virtualx-tsx-en", VIRTUALX_tsx_en, PARAM_TSX_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-pssv-mtrx-en", VIRTUALX_tsx_pssv_mtrx_en, PARAM_TSX_PASSIVEMATRIXUPMIX_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-horiznt-effect-ctrl", VIRTUALX_tsx_horiznt_effect_ctrl, PARAM_TSX_HORIZNT_EFFECT_CTRL),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-phantom-ctrgain",VIRTUALX_tsx_phantom_ctrgain, PARAM_TSX_PHANTOM_CTRGAIN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-ctrgain", VIRTUALX_tsx_ctrgain, PARAM_TSX_CTRGAIN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-heightmix-coeff", VIRTUALX_tsx_heightmix_coeff, PARAM_TSX_HEIGHTMIX_COEFF),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-height-out-gain", VIRTUALX_tsx_height_out_gain, PARAM_TSX_HEIGHT_OUT_GAIN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-precond-front", VIRTUALX_tsx_precond_front, PARAM_TSX_PRECOND_FRONT),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-precond-surnd", VIRTUALX_tsx_precond_surnd, PARAM_TSX_PRECOND_SURND),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-vxtopspk-loc", VIRTUALX_tsx_vxtopspk_loc, PARAM_TSX_VXTOPSPK_LOC),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-frnt-wide-en", VIRTUALX_tsx_frnt_wide_en, PARAM_TSX_FRNT_WIDE_EN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-hght-virtualizer-en", VIRTUALX_tsx_hght_virtualizer_en, PARAM_TSX_HEIGHT_VIRTUALIZER_EN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-frnt-srnd-en", VIRTUALX_tsx_frnt_srnd_en, PARAM_TSX_FRNT_SRND_EN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-hght-upmix-en", VIRTUALX_tsx_hght_upmix_en, PARAM_TSX_HEIGHT_UPMIX_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-lrmix-ratio2ctr", VIRTUALX_tsx_lrmix_ratio2ctr, PARAM_TSX_LRMIX_RATIO2CTR),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-lfe-gain", VIRTUALX_tsx_lfe_gain, PARAM_TSX_LFE_GAIN),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-height-discard", VIRTUALX_tsx_height_discard, PARAM_TSX_HEIGHT_DISCARD_I32),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-app-lstnr-dist", VIRTUALX_tsx_app_lstnr_dist, PARAM_TSX_APP_LSTNR_DIST),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-app-bttmspktoctr-dist", VIRTUALX_tsx_app_bttmspktoctr_dist, PARAM_TSX_APP_BTTM_DIST),
+    CMD_NAME_USERID_INIT("--virtualx-tsx-app-topspktoctr-dist", VIRTUALX_tsx_app_topspktoctr_dist, PARAM_TSX_APP_TOP_DIST),
+};
+
+
+enum virtualx_truSurroundX_DC_id {
+    VIRTUALX_dialogclarity_en,
+    VIRTUALX_dialogclarity_level,
+    VIRTUALX_definition_en,
+    VIRTUALX_definition_lvl,
+    VIRTUALX_cs2to3_en,
+};
+
+static VX_Cmd_Param virtualx_truSurroundX_DC_params[] = {
+    CMD_NAME_USERID_INIT("--virtualx-dialogclarity-en", VIRTUALX_dialogclarity_en, PARAM_VX_DC_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-dialogclarity-level", VIRTUALX_dialogclarity_level, PARAM_VX_DC_CONTROL_I32),
+    CMD_NAME_USERID_INIT("--virtualx-definition-en", VIRTUALX_definition_en, PARAM_VX_DEF_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--virtualx-definition-lvl", VIRTUALX_definition_lvl, PARAM_VX_DEF_CONTROL_I32),
+    CMD_NAME_USERID_INIT("--virtualx-cs2to3-en", VIRTUALX_cs2to3_en, PARAM_VX_CS2TO3_EN),
+};
+
+/*** TBHDX control parameters ***/
+enum virtual_TBHDX_id {
+    tbhdx_front_en,
+    tbhdx_front_proc_mode,
+    tbhdx_front_spksize,
+    tbhdx_front_dynms,
+    tbhdx_front_hp_en,
+    tbhdx_front_hp_order,
+    tbhdx_front_bass_lvl,
+    tbhdx_front_extbass,
+    tbhdx_front_input_gain,
+    tbhdx_front_bypass_gain,
+    tbhdx_rear_en,
+    tbhdx_rear_proc_mode,
+    tbhdx_rear_spksize,
+    tbhdx_rear_dynms,
+    tbhdx_rear_hp_e,
+    tbhdx_rear_hp_order,
+    tbhdx_rear_bass_lvl,
+    tbhdx_rear_extbass,
+    tbhdx_rear_input_gain,
+    tbhdx_rear_bypass_gain,
+    tbhdx_center_en,
+    tbhdx_center_dynms,
+    tbhdx_center_hp_en,
+    tbhdx_center_hp_order,
+    tbhdx_center_bass_lvl,
+    tbhdx_center_extbass,
+    tbhdx_center_input_gain,
+    tbhdx_center_bypass_gain,
+    tbhdx_surround_en,
+    tbhdx_surround_proc_mode,
+    tbhdx_surround_spksize,
+    tbhdx_surround_dynms,
+    tbhdx_surround_hp_en,
+    tbhdx_surround_hp_order,
+    tbhdx_surround_bass_lvl,
+    tbhdx_surround_extbass,
+    tbhdx_surround_input_gain,
+    tbhdx_surround_bypass_gain,
+    tbhdx_delay_matching_gain,
+    tbhdx_discard,
+    tbhdx_front_app_spksize,
+    tbhdx_front_app_tgain,
+    tbhdx_front_app_hpr,
+    tbhdx_front_app_extbass,
+    tbhdx_center_app_spksize,
+    tbhdx_center_app_tgain,
+    tbhdx_center_app_hpr,
+    tbhdx_center_app_extbass,
+    tbhdx_surround_app_spksize,
+    tbhdx_surround_app_tgain,
+    tbhdx_surround_app_hpr,
+    tbhdx_surround_app_extbass,
+    tbhdx_rear_app_spksize,
+    tbhdx_rear_app_tgain,
+    tbhdx_rear_app_hpr,
+    tbhdx_rear_app_extbass,
+};
+
+static VX_Cmd_Param virtualx_TBHDX_params[] = {
+    CMD_NAME_USERID_INIT("--tbhdx-front-en", tbhdx_front_en, PARAM_TBHDX_FRONT_ENABLE),
+    CMD_NAME_USERID_INIT("--tbhdx-front-proc-mode", tbhdx_front_proc_mode, PARAM_TBHDX_FRONT_PROC_MODE),
+    CMD_NAME_USERID_INIT("--tbhdx-front-spksize", tbhdx_front_spksize, PARAM_TBHDX_FRONT_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-front-dynms", tbhdx_front_dynms, PARAM_TBHDX_FRONT_DYNMS),
+    CMD_NAME_USERID_INIT("--tbhdx-front-hp-en", tbhdx_front_hp_en, PARAM_TBHDX_FRONT_HP_EN),
+    CMD_NAME_USERID_INIT("--tbhdx-front-hp-order", tbhdx_front_hp_order, PARAM_TBHDX_FRONT_HP_ORDER),
+    CMD_NAME_USERID_INIT("--tbhdx-front-bass-lvl", tbhdx_front_bass_lvl, PARAM_TBHDX_FRONT_BASS_LVL),
+    CMD_NAME_USERID_INIT("--tbhdx-front-extbass", tbhdx_front_extbass, PARAM_TBHDX_FRONT_EXT_BASS),
+    CMD_NAME_USERID_INIT("--tbhdx-front-input-gain", tbhdx_front_input_gain, PARAM_TBHDX_FRONT_INPUT_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-front-bypass-gain", tbhdx_front_bypass_gain, PARAM_TBHDX_FRONT_BYPASS_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-en", tbhdx_rear_en, PARAM_TBHDX_REAR_ENABLE),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-proc-mode", tbhdx_rear_proc_mode, PARAM_TBHDX_REAR_PROC_MODE),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-spksize", tbhdx_rear_spksize, PARAM_TBHDX_REAR_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-dynms", tbhdx_rear_dynms, PARAM_TBHDX_REAR_DYNMS),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-hp-en", tbhdx_rear_hp_e, PARAM_TBHDX_REAR_HP_EN),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-hp-order", tbhdx_rear_hp_order, PARAM_TBHDX_REAR_HP_ORDER),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-bass-lvl", tbhdx_rear_bass_lvl, PARAM_TBHDX_REAR_BASS_LVL),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-extbass", tbhdx_rear_extbass, PARAM_TBHDX_REAR_EXT_BASS),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-input-gain", tbhdx_rear_input_gain, PARAM_TBHDX_REAR_INPUT_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-bypass-gain", tbhdx_rear_bypass_gain, PARAM_TBHDX_REAR_BYPASS_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-center-en", tbhdx_center_en, PARAM_TBHDX_CENTER_ENABLE),
+    CMD_NAME_USERID_INIT("--tbhdx-center-dynms", tbhdx_center_dynms, PARAM_TBHDX_CENTER_DYNMS),
+    CMD_NAME_USERID_INIT("--tbhdx-center-hp-en", tbhdx_center_hp_en, PARAM_TBHDX_CENTER_HP_EN),
+    CMD_NAME_USERID_INIT("--tbhdx-center-hp-order", tbhdx_center_hp_order, PARAM_TBHDX_CENTER_HP_ORDER),
+    CMD_NAME_USERID_INIT("--tbhdx-center-bass-lvl", tbhdx_center_bass_lvl, PARAM_TBHDX_CENTER_BASS_LVL),
+    CMD_NAME_USERID_INIT("--tbhdx-center-extbass", tbhdx_center_extbass, PARAM_TBHDX_CENTER_EXT_BASS),
+    CMD_NAME_USERID_INIT("--tbhdx-center-input-gain", tbhdx_center_input_gain, PARAM_TBHDX_CENTER_INPUT_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-center-bypass-gain", tbhdx_center_bypass_gain, PARAM_TBHDX_CENTER_BYPASS_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-en", tbhdx_surround_en, PARAM_TBHDX_SURROUND_ENABLE),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-proc-mode", tbhdx_surround_proc_mode, PARAM_TBHDX_SURD_PROC_MODE),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-spksize", tbhdx_surround_spksize, PARAM_TBHDX_SURD_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-dynms", tbhdx_surround_dynms, PARAM_TBHDX_SURD_DYNMS),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-hp-en", tbhdx_surround_hp_en, PARAM_TBHDX_SURD_HP_EN),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-hp-order", tbhdx_surround_hp_order, PARAM_TBHDX_SURD_HP_ORDER),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-bass-lvl", tbhdx_surround_bass_lvl, PARAM_TBHDX_SURD_BASS_LVL),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-extbass", tbhdx_surround_extbass, PARAM_TBHDX_SURD_EXT_BASS),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-input-gain", tbhdx_surround_input_gain, PARAM_TBHDX_SURD_INPUT_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-bypass-gain", tbhdx_surround_bypass_gain, PARAM_TBHDX_SURD_BYPASS_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-delay-matching-gain", tbhdx_delay_matching_gain, PARAM_TBHDX_DELAY_MATCH_GAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-discard", tbhdx_discard, PARAM_TBHDX_PROCESS_DISCARD_I32),
+    CMD_NAME_USERID_INIT("--tbhdx-front-app-spksize", tbhdx_front_app_spksize, PARAM_TBHDX_FRONT_APP_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-front-app-tgain", tbhdx_front_app_tgain, PARAM_TBHDX_FRONT_APP_TGAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-front-app-hpr", tbhdx_front_app_hpr, PARAM_TBHDX_FRONT_APP_HPR),
+    CMD_NAME_USERID_INIT("--tbhdx-front-app-extbass", tbhdx_front_app_extbass, PARAM_TBHDX_FRONT_APP_EXTBASS),
+    CMD_NAME_USERID_INIT("--tbhdx-center-app-spksize", tbhdx_center_app_spksize, PARAM_TBHDX_CENTER_APP_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-center-app-tgain", tbhdx_center_app_tgain, PARAM_TBHDX_CENTER_APP_TGAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-center-app-hpr", tbhdx_center_app_hpr, PARAM_TBHDX_CENTER_APP_HPR),
+    CMD_NAME_USERID_INIT("--tbhdx-center-app-extbass", tbhdx_center_app_extbass, PARAM_TBHDX_CENTER_APP_EXTBASS),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-app-spksize", tbhdx_surround_app_spksize, PARAM_TBHDX_SURD_APP_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-app-tgain", tbhdx_surround_app_tgain, PARAM_TBHDX_SURD_APP_TGAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-app-hpr", tbhdx_surround_app_hpr, PARAM_TBHDX_SURD_APP_HPR),
+    CMD_NAME_USERID_INIT("--tbhdx-surround-app-extbass", tbhdx_surround_app_extbass, PARAM_TBHDX_SURD_APP_EXTBASS),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-app-spksize", tbhdx_rear_app_spksize, PARAM_TBHDX_REAR_APP_SPKSIZE),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-app-tgain", tbhdx_rear_app_tgain, PARAM_TBHDX_REAR_APP_TGAIN),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-app-hpr", tbhdx_rear_app_hpr, PARAM_TBHDX_REAR_APP_HPR),
+    CMD_NAME_USERID_INIT("--tbhdx-rear-app-extbass", tbhdx_rear_app_extbass, PARAM_TBHDX_REAR_APP_EXTBASS),
+};
+
+
+/*** loundness control parameters ***/
+enum virtualx_loundness_id {
+    loudness_control_en = 0,
+    loudness_control_io_mode,
+    loudness_control_target_loudness,
+    loudness_control_preset,
+    loudness_control_latency_mode,
+    loudness_control_discard,
+};
+static VX_Cmd_Param virtualx_loundness_params[] = {
+    CMD_NAME_USERID_INIT("--loudness-control-en", loudness_control_en, PARAM_LOUDNESS_CONTROL_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--loudness-control-io-mode", loudness_control_io_mode, PARAM_LOUDNESS_CONTROL_IO_MODE_I32),
+    CMD_NAME_USERID_INIT("--loudness-control-target-loudness", loudness_control_target_loudness, PARAM_LOUDNESS_CONTROL_TARGET_LOUDNESS_I32),
+    CMD_NAME_USERID_INIT("--loudness-control-preset", loudness_control_preset, PARAM_LOUDNESS_CONTROL_PRESET_I32),
+    CMD_NAME_USERID_INIT("--loudness-control-latency-mode", loudness_control_latency_mode, PARAM_LOUDNESS_CONTROL_LATENCY_MODE_I32),
+    CMD_NAME_USERID_INIT("--loudness-control-discard", loudness_control_discard, PARAM_LOUDNESS_CONTROL_DISCARD),
+};
+
+/*** MBHL control parameters ***/
+enum virtualx_MBHL_id{
+    mbhl_en = 0,
+    mbhl_discard,
+    mbhl_bypass_gain,
+    mbhl_reference_level,
+    mbhl_volume,
+    mbhl_volume_step,
+    mbhl_balance_step,
+    mbhl_output_gain,
+    mbhl_cp_enable,
+    mbhl_cp_level,
+    mbhl_ac_enable,
+    mbhl_ac_level,
+    mbhl_boost,
+    mbhl_threshold,
+    mbhl_slow_offset,
+    mbhl_fast_attack,
+    mbhl_fast_release,
+    mbhl_slow_attack,
+    mbhl_slow_release,
+    mbhl_delay,
+    mbhl_envelope_frequency,
+    mbhl_mode,
+    mbhl_cross_low,
+    mbhl_cross_mid,
+    mbhl_comp_attacks,
+    mbhl_comp_low_release,
+    mbhl_comp_low_ratio,
+    mbhl_comp_low_thresh,
+    mbhl_comp_low_makeup,
+    mbhl_comp_mid_release,
+    mbhl_comp_mid_ratio,
+    mbhl_comp_mid_thresh,
+    mbhl_comp_mid_makeup,
+    mbhl_comp_high_release,
+    mbhl_comp_high_ratio,
+    mbhl_comp_high_thresh,
+    mbhl_comp_high_makeup,
+};
+
+VX_Cmd_Param virtualx_MBHL_params[] = {
+    CMD_NAME_USERID_INIT("--mbhl-en",  mbhl_en, PARAM_MBHL_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-discard",  mbhl_discard, PARAM_MBHL_PROCESS_DISCARD_I32),
+    CMD_NAME_USERID_INIT("--mbhl-bypass-gain",  mbhl_bypass_gain, PARAM_MBHL_BYPASS_GAIN_I32),
+    CMD_NAME_USERID_INIT("--mbhl-reference-level",  mbhl_reference_level, PARAM_MBHL_REFERENCE_LEVEL_I32),
+    CMD_NAME_USERID_INIT("--mbhl-volume",  mbhl_volume, PARAM_MBHL_VOLUME_I32),
+    CMD_NAME_USERID_INIT("--mbhl-volume-step",  mbhl_volume_step, PARAM_MBHL_VOLUME_STEP_I32),
+    CMD_NAME_USERID_INIT("--mbhl-balance-step", mbhl_balance_step, PARAM_MBHL_BALANCE_STEP_I32),
+    CMD_NAME_USERID_INIT("--mbhl-output-gain",  mbhl_output_gain, PARAM_MBHL_OUTPUT_GAIN_I32),
+    CMD_NAME_USERID_INIT("--mbhl-cp-en",  mbhl_cp_enable, PARAM_MBHL_CP_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-cp-level",  mbhl_cp_level, PARAM_MBHL_CP_LEVEL),
+    CMD_NAME_USERID_INIT("--mbhl-ac-en",  mbhl_ac_enable, PARAM_MBHL_AC_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-ac-level",  mbhl_ac_level, PARAM_MBHL_AC_LEVEL),
+    CMD_NAME_USERID_INIT("--mbhl-boost",  mbhl_boost, PARAM_MBHL_BOOST_I32),
+    CMD_NAME_USERID_INIT("--mbhl-threshold",  mbhl_threshold, PARAM_MBHL_THRESHOLD_I32),
+    CMD_NAME_USERID_INIT("--mbhl-slow-offset",  mbhl_slow_offset, PARAM_MBHL_SLOW_OFFSET_I32),
+    CMD_NAME_USERID_INIT("--mbhl-fast-attack",  mbhl_fast_attack, PARAM_MBHL_FAST_ATTACK_I32),
+    CMD_NAME_USERID_INIT("--mbhl-fast-release",  mbhl_fast_release, PARAM_MBHL_FAST_RELEASE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-slow-attack",  mbhl_slow_attack, PARAM_MBHL_SLOW_ATTACK_I32),
+    CMD_NAME_USERID_INIT("--mbhl-slow-release",  mbhl_slow_release, PARAM_MBHL_SLOW_RELEASE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-delay",  mbhl_delay, PARAM_MBHL_DELAY_I32),
+    CMD_NAME_USERID_INIT("--mbhl-envelope-frequency",  mbhl_envelope_frequency, PARAM_MBHL_ENVELOPE_FREQUENCY_I32),
+    CMD_NAME_USERID_INIT("--mbhl-mode",  mbhl_mode, PARAM_MBHL_MODE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-cross-low",  mbhl_cross_low, PARAM_MBHL_CROSS_LOW_I32),
+    CMD_NAME_USERID_INIT("--mbhl-cross-mid",  mbhl_cross_mid, PARAM_MBHL_CROSS_MID_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-attacks",  mbhl_comp_attacks, PARAM_MBHL_COMP_ATTACK_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-low-release",  mbhl_comp_low_release, PARAM_MBHL_COMP_LOW_RELEASE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-low-ratio",  mbhl_comp_low_ratio, PARAM_MBHL_COMP_LOW_RATIO_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-low-thresh",  mbhl_comp_low_thresh, PARAM_MBHL_COMP_LOW_THRESH_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-low-makeup",  mbhl_comp_low_makeup, PARAM_MBHL_COMP_LOW_MAKEUP_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-mid-release",  mbhl_comp_mid_release, PARAM_MBHL_COMP_MID_RELEASE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-mid-ratio",  mbhl_comp_mid_ratio, PARAM_MBHL_COMP_MID_RATIO_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-mid-thresh",  mbhl_comp_mid_thresh, PARAM_MBHL_COMP_MID_THRESH_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-mid-makeup",  mbhl_comp_mid_makeup, PARAM_MBHL_COMP_MID_MAKEUP_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-high-release",  mbhl_comp_high_release, PARAM_MBHL_COMP_HIGH_RELEASE_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-high-ratio",  mbhl_comp_high_ratio, PARAM_MBHL_COMP_HIGH_RATIO_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-high-thresh",  mbhl_comp_high_thresh, PARAM_MBHL_COMP_HIGH_THRESH_I32),
+    CMD_NAME_USERID_INIT("--mbhl-comp-high-makeup",  mbhl_comp_high_makeup, PARAM_MBHL_COMP_HIGH_MAKEUP_I32),
+};
+
+/*** AEQ control parameters ***/
+enum virtualx_AEQ_id {
+    aeq_enable = 0,
+    aeq_app_ch_link_mask,
+    aeq_ch_ctrl_mask,
+    aeq_input_gain,
+    aeq_output_gain,
+    aeq_bypass_gain,
+    aeq_discard,
+    aeq_app_band_num,
+    aeq_app_band_en,
+    aeq_app_band_freq,
+    aeq_app_band_gain,
+    aeq_app_band_q,
+    aeq_app_band_type
+};
+static VX_Cmd_Param virtualx_AEQ_params[] = {
+    CMD_NAME_USERID_INIT("--aeq-enable", aeq_enable, PARAM_AEQ_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--aeq-app-ch-link-mask", aeq_app_ch_link_mask, PARAM_AEQ_CH_LINK_MASK_I32),
+    CMD_NAME_USERID_INIT("--aeq-ch-ctrl-mask", aeq_ch_ctrl_mask, PARAM_AEQ_CH_CTRL_MASK),
+    CMD_NAME_USERID_INIT("--aeq-input-gain",   aeq_input_gain, PARAM_AEQ_INPUT_GAIN_I16),
+    CMD_NAME_USERID_INIT("--aeq-output-gain",  aeq_output_gain, PARAM_AEQ_OUTPUT_GAIN_I16),
+    CMD_NAME_USERID_INIT("--aeq-bypass-gain",  aeq_bypass_gain, PARAM_AEQ_BYPASS_GAIN_I16),
+    CMD_NAME_USERID_INIT("--aeq-discard", aeq_discard, PARAM_AEQ_PROCESS_DISCARD_I32),
+    //Band parameters
+    CMD_NAME_USERID_INIT("--aeq-app-band-num", aeq_app_band_num, PARAM_AEQ_BAND_Num),
+    CMD_NAME_USERID_INIT("--aeq-app-band-en", aeq_app_band_en, PARAM_AEQ_BAND_En),
+    CMD_NAME_USERID_INIT("--aeq-app-band-freq", aeq_app_band_freq, PARAM_AEQ_BAND_Fre),
+    CMD_NAME_USERID_INIT("--aeq-app-band-gain", aeq_app_band_gain, PARAM_AEQ_BAND_Gain),
+    CMD_NAME_USERID_INIT("--aeq-app-band-q", aeq_app_band_q, PARAM_AEQ_BAND_Q),
+    CMD_NAME_USERID_INIT("--aeq-app-band-type", aeq_app_band_type, PARAM_AEQ_BAND_type),
+};
+
+/*** AEQ control parameters ***/
+enum virtualx_GEQ_id {
+    geq_enable = 0,
+    geq_ch_ctrl_mask,
+    geq_input_gain,
+    geq_band0_gain,
+    geq_band1_gain,
+    geq_band2_gain,
+    geq_band3_gain,
+    geq_band4_gain,
+    geq_band5_gain,
+    geq_band6_gain,
+    geq_band7_gain,
+    geq_band8_gain,
+    geq_band9_gain,
+    geq_discard,
+};
+
+static VX_Cmd_Param virtualx_GEQ_params[] = {
+    CMD_NAME_USERID_INIT("--geq-enable", geq_enable, PARAM_GEQ_En),
+    CMD_NAME_USERID_INIT("--geq-ch-ctrl-mask", geq_ch_ctrl_mask, PARAM_GEQ_CTRL_MASK),
+    CMD_NAME_USERID_INIT("--geq-input-gain", geq_input_gain, PARAM_GEQ_INPUT_GAIN),
+    CMD_NAME_USERID_INIT("--geq-band0-gain", geq_band0_gain, PARAM_GEQ_BAND0_Gain),
+    CMD_NAME_USERID_INIT("--geq-band1-gain", geq_band1_gain, PARAM_GEQ_BAND1_Gain),
+    CMD_NAME_USERID_INIT("--geq-band2-gain", geq_band2_gain, PARAM_GEQ_BAND2_Gain),
+    CMD_NAME_USERID_INIT("--geq-band3-gain", geq_band3_gain, PARAM_GEQ_BAND3_Gain),
+    CMD_NAME_USERID_INIT("--geq-band4-gain", geq_band4_gain, PARAM_GEQ_BAND4_Gain),
+    CMD_NAME_USERID_INIT("--geq-band5-gain", geq_band5_gain, PARAM_GEQ_BAND5_Gain),
+    CMD_NAME_USERID_INIT("--geq-band6-gain", geq_band6_gain, PARAM_GEQ_BAND6_Gain),
+    CMD_NAME_USERID_INIT("--geq-band7-gain", geq_band7_gain, PARAM_GEQ_BAND7_Gain),
+    CMD_NAME_USERID_INIT("--geq-band8-gain", geq_band8_gain, PARAM_GEQ_BAND8_Gain),
+    CMD_NAME_USERID_INIT("--geq-band9-gain", geq_band9_gain, PARAM_GEQ_BAND9_Gain),
+    CMD_NAME_USERID_INIT("--geq-discard", geq_discard, PARAM_GEQ_DISCARD),
+};
+
+/*** AEQ control parameters ***/
+enum virtualx_ildetect_id {
+    ildetect_upmix_en = 0,
+    ildetect_upmix_low_level_threshold,
+    ildetect_upmix_peak_hold_count,
+    ildetect_upmix_orig_lr_mix,
+    ildetect_upmix_srrnd_gain,
+    ildetect_upmix_srrnd_delay_en,
+    ildetect_upmix_discard,
+};
+
+static VX_Cmd_Param virtualx_ildetect_params[] = {
+    CMD_NAME_USERID_INIT("--ildetect-upmix-en", ildetect_upmix_en, PARAM_IL_UPMIX_EN),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-low-level-threshold", ildetect_upmix_low_level_threshold, PARAM_IL_UPMIX_LOW_LEVEL_THRES),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-peak-hold-count", ildetect_upmix_peak_hold_count, PARAM_IL_UPMIX_PEAK_HOLD_COUNT),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-orig-lr-mix", ildetect_upmix_orig_lr_mix, PARAM_IL_UPMIX_ORIG_LR_MIX),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-srrnd-gain", ildetect_upmix_srrnd_gain, PARAM_IL_UPMIX_SRRND_GAIN),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-srrnd-delay-en", ildetect_upmix_srrnd_delay_en, PARAM_IL_UPMIX_SRRND_DELAY_EN),
+    CMD_NAME_USERID_INIT("--ildetect-upmix-discard", ildetect_upmix_discard, PARAM_IL_UPMIX_DISCARD),
+};
+
+enum vx_show_config_id {
+    show_config = 0,
+};
+
+static VX_Cmd_Param vx_show_config_params[] = {
+    CMD_NAME_USERID_INIT("--show-config",  show_config, AUDIO_ALL_PARAM_DUMP),
+};
+
+enum vx_ui_interface_id {
+    ui_vx_enable = 0,
+    ui_vx_in_channel_num,
+    ui_vx_out_channel_num,
+    ui_vx_surround_mode,
+    ui_vx_dc_mode,
+    ui_vx_tru_vol,
+    ui_vx_loudness_en,
+    ui_vx_loudness_io_mode,
+    ui_vx_aeq_en,
+    ui_vx_effect_en,
+    vx_user_mode,
+};
+
+static VX_Cmd_Param vx_ui_interface_params[] = {
+    CMD_NAME_USERID_INIT("--am-ui-vx-en",  ui_vx_enable, VIRTUALX_PARAM_ENABLE),
+    CMD_NAME_USERID_INIT("--am-ui-vx-in-ch",  ui_vx_in_channel_num, PARAM_CHANNEL_NUM),
+    CMD_NAME_USERID_INIT("--am-ui-vx-out-ch",  ui_vx_out_channel_num, PARAM_OUT_CHANNEL_NUM),
+    CMD_NAME_USERID_INIT("--am-ui-vx-surd-mode",  ui_vx_surround_mode, VIRTUALX4_PARAM_SURROUND_MODE),
+    CMD_NAME_USERID_INIT("--am-ui-vx-surd-mode",  ui_vx_dc_mode, VIRTUALX4_PARAM_DIALOGCLARITY_MODE),
+    CMD_NAME_USERID_INIT("--am-ui-vx-tru-vol",  ui_vx_tru_vol, AUDIO_PARAM_TYPE_TRU_VOLUME),
+    CMD_NAME_USERID_INIT("--am-ui-vx-loudness-ctrl",  ui_vx_loudness_en, PARAM_LOUDNESS_CONTROL_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--am-ui-vx-loudness-io-mode",  ui_vx_loudness_io_mode, PARAM_LOUDNESS_CONTROL_IO_MODE_I32),
+    CMD_NAME_USERID_INIT("--am-ui-vx-aeq-en",  ui_vx_aeq_en, PARAM_AEQ_ENABLE_I32),
+    CMD_NAME_USERID_INIT("--am-ui-vx-effect-en",  ui_vx_effect_en, VIRTUALX_EFFECT_ENABLE),
+    CMD_NAME_USERID_INIT("--am-ui-vx-mode",  vx_user_mode, VIRTUALX_USER_MODE),
+};
+
+enum param_type_t {
+    PARAM_TYPE_VIRTUALX_FORCE = 0,
+    PARAM_TYPE_VIRTUALX_GENERAL,
+    PARAM_TYPE_TRUSURROUNDX,
+    PARAM_TYPE_TRUSURROUNDX_DC,
+    PARAM_TYPE_LOUNDNESS,
+    PARAM_TYPE_TBHDX,
+    PARAM_TYPE_MBHL,
+    PARAM_TYPE_AEQ,
+    PARAM_TYPE_GEQ,
+    PARAM_TYPE_ILDETECT,
+    PARAM_TYPE_DEBUG,
+    PARAM_TYPE_AM_UI,
+    PARAM_TYPE_MAX,
+};
+
+enum param_type_t param_name_to_param_type(const char * paramName)
+{
+    if (!strncmp(paramName, "--virtualx-tsx", strlen("--virtualx-tsx")))  {
+        return PARAM_TYPE_TRUSURROUNDX;
+    } else if (!strncmp(paramName, "--virtualx-dialogclarity", strlen("--virtualx-dialogclarity")) ||
+               !strncmp(paramName, "--virtualx-definition", strlen("--virtualx-definition"))) {
+        return PARAM_TYPE_TRUSURROUNDX_DC;
+    } else if (!strncmp(paramName, "--virtualx", strlen("--virtualx"))) {
+        return PARAM_TYPE_VIRTUALX_GENERAL;
+    } else if (!strncmp(paramName, "--tbhdx", strlen("--tbhdx")))  {
+        return PARAM_TYPE_TBHDX;
+    } else if (!strncmp(paramName, "--loudness", strlen("--loudness"))) {
+        return PARAM_TYPE_LOUNDNESS;
+    }  else if (!strncmp(paramName, "--mbhl", strlen("--mbhl"))) {
+        return PARAM_TYPE_MBHL;
+    } else if (!strncmp(paramName, "--aeq", strlen("--aeq"))) {
+        return PARAM_TYPE_AEQ;
+    } else if (!strncmp(paramName, "--geq", strlen("--geq"))) {
+        return PARAM_TYPE_GEQ;
+    } else if (!strncmp(paramName, "--ildetect", strlen("--ildetect"))) {
+        return PARAM_TYPE_ILDETECT;
+    } else if (!strncmp(paramName, "--frame-size", strlen("--frame-size")) ||
+               !strncmp(paramName, "--input-pcm-stride", strlen("--input-pcm-stride")) ||
+               !strncmp(paramName, "--output-pcm-stride", strlen("--output-pcm-stride"))) {
+        return PARAM_TYPE_VIRTUALX_FORCE;
+    } else if (!strncmp(paramName, "--show", strlen("--show"))) {
+        return PARAM_TYPE_DEBUG;
+    } else if (!strncmp(paramName, "--am", strlen("--am"))) {
+        return PARAM_TYPE_AM_UI;
+    }
+    else {
+        return PARAM_TYPE_MAX;
+    }
+}
+
+void split_string(char *str, char *key, char *value)
+{
+    char *token;
+    token = strtok(str, "=");
+    strcpy(key, token);
+    token = strtok(NULL, "=");
+    strcpy(value, token);
+}
+
+void removeSpaces_for_key(char str[]) {
+    int i = 0, j = 0;
+    while (str[i] != '\0') {
+        if (str[i] != ' ') {
+            str[j++] = str[i];
+        }
+        i++;
+    }
+    str[j] = '\0';
+}
+
+void removeSpaces_for_value(char str[]) {
+    int i = 0, j = 0;
+    while (str[i] != '\0') {
+        if (str[i] != ' ') {
+            str[j++] = str[i];
+        }
+        i++;
+    }
+    str[j] = '\0';
+
+    j = strlen(str);;
+    while (j-- > 0) {
+        if (!isdigit(str[j])) {
+            str[j] = 0;
+        } else {
+            break;
+        }
+    }
+}
+
+enum param_type_t param_index_to_param_type(int userId)
+{
+    if (userId == AUDIO_ALL_PARAM_DUMP) {
+        return PARAM_TYPE_DEBUG;
+    } else if ((userId == PARAM_CHANNEL_NUM) ||
+        (userId == PARAM_OUT_CHANNEL_NUM) ||
+        (userId == VIRTUALX4_PARAM_ENABLE) ||
+        (userId == VIRTUALX4_PARAM_SURROUND_MODE) ||
+        (userId == VIRTUALX4_PARAM_DIALOGCLARITY_MODE) ||
+        (userId == AUDIO_PARAM_TYPE_TRU_VOLUME) ||
+        (userId == PARAM_LOUDNESS_CONTROL_ENABLE_I32) ||
+        (userId == PARAM_LOUDNESS_CONTROL_IO_MODE_I32) ||
+        (userId == PARAM_AEQ_ENABLE_I32) ||
+        (userId == VIRTUALX_EFFECT_ENABLE) ||
+        (userId == VIRTUALX_USER_MODE)) {
+        return PARAM_TYPE_AM_UI;
+    } else if ((userId >= PARAM_MBHL_ENABLE_I32) && (userId < PARAM_MBHL_PARAM_MAX)) {
+        return PARAM_TYPE_MBHL;
+    } else if ((userId > PARAM_TBHDX_PARAM_START) && (userId < PARAM_TBHDX_PARAM_MAX)) {
+        return PARAM_TYPE_TBHDX;
+    }else if ((userId > PARAM_VX_FORCE_PARAM_START) && (userId < PARAM_VX_FORCE_PARAM_MAX)) {
+        return PARAM_TYPE_VIRTUALX_FORCE;
+    } else if ((userId > PARAM_VX_GENERAL_PARAM_START) && (userId < PARAM_VX_GENERAL_PARAM_MAX)) {
+        return PARAM_TYPE_VIRTUALX_GENERAL;
+    } else if ((userId > PARAM_TSX_PARAM_START) && (userId < PARAM_TSX_PARAM_MAX)) {
+        return PARAM_TYPE_TRUSURROUNDX;
+    } else if ((userId > PARAM_VX_DC_PARAM_START) && (userId < PARAM_VX_DC_PARAM_MAX)) {
+        return PARAM_TYPE_TRUSURROUNDX_DC;
+    } else if ((userId > PARAM_LOUDNESS_PARAM_START) && (userId < PARAM_LOUDNESS_PARAM_MAX)) {
+        return PARAM_TYPE_LOUNDNESS;
+    } else if ((userId > PARAM_AEQ_PARAM_START) && (userId < PARAM_AEQ_PARAM_MAX)) {
+        return PARAM_TYPE_AEQ;
+    } else if ((userId > PARAM_GEQ_PARAM_START) && (userId < PARAM_GEQ_PARAM_MAX)) {
+        return PARAM_TYPE_GEQ;
+    } else if ((userId > PARAM_IL_PARAM_START) && (userId < PARAM_IL_PARAM_MAX)) {
+        return PARAM_TYPE_ILDETECT;
+    }
+    LOG("%s() Error, Unsupport paramIndex:%d\n",__func__, userId);
+    return PARAM_TYPE_MAX;
+}
+
+int get_vx_cmd_table_from_paramType(VX_Cmd_Param **table, int *size, int paramType)
+{
+    if (paramType == PARAM_TYPE_MAX) {
+        LOG("%s() Invalid paramType:%d", __func__, paramType);
+        return -1;
+    }
+
+    switch (paramType) {
+    case PARAM_TYPE_VIRTUALX_FORCE:
+       *table = virtualx_force_params;
+       *size = AM_ARRAY_SIZE(virtualx_force_params);
+        break;
+    case PARAM_TYPE_VIRTUALX_GENERAL:
+        *table = virtualx_general_params;
+        *size = AM_ARRAY_SIZE(virtualx_general_params);
+        break;
+    case PARAM_TYPE_TRUSURROUNDX:
+        *table = virtualx_truSurroundX_params;
+        *size = AM_ARRAY_SIZE(virtualx_truSurroundX_params);
+        break;
+    case PARAM_TYPE_TRUSURROUNDX_DC:
+        *table = virtualx_truSurroundX_DC_params;
+        *size = AM_ARRAY_SIZE(virtualx_truSurroundX_DC_params);
+        break;
+    case PARAM_TYPE_LOUNDNESS:
+        *table = virtualx_loundness_params;
+        *size = AM_ARRAY_SIZE(virtualx_loundness_params);
+        break;
+    case PARAM_TYPE_TBHDX:
+        *table = virtualx_TBHDX_params;
+        *size = AM_ARRAY_SIZE(virtualx_TBHDX_params);
+        break;
+    case PARAM_TYPE_MBHL:
+        *table = virtualx_MBHL_params;
+        *size = AM_ARRAY_SIZE(virtualx_MBHL_params);
+        break;
+    case PARAM_TYPE_AEQ:
+        *table = virtualx_AEQ_params;
+        *size = AM_ARRAY_SIZE(virtualx_AEQ_params);
+        break;
+    case PARAM_TYPE_GEQ:
+        *table = virtualx_GEQ_params;
+        *size = AM_ARRAY_SIZE(virtualx_GEQ_params);
+        break;
+    case PARAM_TYPE_ILDETECT:
+        *table = virtualx_ildetect_params;
+        *size = AM_ARRAY_SIZE(virtualx_ildetect_params);
+        break;
+    case PARAM_TYPE_DEBUG:
+        *table = vx_show_config_params;
+        *size = AM_ARRAY_SIZE(vx_show_config_params);
+        break;
+    case PARAM_TYPE_AM_UI:
+        *table = vx_ui_interface_params;
+        *size = AM_ARRAY_SIZE(vx_ui_interface_params);
+        break;
+    default:
+         LOG("%s() unknown paramType:%d \n", __func__, paramType);
+        return -1;
+    }
+    return 0;
+}
+
+VX_Cmd_Param * get_VXCmd_from_param_name(const char *paramName)
+{
+    if (!paramName) {
+        LOG("%s() param name = NULL!\n", __func__);
+        return NULL;
+    }
+
+    enum param_type_t paramType = param_name_to_param_type(paramName);
+    if (paramType == PARAM_TYPE_MAX) {
+        LOG("%s() can not get param_type from paramName:%s\n", __func__, paramName);
+        return NULL;
+    }
+
+    VX_Cmd_Param *vxCmdTable = NULL;
+    int tableSize = 0;
+    VX_Cmd_Param *retVxCmd = NULL;
+    int ret = 0;
+
+    ret = get_vx_cmd_table_from_paramType(&vxCmdTable, &tableSize, paramType);
+    if (ret < 0 || !vxCmdTable || !tableSize) {
+        LOG("%s() Not find VX_Cmd_Param table\n", __func__);
+        return NULL;
+    }
+
+    for (int i = 0; i < tableSize; i++) {
+        VX_Cmd_Param *temp = &vxCmdTable[i];
+        if (strncmp(temp->param, paramName, strlen(temp->param)) == 0) {
+            retVxCmd = temp;
+            break;
+        }
+    }
+    return retVxCmd;
+}
+
+VX_Cmd_Param * get_VXCmd_from_param_index(int paramIndex)
+{
+    VX_Cmd_Param *vxCmdTable = NULL;
+    int tableSize = 0;
+    VX_Cmd_Param *retVxCmd = NULL;
+    int ret  = 0;
+    int paramType = param_index_to_param_type(paramIndex);
+
+    ret = get_vx_cmd_table_from_paramType(&vxCmdTable, &tableSize, paramType);
+    if (ret < 0 || !vxCmdTable || !tableSize) {
+        LOG("%s() Can't find VX_Cmd_Param table!\n", __func__);
+        return NULL;
+    }
+
+    for (int i = 0; i < tableSize; i++) {
+        VX_Cmd_Param *temp = &vxCmdTable[i];
+        if (temp->userId == paramIndex) {
+            retVxCmd = temp;
+            break;
+        }
+    }
+
+    return retVxCmd;
+}
+
+/******************************** End ********************************************/
+
+void init_effect_param_data(Virtualx_v4_param_t *vxParam, int paramIndex, const char *vbuf)
+{
+    if (paramIndex < 0 || !vbuf) {
+        return;
+    }
+
+    vxParam->param.status = 0;
+    vxParam->param.psize = 4;
+    vxParam->command = paramIndex;
+
+    /* init effect_param_t with integer type value */
+    if ((paramIndex == PARAM_CHANNEL_NUM) ||
+        (paramIndex == PARAM_OUT_CHANNEL_NUM) ||
+        (paramIndex == VIRTUALX_PARAM_ENABLE) ||
+        (paramIndex == VIRTUALX4_PARAM_SURROUND_MODE) ||
+        (paramIndex == VIRTUALX4_PARAM_DIALOGCLARITY_MODE) ||
+        (paramIndex == AUDIO_PARAM_TYPE_TRU_VOLUME) ||
+        (paramIndex == PARAM_LOUDNESS_CONTROL_ENABLE_I32) ||
+        (paramIndex == PARAM_LOUDNESS_CONTROL_IO_MODE_I32) ||
+        (paramIndex == PARAM_AEQ_ENABLE_I32) ||
+        (paramIndex == VIRTUALX_EFFECT_ENABLE) ||
+        (paramIndex == VIRTUALX_USER_MODE))
+    {
+        vxParam->param.vsize = sizeof(int);
+        sscanf(vbuf, "%d", &vxParam->v);
+        LOGV(">>[Line: %d] ParamIndex:%d, ParamValueInt:%d \n", __LINE__, paramIndex, vxParam->v);
+    }
+    else /* c-string type value */
+    {
+        /*
+         *Note: Compared to DTS VX2, the dts vx4 lib parameter accepts string format and init format.
+         *means that arrays of type float and data in float format no longer need to be constructed
+        */
+        vxParam->param.vsize = MAX_PARAM_VALUE_LEN;
+        strncpy(vxParam->str, vbuf, MAX_PARAM_VALUE_LEN);
+        LOGV(">>[Line: %d] ParamIndex:%d, ParamValueBuf:%s \n", __LINE__, paramIndex, vxParam->str);
+    }
+}
+
+/* Enter AML_EFFECT_VIRTUALX_v4 when enter effect_tool for the first time */
+int set_param_from_cmd_line(int argc, char **argv)
+{
+    int effectIndex = 0;
+    int paramIndex = -1;
+    char paramIndexBuf[VX4_MAX_PARAM_VALUE_STR_LEN] = {0};
+    Virtualx_v4_param_t *vxParam  = getVxParamInstance();
+    VX_Cmd_Param *vxCmd = getVxCmdParamInstance();
+
+    memset(vxParam, 0, sizeof(Virtualx_v4_param_t));
+    setVxCmdParamInstance(NULL);
+
+    sscanf(argv[1], "%d", &effectIndex);
+    strncpy(paramIndexBuf, argv[2], VX4_MAX_PARAM_VALUE_STR_LEN);
+    paramIndexBuf[VX4_MAX_PARAM_VALUE_STR_LEN - 1] = '\0';
+
+    if (strstr(paramIndexBuf, "--") != NULL)
+    {
+        vxCmd = get_VXCmd_from_param_name(paramIndexBuf);
+        if (!vxCmd) {
+            LOG(">>main() parse <ParamIndex> Failed! paramIndexBuf:%s\n", paramIndexBuf);
+            return -1;
+        }
+
+        setVxCmdParamInstance(vxCmd);
+        paramIndex = vxCmd->userId;
+    }
+    else
+    {
+        if (sscanf(paramIndexBuf, "%d", &paramIndex) != 1) {
+            LOG(">>main() [%d] <ParamIndex> Failed!\n",__LINE__);
+            return -1;
+        }
+
+        vxCmd = get_VXCmd_from_param_index(paramIndex);
+        if (!vxCmd) {
+            LOG(">>main() [%d] Not find VXCmd for ParamIndex:%d\n",__LINE__, paramIndex);
+            return -1;
+        }
+
+        setVxCmdParamInstance(vxCmd);
+    }
+
+    //-------------------set parameter value by paramIndex integer -----------------------------
+    init_effect_param_data(vxParam, paramIndex, argv[3]);
+    LOGV("%s():[%d] EffectIndex:%d, ParamIndex:%d, ParamValueBuf:%s\n",__func__,__LINE__, effectIndex, paramIndex, argv[3]);
+    return paramIndex;
+}
+
+int getIntData (int *data)
+{
+    int status = scanf("%d", data);
+    if (status == 0) {
+        int status_temp = scanf("%*s");
+        if (status_temp < 0)
+            LOG("Erorr input! Pls Retry!\n");
+        return -1;
+    }
+    return 0;
+}
+
+int getFloatData (float *data)
+{
+    int status = scanf("%f", data);
+    if (status == 0) {
+        int status_temp = scanf("%*s");
+        if (status_temp < 0)
+            LOG("Erorr input! Pls Retry!\n");
+        return -1;
+    }
+    return 0;
+}
+
+int getCStrData (char *data, char *value)
+{
+    int status_temp,status;
+    status = scanf("%s%s", data, value);
+    if (status == 0) {
+        goto _exit_clear;
+    }
+
+    return 0;
+
+_exit_clear:
+    status_temp= scanf("%*s");
+    if (status_temp < 0) {
+        LOG("Erorr input! Pls Retry!\n");
+    }
+    return -1;
+}
+
+int set_param_for_file_cmd_line(char *line_buf)
+{
+    if (!line_buf || strlen(line_buf) < 4) {
+        LOG("%s() Invalid setting line:%s\n", __func__, line_buf);
+        return -1;
+    }
+
+    char key[64] = {0};
+    char value[16] = {0};
+
+    split_string(line_buf, key, value);
+    removeSpaces_for_key(key);
+    removeSpaces_for_value(value);
+
+    VX_Cmd_Param *vxCmd = NULL;
+    Virtualx_v4_param_t vxParamInstance;
+    Virtualx_v4_param_t *vxParam = &vxParamInstance;
+    int paramIndex = 0;
+    int ret = 0;
+
+    memset(vxParam, 0, sizeof(Virtualx_v4_param_t));
+
+    vxCmd = get_VXCmd_from_param_name(key);
+    if (!vxCmd) {
+        LOG("[Failed] Not find VxCmd for ParamName:%s\n", key);
+        return -1;
+    }
+    paramIndex = vxCmd->userId;
+    init_effect_param_data(vxParam, paramIndex, value);
+    usleep(5000);
+    LOG("[setParameter] [%s] [%s=%s]\n", (ret == 0 ? "OK" : "NG"), key, value);
+    return ret;
+}
+
+void load_ini_session(const char *iniName)
+{
+    ssize_t read;
+    char *line = NULL;
+    size_t len = 0;
+    char filePathName[128] = {0};
+    int caseNum = -1;
+    int found = 0;
+    int found_common = 0;
+    int load_common_setting = 0;
+    int param_count = 0;
+
+    snprintf(filePathName, 128, "/mnt/vendor/odm_ext/etc/tvconfig/audio/%s", iniName);
+    FILE* fp = fopen(filePathName, "r");
+    if (!fp) {
+        LOG("[Failed] fopen() %s\n", filePathName);
+        return;
+    }
+
+    LOG("Please enter Test case Num: ");
+    if (getIntData (&caseNum) < 0) {
+        LOG("[Failed] Invalid case Num, Exit!\n");
+        return;
+    }
+
+    LOG("[Test case %d] Start ...\n", caseNum);
+    while ((read = getline(&line, &len, fp)) > 0)
+    {
+        if (load_common_setting == 0) {
+            if (found_common == 0) {
+                if (strstr(line, "common") != NULL) {
+                    found_common = 1;
+                    continue;
+                }
+            }
+            else
+            {
+                if (strstr(line, "#")) { //one case setting end tag is "#"
+                    load_common_setting = 1;
+                    LOG("[Test case %d] load common setting done!\n", caseNum);
+                    continue;;
+                }
+                set_param_for_file_cmd_line(line);
+            }
+            continue;
+        }
+
+        if (caseNum == 666) //load all setting without case
+        {
+            set_param_for_file_cmd_line(line);
+        }
+        else
+        { //load specified case number setting
+            if (found == 0) {
+                char *temp = NULL;
+                if ((temp = strstr(line, "case_")) != NULL) {
+                    int temp_case_num = atoi(temp + 5);
+                    if (temp_case_num == caseNum) {
+                        found = 1;
+                        continue;
+                    }
+                }
+            }
+
+            if (found) {
+                if (strstr(line, "#")) { //one case setting end tag is "#"
+                    break;
+                }
+
+                set_param_for_file_cmd_line(line);
+                param_count++;
+            }
+        }
+    }
+    LOG("[Test case %d] Done! Apply params:%d\n", caseNum, param_count);
+}
+
+//Only support part of paramIndex setting
+//The param value type must be: single integer or single float input
+int set_param_from_scanf(int effectIndex)
+{
+    int paramIndex = -1;
+    char paramIndexBuf[128] = {0};
+    char valueBuf[MAX_PARAM_VALUE_LEN] = {0};
+    Virtualx_v4_param_t *vxParam = getVxParamInstance();
+    VX_Cmd_Param *vxCmd = getVxCmdParamInstance();
+
+    memset(vxParam, 0, sizeof(Virtualx_v4_param_t));
+    setVxCmdParamInstance(NULL);
+
+    if (getCStrData(paramIndexBuf, valueBuf) < 0) {
+        LOG(">>%s():scanf() [%d] <ParamIndex> Failed!\n",__func__, __LINE__);
+        return -1;
+    }
+
+    if (strstr(paramIndexBuf, "--") != NULL)
+    {
+        VX_Cmd_Param *vxCmd = get_VXCmd_from_param_name(paramIndexBuf);
+        if (!vxCmd) {
+            LOG(">>scanf() [%d] Can't find <ParamIndex> for ParamName:%s\n",__LINE__, paramIndexBuf);
+            return -1;
+        }
+        setVxCmdParamInstance(vxCmd);
+        paramIndex = vxCmd->userId;
+    }
+    else
+    {
+        if (sscanf(paramIndexBuf, "%d", &paramIndex) != 1) {
+            LOG(">>scanf() [%d] <ParamIndex> Failed!\n",__LINE__);
+            return -1;
+        }
+
+        if (paramIndex == DTS_PARAM_READE_INI) {
+            goto _load_ini;
+        }
+
+        vxCmd = get_VXCmd_from_param_index(paramIndex);
+        if (!vxCmd) {
+            LOG(">>scanf() [%d] Not find VXCmd for ParamIndex:%d\n",__LINE__, paramIndex);
+            return -1;
+        }
+        setVxCmdParamInstance(vxCmd);
+    }
+
+    //-------------------set parameter value by paramIndex integer -----------------------------
+    init_effect_param_data(vxParam, paramIndex, valueBuf);
+
+    LOGV(">>scanf() [%d] EffectIndex:%d, ParamIndex:%d, ParamValueBuf:%s\n",__LINE__, effectIndex, paramIndex, vxParam->str);
+    return paramIndex;
+
+_load_ini:
+    //load_ini_session(gAudioEffect, valueBuf);
+    LOG(">>scanf() %d:download init file!\n",__LINE__);
+    return -1;
+
+}
+
+void printf_vx4_help(char *name)
+{
+    LOG("*********************************Virtualx***********************************\n");
+    LOG("VirtualX EffectIndex: %d\n", 6);
+    LOG("Usage: %s %d <ParamIndex> <ParamValue/ParamScale/gParamBand>\n", name, 6);
+    LOG("------------Multi band hard limiter----ParamIndex(from %d to %d)-----\n",
+        (int)PARAM_MBHL_ENABLE_I32, (int)PARAM_MBHL_PARAM_MAX -1);
+    LOG("ParamIndex: %d -> Mbhl Enable\n", (int)PARAM_MBHL_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> Mbhl Bypass Gain\n", (int)PARAM_MBHL_BYPASS_GAIN_I32);
+    LOG("ParamScale: 0.0 ~ 1.0\n");
+    LOG("ParamIndex: %d -> Mbhl Reference Level\n", (int)PARAM_MBHL_REFERENCE_LEVEL_I32);
+    LOG("ParamScale: 0.0009 ~ 1.0\n");
+    LOG("ParamIndex: %d -> Mbhl Volume\n", (int)PARAM_MBHL_VOLUME_I32);
+    LOG("ParamScale: 0.0 ~ 1.0\n");
+    LOG("ParamIndex: %d -> Mbhl Volume Step\n", (int)PARAM_MBHL_VOLUME_STEP_I32);
+    LOG("ParamValue: 0 ~ 100\n");
+    LOG("ParamIndex: %d -> Mbhl Balance Step\n", (int)PARAM_MBHL_BALANCE_STEP_I32);
+    LOG("ParamValue: -10 ~ 10\n");
+    LOG("ParamIndex: %d -> Mbhl Output Gain\n", (int)PARAM_MBHL_OUTPUT_GAIN_I32);
+    LOG("ParamScale: 0.0 ~ 1.0\n");
+    LOG("ParamIndex: %d -> Mbhl Mode\n", (int)PARAM_MBHL_MODE_I32);
+    LOG("ParamValue: 0 ~ 4\n");
+    LOG("ParamIndex: %d -> Mbhl process Discard\n", (int)PARAM_MBHL_PROCESS_DISCARD_I32);
+    LOG("ParamValue: 0 ~ 1\n");
+    LOG("ParamIndex: %d -> Mbhl Cross Low\n", (int)PARAM_MBHL_CROSS_LOW_I32);
+    LOG("ParamValue: 0 ~ 20\n");
+    LOG("ParamIndex: %d -> Mbhl Cross Mid\n", (int)PARAM_MBHL_CROSS_MID_I32);
+    LOG("ParamValue: 0 ~ 20\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Attack\n", (int)PARAM_MBHL_COMP_ATTACK_I32);
+    LOG("ParamValue: 0 ~ 100\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Low Release\n", (int)PARAM_MBHL_COMP_LOW_RELEASE_I32);
+    LOG("ParamValue: 50 ~ 2000\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Low Ratio\n", (int)PARAM_MBHL_COMP_LOW_RATIO_I32);
+    LOG("ParamScale: 1.0 ~ 20.0\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Low Thresh\n", (int)PARAM_MBHL_COMP_LOW_THRESH_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Low Makeup\n", (int)PARAM_MBHL_COMP_LOW_MAKEUP_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Mid Release\n", (int)PARAM_MBHL_COMP_MID_RELEASE_I32);
+    LOG("ParamValue: 50 ~ 2000\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Mid Ratio\n", (int)PARAM_MBHL_COMP_MID_RATIO_I32);
+    LOG("ParamScale: 1.0 ~ 20.0\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Mid Thresh\n", (int)PARAM_MBHL_COMP_MID_THRESH_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Comp Mid Makeup\n", (int)PARAM_MBHL_COMP_MID_MAKEUP_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Comp High Release\n", (int)PARAM_MBHL_COMP_HIGH_RELEASE_I32);
+    LOG("ParamValue: 50 ~ 2000\n");
+    LOG("ParamIndex: %d -> Mbhl Comp High Ratio\n", (int)PARAM_MBHL_COMP_HIGH_RATIO_I32);
+    LOG("ParamScale: 1.0 ~ 20.0\n");
+    LOG("ParamIndex: %d -> Mbhl Comp High Thresh\n", (int)PARAM_MBHL_COMP_HIGH_THRESH_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Comp High Makeup\n", (int)PARAM_MBHL_COMP_HIGH_MAKEUP_I32);
+    LOG("ParamScale: 0.0640 ~ 15.8479\n");
+    LOG("ParamIndex: %d -> Mbhl Boost\n", (int)PARAM_MBHL_BOOST_I32);
+    LOG("ParamScale: 0.001 ~ 1000\n");
+    LOG("ParamIndex: %d -> Mbhl Threshold\n", (int)PARAM_MBHL_THRESHOLD_I32);
+    LOG("ParamScale: 0.0640 ~ 1.0\n");
+    LOG("ParamIndex: %d -> Mbhl Slow Offset\n", (int)PARAM_MBHL_SLOW_OFFSET_I32);
+    LOG("ParamScale: 0.317 ~ 3.1619\n");
+    LOG("ParamIndex: %d -> Mbhl Fast Attack\n", (int)PARAM_MBHL_FAST_ATTACK_I32);
+    LOG("ParamScale: 0 ~ 10\n");
+    LOG("ParamIndex: %d -> Mbhl Fast Release\n", (int)PARAM_MBHL_FAST_RELEASE_I32);
+    LOG("ParamValue: 10 ~ 500\n");
+    LOG("ParamIndex: %d -> Mbhl Slow Attack\n", (int)PARAM_MBHL_SLOW_ATTACK_I32);
+    LOG("ParamValue: 100 ~ 1000\n");
+    LOG("ParamIndex: %d -> Mbhl Slow Release\n", (int)PARAM_MBHL_SLOW_RELEASE_I32);
+    LOG("ParamValue: 100 ~ 2000\n");
+    LOG("ParamIndex: %d -> Mbhl Delay\n", (int)PARAM_MBHL_DELAY_I32);
+    LOG("ParamValue: 0 ~ 16\n");
+    LOG("ParamIndex: %d -> Mbhl Envelope Freq\n", (int)PARAM_MBHL_ENVELOPE_FREQUENCY_I32);
+    LOG("ParamValue: 5 ~ 500\n");
+    LOG("ParamIndex: %d -> Mbhl frt lowcross\n", (int)PARAM_MBHL_APP_FRT_LOWCROSS_F32);
+    LOG("ParamScale  40 ~ 8000\n");
+    LOG("ParamIndex: %d -> Mbhl frt midcross\n", (int)PARAM_MBHL_APP_FRT_MIDCROSS_F32);
+    LOG("ParamScale  40 ~ 8000\n");
+
+    LOG("------------TruBassHDX-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_TBHDX_PARAM_START + 1, (int)PARAM_TBHDX_PARAM_MAX -1);
+
+    LOG("------------General Setting-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_VX_ENABLE_I32, (int)PARAM_VX_REFERENCE_LEVEL_I32);
+    LOG("ParamIndex: %d -> VX Enable\n", (int)PARAM_VX_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> VX Input Mode\n", (int)PARAM_VX_INPUT_MODE_I32);
+    LOG("ParamValue: 0 ~ 4\n");
+    LOG("ParamIndex: %d -> VX Output Mode\n", (int)PARAM_VX_OUTPUT_MODE_I32);
+    LOG("ParamValue: Can't be set!\n");
+    LOG("ParamIndex: %d -> VX Head Room Gain\n", (int)PARAM_VX_HEADROOM_GAIN_I32);
+    LOG("ParamScale: 0.125 ~ 1.0\n");
+    LOG("ParamIndex: %d -> VX Proc Output Gain\n", (int)PARAM_VX_PROC_OUTPUT_GAIN_I32);
+    LOG("ParamScale: 0.5 ~ 4.0\n");
+    LOG("ParamIndex: %d -> VX Reference level\n", (int)PARAM_VX_REFERENCE_LEVEL_I32);
+    LOG("ParamValue: Can't be set!\n");
+
+    LOG("------------TrusurroundX-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_TSX_PARAM_START +1, (int)PARAM_TSX_PARAM_MAX -1);
+    LOG("ParamIndex: %d -> TSX Enable\n", (int)PARAM_TSX_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> TSX Passive Matrix Upmixer Enable\n", (int)PARAM_TSX_PASSIVEMATRIXUPMIX_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> TSX Height Upmixer Enable\n", (int)PARAM_TSX_HEIGHT_UPMIX_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> TSX Height Mix Coeff\n", (int)PARAM_TSX_HEIGHTMIX_COEFF_I32);
+    LOG("ParamScale: 0.5 ~ 2.0\n");
+    LOG("ParamIndex: %d -> TSX Process Discard\n", (int)PARAM_TSX_PROCESS_DISCARD_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> TSX Height Discard\n", (int)PARAM_TSX_HEIGHT_DISCARD_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+
+    LOG("------------Dialog Clarty-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_VX_DC_ENABLE_I32, (int)PARAM_VX_DC_CONTROL_I32);
+    LOG("ParamIndex: %d -> VX DC Enable\n", (int)PARAM_VX_DC_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> VX DC Control\n", (int)PARAM_VX_DC_CONTROL_I32);
+    LOG("ParamScale: 0.0 ~ 1.0\n");
+
+    LOG("------------Definition-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_VX_DEF_ENABLE_I32, (int)PARAM_VX_DEF_CONTROL_I32);
+    LOG("ParamIndex: %d -> VX DEF Enable\n", (int)PARAM_VX_DEF_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> VX DEF Control\n", (int)PARAM_VX_DEF_CONTROL_I32);
+    LOG("ParamScale: 0.0 ~ 1.0\n");
+
+    LOG("------------TruVolume-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_LOUDNESS_CONTROL_ENABLE_I32, (int)PARAM_LOUDNESS_CONTROL_IO_MODE_I32);
+    LOG("ParamIndex: %d -> Loudness Control Enable\n", (int)PARAM_LOUDNESS_CONTROL_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> Loudness Control Target Loudness\n", (int)PARAM_LOUDNESS_CONTROL_TARGET_LOUDNESS_I32);
+    LOG("ParamValue: -40 ~ 0\n");
+    LOG("ParamIndex: %d -> Loudness Control Preset\n", (int)PARAM_LOUDNESS_CONTROL_PRESET_I32);
+    LOG("ParamValue: 0 -> light 1 -> mid 2 -> Aggressive \n");
+    LOG("ParamIndex: %d -> Loudness Control Mode\n", (int)PARAM_LOUDNESS_CONTROL_IO_MODE_I32);
+    LOG("ParamValue: 0 ~ 4 \n");
+    LOG("****************************************************************************\n\n");
+
+    LOG("------------DTSEQ-------ParamIndex(from %d to %d)--\n",
+        (int)PARAM_AEQ_ENABLE_I32, (int)PARAM_AEQ_BAND_type);
+    LOG("ParamIndex: %d -> AEQ  Enable\n", (int)PARAM_AEQ_ENABLE_I32);
+    LOG("ParamValue: 0 -> Disable   1 -> Enable\n");
+    LOG("ParamIndex: %d -> AEQ  input gain\n", (int)PARAM_AEQ_INPUT_GAIN_I16);
+    LOG("ParamScale: 0.000 ~ 1.0\n");
+    LOG("ParamIndex: %d -> AEQ  output gain\n", (int)PARAM_AEQ_OUTPUT_GAIN_I16);
+    LOG("ParamScale: 0.000 ~ 1.0\n");
+    LOG("ParamIndex: %d -> AEQ  bypass gain\n", (int)PARAM_AEQ_BYPASS_GAIN_I16);
+    LOG("ParamScale: 0.000 ~ 1.0\n");
+    LOG("ParamIndex: %d -> AEQ  fre\n", (int)PARAM_AEQ_BAND_Fre);
+    LOG("ParamValue: 20 ~ 20000\n");
+    LOG("ParamIndex: %d -> AEQ  band gain\n", (int)PARAM_AEQ_BAND_Gain);
+    LOG("ParamValue: -12db ~ 12db\n");
+    LOG("ParamIndex: %d -> AEQ  band Q\n", (int)PARAM_AEQ_BAND_Q);
+    LOG("ParamValue: 0.25 ~ 16\n");
+    LOG("ParamIndex: %d -> AEQ  band type\n", (int)PARAM_AEQ_BAND_type);
+    LOG("ParamValue: 0:Traditional | 1:LowShelf | 2:High Shelf | 9:Null ]\n");
+    LOG("ParamIndex: %d -> DTS source channel num\n", (int)PARAM_CHANNEL_NUM);
+    LOG("ParamValue: 2 | 6 \n");
+
+    LOG("------------Debug interface------------\n");
+    LOG("ParamIndex: %d -> Get all parameters from VX lib\n", (int)AUDIO_ALL_PARAM_DUMP);
+    LOG("ParamValue: 0 \n");
+    LOG("****************************************************************************\n\n");
+}
+