Add support for more filters

SOUND_FILTER_LOW_PASS, SOUND_FILTER_HIGH_PASS, SOUND_FILTER_DELAY are added.
Added to check if the preset is valid for filter.

[Version] 0.4.16
[Issue Type] Enhancement

Change-Id: I124f7f1aac227b0fc03fb5a733acedc2f24f0705
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/include/sound_manager_internal.h b/include/sound_manager_internal.h
index a63c9a7..7d4b494 100644 (file)
--- a/include/sound_manager_internal.h
+++ b/include/sound_manager_internal.h
@@ -79,7 +79,9 @@ typedef enum {
  * @since_tizen 4.0
  */
 typedef enum {
-       SOUND_FILTER_NONE = 0,
+       SOUND_FILTER_LOW_PASS = 0,
+       SOUND_FILTER_HIGH_PASS,
+       SOUND_FILTER_DELAY,
        SOUND_FILTER_SOUNDALIVE,
 } sound_filter_e;
 
@@ -89,12 +91,21 @@ typedef enum {
  * @since_tizen 4.0
  */
 typedef enum {
-       SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL = 0,   /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_TUBE,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_CLUB,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL, /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
+       SOUND_FILTER_PRESET_LOW_PASS_NONE = 0,       /**< Filter preset for SOUND_FILTER_LOW_PASS none */
+       SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ,    /**< Filter preset for SOUND_FILTER_LOW_PASS under 240hz */
+       SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ,    /**< Filter preset for SOUND_FILTER_LOW_PASS under 480hz */
+       SOUND_FILTER_PRESET_HIGH_PASS_NONE,          /**< Filter preset for SOUND_FILTER_HIGH_PASS none */
+       SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ,    /**< Filter preset for SOUND_FILTER_HIGH_PASS over 240hz */
+       SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ,    /**< Filter preset for SOUND_FILTER_HIGH_PASS over 480hz */
+       SOUND_FILTER_PRESET_DELAY_NONE,              /**< Filter preset for SOUND_FILTER_DELAY none */
+       SOUND_FILTER_PRESET_DELAY_1SEC,              /**< Filter preset for SOUND_FILTER_DELAY 1 second */
+       SOUND_FILTER_PRESET_DELAY_2SEC,              /**< Filter preset for SOUND_FILTER_DELAY 2 seconds */
+       SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE normal */
+       SOUND_FILTER_PRESET_SOUNDALIVE_TUBE,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE tube */
+       SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE virtual7.1 */
+       SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE studio */
+       SOUND_FILTER_PRESET_SOUNDALIVE_CLUB,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE club */
+       SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL, /**< Filter preset for SOUND_FILTER_SOUNDALIVE concert hall */
 } sound_filter_preset_e;
 
 /**

diff --git a/include/sound_manager_internal_tv.h b/include/sound_manager_internal_tv.h
index 000ee33..2d4af1a 100644 (file)
--- a/include/sound_manager_internal_tv.h
+++ b/include/sound_manager_internal_tv.h
@@ -79,7 +79,9 @@ typedef enum {
  * @since_tizen 4.0
  */
 typedef enum {
-       SOUND_FILTER_NONE = 0,
+       SOUND_FILTER_LOW_PASS = 0,
+       SOUND_FILTER_HIGH_PASS,
+       SOUND_FILTER_DELAY,
        SOUND_FILTER_SOUNDALIVE,
 } sound_filter_e;
 
@@ -89,12 +91,21 @@ typedef enum {
  * @since_tizen 4.0
  */
 typedef enum {
-       SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL = 0,   /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_TUBE,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_CLUB,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
-       SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL, /**< Filter preset for SOUND_FILTER_SOUNDALIVE */
+       SOUND_FILTER_PRESET_LOW_PASS_NONE = 0,       /**< Filter preset for SOUND_FILTER_LOW_PASS none */
+       SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ,    /**< Filter preset for SOUND_FILTER_LOW_PASS under 240hz */
+       SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ,    /**< Filter preset for SOUND_FILTER_LOW_PASS under 480hz */
+       SOUND_FILTER_PRESET_HIGH_PASS_NONE,          /**< Filter preset for SOUND_FILTER_HIGH_PASS none */
+       SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ,    /**< Filter preset for SOUND_FILTER_HIGH_PASS over 240hz */
+       SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ,    /**< Filter preset for SOUND_FILTER_HIGH_PASS over 480hz */
+       SOUND_FILTER_PRESET_DELAY_NONE,              /**< Filter preset for SOUND_FILTER_DELAY none */
+       SOUND_FILTER_PRESET_DELAY_1SEC,              /**< Filter preset for SOUND_FILTER_DELAY 1 second */
+       SOUND_FILTER_PRESET_DELAY_2SEC,              /**< Filter preset for SOUND_FILTER_DELAY 2 seconds */
+       SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE normal */
+       SOUND_FILTER_PRESET_SOUNDALIVE_TUBE,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE tube */
+       SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE virtual7.1 */
+       SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO,       /**< Filter preset for SOUND_FILTER_SOUNDALIVE studio */
+       SOUND_FILTER_PRESET_SOUNDALIVE_CLUB,         /**< Filter preset for SOUND_FILTER_SOUNDALIVE club */
+       SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL, /**< Filter preset for SOUND_FILTER_SOUNDALIVE concert hall */
 } sound_filter_preset_e;
 
 /**

diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec
index bd93ba5..d0a3d4d 100644 (file)
--- a/packaging/capi-media-sound-manager.spec
+++ b/packaging/capi-media-sound-manager.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-sound-manager
 Summary:    Sound Manager library
-Version:    0.4.15
+Version:    0.4.16
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager_internal.c b/src/sound_manager_internal.c
index bc4618c..ff159c6 100644 (file)
--- a/src/sound_manager_internal.c
+++ b/src/sound_manager_internal.c
@@ -307,24 +307,33 @@ int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream)
 
 static int _convert_filter(sound_filter_e filter, char **filter_str, char **filter_params_str)
 {
-       int ret = MM_ERROR_NONE;
-
-       if (filter_str == NULL)
+       if (filter_str == NULL || filter_params_str == NULL)
                return MM_ERROR_INVALID_ARGUMENT;
 
        switch (filter) {
+       case SOUND_FILTER_LOW_PASS:
+               *filter_str = "ladspa-sink";
+               *filter_params_str = "plugin=filter label=lpf control=22050";
+               break;
+       case SOUND_FILTER_HIGH_PASS:
+               *filter_str = "ladspa-sink";
+               *filter_params_str = "plugin=filter label=hpf control=2";
+               break;
+       case SOUND_FILTER_DELAY:
+               *filter_str = "ladspa-sink";
+               *filter_params_str = "plugin=delay label=delay_5s control=0,0";
+               break;
        case SOUND_FILTER_SOUNDALIVE:
                *filter_str = "ladspa-sink";
                *filter_params_str = "plugin=audiofilters-sec-ladspa label=audiofiltersec_stereo control=1,0";
                break;
        default:
                LOGE("could not find filter[%d]", filter);
-               ret = MM_ERROR_SOUND_INTERNAL;
-               break;
+               return MM_ERROR_SOUND_INTERNAL;
        }
-       LOGI("filter[%s]", *filter_str);
+       LOGI("filter[%s], param[%s]", *filter_str, *filter_params_str);
 
-       return ret;
+       return MM_ERROR_NONE;
 }
 
 static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
@@ -335,6 +344,33 @@ static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
                return MM_ERROR_INVALID_ARGUMENT;
 
        switch (preset) {
+       case SOUND_FILTER_PRESET_LOW_PASS_NONE:
+               *control = "22050";
+               break;
+       case SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ:
+               *control = "240";
+               break;
+       case SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ:
+               *control = "480";
+               break;
+       case SOUND_FILTER_PRESET_HIGH_PASS_NONE:
+               *control = "2";
+               break;
+       case SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ:
+               *control = "240";
+               break;
+       case SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ:
+               *control = "480";
+               break;
+       case SOUND_FILTER_PRESET_DELAY_NONE:
+               *control = "0,0";
+               break;
+       case SOUND_FILTER_PRESET_DELAY_1SEC:
+               *control = "1,0.5";
+               break;
+       case SOUND_FILTER_PRESET_DELAY_2SEC:
+               *control = "2,0.5";
+               break;
        case SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL:
                *control = "1,0";
                break;
@@ -363,6 +399,45 @@ static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
        return ret;
 }
 
+static int _check_valid_filter_preset(sound_filter_e filter, sound_filter_preset_e preset)
+{
+       switch (filter) {
+       case SOUND_FILTER_LOW_PASS:
+               if (preset < SOUND_FILTER_PRESET_LOW_PASS_NONE || preset > SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ) {
+                       LOGE("invalid preset(%d) for low pass filter", preset);
+                       goto ERROR_INVALID_ARGS;
+               }
+               break;
+       case SOUND_FILTER_HIGH_PASS:
+               if (preset < SOUND_FILTER_PRESET_HIGH_PASS_NONE || preset > SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ) {
+                       LOGE("invalid preset(%d) for high pass filter", preset);
+                       goto ERROR_INVALID_ARGS;
+               }
+               break;
+       case SOUND_FILTER_DELAY:
+               if (preset < SOUND_FILTER_PRESET_DELAY_NONE || preset > SOUND_FILTER_PRESET_DELAY_2SEC) {
+                       LOGE("invalid preset(%d) for delay filter", preset);
+                       goto ERROR_INVALID_ARGS;
+               }
+               break;
+       case SOUND_FILTER_SOUNDALIVE:
+               if (preset < SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL || preset > SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL) {
+                       LOGE("invalid preset(%d) for soundAlive filter", preset);
+                       goto ERROR_INVALID_ARGS;
+               }
+               break;
+       default:
+               LOGE("invalid filter(%d)", filter);
+               return MM_ERROR_INVALID_ARGUMENT;
+       }
+
+       return MM_ERROR_NONE;
+
+ERROR_INVALID_ARGS:
+       LOGE("invalid preset(%d) for filter(%d)", preset, filter);
+       return MM_ERROR_INVALID_ARGUMENT;
+}
+
 int sound_manager_set_filter(sound_stream_type_e stream_type, sound_filter_e filter)
 {
        int ret = MM_ERROR_NONE;
@@ -371,27 +446,16 @@ int sound_manager_set_filter(sound_stream_type_e stream_type, sound_filter_e fil
 
        LOGI(">> enter");
 
+       if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
+               ret = MM_ERROR_NOT_SUPPORT_API;
+               goto LEAVE;
+       }
        if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
                goto LEAVE;
        if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != MM_ERROR_NONE)
                goto LEAVE;
 
-       switch (filter) {
-       case SOUND_FILTER_NONE:
-               ret = SOUND_MANAGER_ERROR_NOT_SUPPORTED;
-               LOGI("no filter apply");
-               break;
-       case SOUND_FILTER_SOUNDALIVE:
-               if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != MM_ERROR_NONE)
-                       break;
-               ret = mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str);
-               LOGI("apply SoundAlive filter");
-               break;
-       default:
-               ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
-               LOGE("invaid sound filter");
-               break;
-       }
+       ret = mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str);
 
 LEAVE:
        return _convert_sound_manager_error_code(__func__, ret);
@@ -423,6 +487,12 @@ int sound_manager_set_filter_preset(sound_stream_type_e stream_type, sound_filte
 
        LOGI(">> enter");
 
+       if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
+               ret = MM_ERROR_NOT_SUPPORT_API;
+               goto LEAVE;
+       }
+       if ((ret = _check_valid_filter_preset(filter, preset)))
+               goto LEAVE;
        if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != MM_ERROR_NONE)
                goto LEAVE;
        if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != MM_ERROR_NONE)
@@ -430,20 +500,7 @@ int sound_manager_set_filter_preset(sound_stream_type_e stream_type, sound_filte
        if ((ret = _convert_filter_preset(preset, &control_str)) != MM_ERROR_NONE)
                goto LEAVE;
 
-       switch (filter) {
-       case SOUND_FILTER_NONE:
-               ret = SOUND_MANAGER_ERROR_NOT_SUPPORTED;
-               LOGI("no filter preset");
-               break;
-       case SOUND_FILTER_SOUNDALIVE:
-               ret = mm_sound_control_filter(stream_type_str, filter_str, control_str);
-               LOGI("apply SoundAlive filter");
-               break;
-       default:
-               ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
-               LOGE("invaid sound filter");
-               break;
-       }
+       ret = mm_sound_control_filter(stream_type_str, filter_str, control_str);
 
 LEAVE:
        return _convert_sound_manager_error_code(__func__, ret);
@@ -494,4 +551,3 @@ int sound_manager_get_device_product_id(sound_device_h device, int *product_id)
 
        return _convert_sound_manager_error_code(__func__, ret);
 }
-

diff --git a/test/sound_manager_test.c b/test/sound_manager_test.c
index 73c859b..7799705 100644 (file)
--- a/test/sound_manager_test.c
+++ b/test/sound_manager_test.c
@@ -92,6 +92,9 @@ enum {
        CURRENT_STATUS_START_VIRTUAL_STREAM,
        CURRENT_STATUS_STOP_VIRTUAL_STREAM,
        CURRENT_STATUS_DESTROY_VIRTUAL_STREAM,
+       CURRENT_STATUS_SET_FILTER,
+       CURRENT_STATUS_SET_FILTER_PRESET,
+       CURRENT_STATUS_UNSET_FILTER,
 #ifndef TIZEN_FEATURE_TV_PROD
        CURRENT_STATUS_GET_MAX_MASTER_VOLUME,
        CURRENT_STATUS_SET_MASTER_VOLUME,
@@ -278,6 +281,12 @@ void _interpret_main_menu(char *cmd)
                g_menu_state = CURRENT_STATUS_STOP_VIRTUAL_STREAM;
        else if (strncmp(cmd, "vdt", 3) == 0)
                g_menu_state = CURRENT_STATUS_DESTROY_VIRTUAL_STREAM;
+       else if (strncmp(cmd, "sft", 3) == 0)
+               g_menu_state = CURRENT_STATUS_SET_FILTER;
+       else if (strncmp(cmd, "sfp", 3) == 0)
+               g_menu_state = CURRENT_STATUS_SET_FILTER_PRESET;
+       else if (strncmp(cmd, "uft", 3) == 0)
+               g_menu_state = CURRENT_STATUS_UNSET_FILTER;
 #ifndef TIZEN_FEATURE_TV_PROD
        else if (strncmp(cmd, "mgx", 3) == 0)
                g_menu_state = CURRENT_STATUS_GET_MAX_MASTER_VOLUME;
@@ -375,6 +384,9 @@ void display_sub_basic()
        g_print("vsr. *Start VStream\t");
        g_print("vst. *Stop VStream\t");
        g_print("vdt. *Destroy VStream\n");
+       g_print("sft. *Set Filter\t");
+       g_print("sfp. *Set Filter Preset\t");
+       g_print("uft. *Unset Filter\n");
        g_print("                                                                 * is for internal usage.\n");
        g_print("=========================================================================================\n");
 }
@@ -513,6 +525,12 @@ static void displaymenu()
                g_print("*** press enter to stop virtual stream\n");
        else if (g_menu_state == CURRENT_STATUS_DESTROY_VIRTUAL_STREAM)
                g_print("*** press enter to destroy virtual stream\n");
+       else if (g_menu_state == CURRENT_STATUS_SET_FILTER)
+               g_print("*** input filter type of media stream (0:LOW_PASS 1:HIGH_PASS 2:DELAY 3:SOUNDALIVE)\n");
+       else if (g_menu_state == CURRENT_STATUS_SET_FILTER_PRESET)
+               g_print("*** input filter preset of media stream (LOW_PASS(1:none 2:240hz 3:480hz), HIGH_PASS(3:none 4:240hz 5:480hz) DELAY(6:none 7:1sec 8:2sec) SOUNDALIVE(9:normal 10:concert_hall))\n");
+       else if (g_menu_state == CURRENT_STATUS_UNSET_FILTER)
+               g_print("*** press enter to unset filter of media stream\n");
 #ifndef TIZEN_FEATURE_TV_PROD
        else if (g_menu_state == CURRENT_STATUS_GET_MAX_MASTER_VOLUME)
                g_print("*** press enter to get max master volume level\n");
@@ -1971,6 +1989,115 @@ static void interpret(char *cmd)
                reset_menu_state();
                break;
        }
+       case CURRENT_STATUS_SET_FILTER: {
+               int ret = SOUND_MANAGER_ERROR_NONE;
+               sound_filter_e filter;
+               int selection = atoi(cmd);
+               switch (selection) {
+               case 0: /* low pass filter */
+                       filter = SOUND_FILTER_LOW_PASS;
+                       break;
+               case 1: /* high pass filter */
+                       filter = SOUND_FILTER_HIGH_PASS;
+                       break;
+               case 2: /* delay */
+                       filter = SOUND_FILTER_DELAY;
+                       break;
+               case 3: /* soundAlive */
+                       filter = SOUND_FILTER_SOUNDALIVE;
+                       break;
+               default:
+                       filter = SOUND_FILTER_DELAY;
+                       g_print("invalid selection(%d), keep going with filter(%d)\n", selection, filter);
+                       break;
+               }
+
+               ret = sound_manager_set_filter(SOUND_STREAM_TYPE_MEDIA, filter);
+               if (ret)
+                       g_print("fail to sound_manager_set_filter(), ret(0x%x)\n", ret);
+               else
+                       g_print("success to sound_manager_set_filter(), ret(0x%x)\n", ret);
+
+               reset_menu_state();
+               break;
+       }
+       case CURRENT_STATUS_SET_FILTER_PRESET: {
+               int ret = SOUND_MANAGER_ERROR_NONE;
+               sound_filter_e filter;
+               sound_filter_preset_e preset;
+               int selection = atoi(cmd);
+
+               switch (selection) {
+               case 0: /* low pass under none */
+                       filter = SOUND_FILTER_LOW_PASS;
+                       preset = SOUND_FILTER_PRESET_LOW_PASS_NONE;
+                       break;
+               case 1: /* low pass under 240hz */
+                       filter = SOUND_FILTER_LOW_PASS;
+                       preset = SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ;
+                       break;
+               case 2: /* low pass under 480hz */
+                       filter = SOUND_FILTER_LOW_PASS;
+                       preset = SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ;
+                       break;
+               case 3: /* high pass over none */
+                       filter = SOUND_FILTER_HIGH_PASS;
+                       preset = SOUND_FILTER_PRESET_HIGH_PASS_NONE;
+                       break;
+               case 4: /* high pass over 240hz */
+                       filter = SOUND_FILTER_HIGH_PASS;
+                       preset = SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ;
+                       break;
+               case 5: /* high pass over 480hz */
+                       filter = SOUND_FILTER_HIGH_PASS;
+                       preset = SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ;
+                       break;
+               case 6: /* delay none */
+                       filter = SOUND_FILTER_DELAY;
+                       preset = SOUND_FILTER_PRESET_DELAY_NONE;
+                       break;
+               case 7: /* delay 1 sec */
+                       filter = SOUND_FILTER_DELAY;
+                       preset = SOUND_FILTER_PRESET_DELAY_1SEC;
+                       break;
+               case 8: /* delay 2 sec */
+                       filter = SOUND_FILTER_DELAY;
+                       preset = SOUND_FILTER_PRESET_DELAY_2SEC;
+                       break;
+               case 9: /* soundAlive concert normal */
+                       filter = SOUND_FILTER_SOUNDALIVE;
+                       preset = SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL;
+                       break;
+               case 10: /* soundAlive concert hall */
+                       filter = SOUND_FILTER_SOUNDALIVE;
+                       preset = SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL;
+                       break;
+               default:
+                       filter = SOUND_FILTER_DELAY;
+                       preset = SOUND_FILTER_PRESET_DELAY_NONE;
+                       g_print("invalid selection(%d), keep going with filter(%d), preset(%d)\n", selection, filter, preset);
+                       break;
+               }
+
+               ret = sound_manager_set_filter_preset(SOUND_STREAM_TYPE_MEDIA, filter, preset);
+               if (ret)
+                       g_print("fail to sound_manager_set_filter_preset(), ret(0x%x)\n", ret);
+               else
+                       g_print("success to sound_manager_set_filter_preset(), ret(0x%x)\n", ret);
+
+               reset_menu_state();
+               break;
+       }
+       case CURRENT_STATUS_UNSET_FILTER: {
+               int ret = SOUND_MANAGER_ERROR_NONE;
+               ret = sound_manager_unset_filter(SOUND_STREAM_TYPE_MEDIA);
+               if (ret)
+                       g_print("fail to sound_manager_unset_filter(), ret(0x%x)\n", ret);
+               else
+                       g_print("success to sound_manager_unset_filter(), ret(0x%x)\n", ret);
+               reset_menu_state();
+               break;
+       }
 #ifndef TIZEN_FEATURE_TV_PROD
        case CURRENT_STATUS_GET_MAX_MASTER_VOLUME: {
                int max_level;