diff --git a/Android.mk b/Android.mk
index 060bee6..29fc8c6 100644
--- a/Android.mk
+++ b/Android.mk
@@ -11,6 +11,7 @@
 else
 include $(MY_LOCAL_PATH)/hal/Android.mk
 endif
+include $(MY_LOCAL_PATH)/hal/audio_extn/Android.mk
 include $(MY_LOCAL_PATH)/voice_processing/Android.mk
 include $(MY_LOCAL_PATH)/mm-audio/Android.mk
 include $(MY_LOCAL_PATH)/visualizer/Android.mk
diff --git a/hal/Android.mk b/hal/Android.mk
index 9485d6b..a67ce7c 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -105,7 +105,15 @@
         acdb.c
 
 LOCAL_SRC_FILES += audio_extn/audio_extn.c \
-                   audio_extn/utils.c
+                   audio_extn/audio_feature_manager.c \
+                   audio_extn/utils.c \
+                   audio_extn/source_track.c \
+                   voice_extn/voice_extn.c \
+                   audio_extn/fm.c \
+                   voice_extn/compress_voip.c \
+                   audio_extn/keep_alive.c
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
 LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
 LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
 
@@ -117,114 +125,104 @@
 
 LOCAL_CFLAGS += -DUSE_VENDOR_EXTN
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HDMI_EDID)),true)
-    LOCAL_CFLAGS += -DHDMI_EDID
-    LOCAL_SRC_FILES += edid.c
-endif
-
-ifeq ($(strip $(AUDIO_USE_DEEP_AS_PRIMARY_OUTPUT)),true)
-    LOCAL_CFLAGS += -DUSE_DEEP_AS_PRIMARY_OUTPUT
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HDMI_EDID)),true)
+#     LOCAL_CFLAGS += -DHDMI_EDID
+#     LOCAL_SRC_FILES += edid.c
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD)),true)
     LOCAL_CFLAGS += -DPCM_OFFLOAD_ENABLED
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ANC_HEADSET)),true)
-    LOCAL_CFLAGS += -DANC_HEADSET_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ANC_HEADSET)),true)
+#     LOCAL_CFLAGS += -DANC_HEADSET_ENABLED
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HIFI_AUDIO)),true)
-    LOCAL_CFLAGS += -DHIFI_AUDIO_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HIFI_AUDIO)),true)
+#     LOCAL_CFLAGS += -DHIFI_AUDIO_ENABLED
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RAS)),true)
-    LOCAL_CFLAGS += -DRAS_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RAS)),true)
+#     LOCAL_CFLAGS += -DRAS_ENABLED
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VBAT_MONITOR)),true)
-    LOCAL_CFLAGS += -DVBAT_MONITOR_ENABLED
-endif
+#ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VBAT_MONITOR)),true)
+#    LOCAL_CFLAGS += -DVBAT_MONITOR_ENABLED
+#endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FLUENCE)),true)
-    LOCAL_CFLAGS += -DFLUENCE_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FLUENCE)),true)
+#     LOCAL_CFLAGS += -DFLUENCE_ENABLED
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PROXY_DEVICE)),true)
     LOCAL_CFLAGS += -DAFE_PROXY_ENABLED
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_KPI_OPTIMIZE)),true)
-    LOCAL_CFLAGS += -DKPI_OPTIMIZE_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_KPI_OPTIMIZE)),true)
+#     LOCAL_CFLAGS += -DKPI_OPTIMIZE_ENABLED
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FM_POWER_OPT)),true)
-    LOCAL_CFLAGS += -DFM_POWER_OPT
-    LOCAL_SRC_FILES += audio_extn/fm.c
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FM_POWER_OPT)),true)
+#     LOCAL_CFLAGS += -DFM_POWER_OPT
+#     LOCAL_SRC_FILES += audio_extn/fm.c
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_TUNNEL)),true)
-    LOCAL_CFLAGS += -DUSB_TUNNEL_ENABLED
+
+#ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_TUNNEL)),true)
+#    LOCAL_CFLAGS += -DUSB_TUNNEL_ENABLED
     LOCAL_SRC_FILES += audio_extn/usb.c
-endif
+#endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_SIDETONE_VOLUME)),true)
-    LOCAL_CFLAGS += -DUSB_SIDETONE_VOLUME
-endif
+#ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_SIDETONE_VOLUME)),true)
+#    LOCAL_CFLAGS += -DUSB_SIDETONE_VOLUME
+#endif
+
+#ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_BURST_MODE)), true)
+#    LOCAL_CFLAGS += -DUSB_BURST_MODE_ENABLED
+#endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HFP)),true)
     LOCAL_CFLAGS += -DHFP_ENABLED
     LOCAL_SRC_FILES += audio_extn/hfp.c
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_CUSTOMSTEREO)),true)
-    LOCAL_CFLAGS += -DCUSTOM_STEREO_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SSR)),true)
-    LOCAL_CFLAGS += -DSSR_ENABLED
-    LOCAL_SRC_FILES += audio_extn/ssr.c
-    LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/surround_sound_3mic/
-    LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/common/inc/
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MULTI_VOICE_SESSIONS)),true)
-    LOCAL_CFLAGS += -DMULTI_VOICE_SESSION_ENABLED
-    LOCAL_SRC_FILES += voice_extn/voice_extn.c
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_CUSTOMSTEREO)),true)
+#     LOCAL_CFLAGS += -DCUSTOM_STEREO_ENABLED
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_INCALL_MUSIC)),true)
     LOCAL_CFLAGS += -DINCALL_MUSIC_ENABLED
 endif
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_COMPRESS_VOIP)),true)
-    LOCAL_CFLAGS += -DCOMPRESS_VOIP_ENABLED
-    LOCAL_SRC_FILES += voice_extn/compress_voip.c
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_COMPRESS_VOIP)),true)
+#     LOCAL_CFLAGS += -DCOMPRESS_VOIP_ENABLED
+#     LOCAL_SRC_FILES += voice_extn/compress_voip.c
+# endif
 
-endif
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FORMATS)),true)
   LOCAL_CFLAGS += -DAUDIO_EXTN_FORMATS_ENABLED
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SPKR_PROTECTION)),true)
-  LOCAL_CFLAGS += -DSPKR_PROT_ENABLED
-  LOCAL_SRC_FILES += audio_extn/spkr_protection.c
-endif
+#ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SPKR_PROTECTION)),true)
+#  LOCAL_CFLAGS += -DSPKR_PROT_ENABLED
+#  LOCAL_SRC_FILES += audio_extn/spkr_protection.c
+#endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_BG_CAL)),true)
   LOCAL_CFLAGS += -DBG_CODEC_CAL
 endif
 
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_CIRRUS_SPKR_PROTECTION)),true)
+#     LOCAL_CFLAGS += -DSPKR_PROT_ENABLED
+#     LOCAL_SRC_FILES += audio_extn/cirrus_playback.c
+# endif
+
 ifdef MULTIPLE_HW_VARIANTS_ENABLED
   LOCAL_CFLAGS += -DHW_VARIANTS_ENABLED
   LOCAL_SRC_FILES += $(AUDIO_PLATFORM)/hw_info.c
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_COMPRESS_CAPTURE)),true)
-    LOCAL_CFLAGS += -DCOMPRESS_CAPTURE_ENABLED
-    LOCAL_SRC_FILES += audio_extn/compress_capture.c
-endif
-
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DTS_EAGLE)),true)
     LOCAL_CFLAGS += -DDTS_EAGLE
     LOCAL_SRC_FILES += audio_extn/dts_eagle.c
@@ -244,28 +242,27 @@
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FLAC_DECODER)),true)
     LOCAL_CFLAGS += -DFLAC_OFFLOAD_ENABLED
-    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
+#    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
 endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VORBIS_OFFLOAD)),true)
     LOCAL_CFLAGS += -DVORBIS_OFFLOAD_ENABLED
-    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
-
+#    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
 endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_WMA_OFFLOAD)),true)
     LOCAL_CFLAGS += -DWMA_OFFLOAD_ENABLED
-    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
+#    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
 endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ALAC_OFFLOAD)),true)
     LOCAL_CFLAGS += -DALAC_OFFLOAD_ENABLED
-    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
+#    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
 endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_APE_OFFLOAD)),true)
     LOCAL_CFLAGS += -DAPE_OFFLOAD_ENABLED
-    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
+#    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED
 endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD_24)),true)
@@ -276,18 +273,20 @@
     LOCAL_CFLAGS += -DAAC_ADTS_OFFLOAD_ENABLED
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DEV_ARBI)),true)
-    LOCAL_CFLAGS += -DDEV_ARBI_ENABLED
-    LOCAL_SRC_FILES += audio_extn/dev_arbi.c
-endif
+# # Removing flag as feature below is no longer needed
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DEV_ARBI)),true)
+#     LOCAL_CFLAGS += -DDEV_ARBI_ENABLED
+#     LOCAL_SRC_FILES += audio_extn/dev_arbi.c
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RECORD_PLAY_CONCURRENCY)),true)
     LOCAL_CFLAGS += -DRECORD_PLAY_CONCURRENCY
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ACDB_LICENSE)), true)
-    LOCAL_CFLAGS += -DDOLBY_ACDB_LICENSE
-endif
+# Removing following flag as dolby is not being used on mobile targets
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ACDB_LICENSE)), true)
+#     LOCAL_CFLAGS += -DDOLBY_ACDB_LICENSE
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DS2_DOLBY_DAP)),true)
     LOCAL_CFLAGS += -DDS2_DOLBY_DAP_ENABLED
@@ -304,25 +303,16 @@
     LOCAL_SRC_FILES += audio_extn/passthru.c
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_KEEP_ALIVE)),true)
-    LOCAL_CFLAGS += -DKEEP_ALIVE_ENABLED
-    LOCAL_SRC_FILES += audio_extn/keep_alive.c
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_KEEP_ALIVE)),true)
+#     LOCAL_CFLAGS += -DKEEP_ALIVE_ENABLED
+#     LOCAL_SRC_FILES += audio_extn/keep_alive.c
+# endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SOURCE_TRACKING)),true)
-    LOCAL_CFLAGS += -DSOURCE_TRACKING_ENABLED
-    LOCAL_SRC_FILES += audio_extn/source_track.c
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_A2DP_OFFLOAD)),true)
-    LOCAL_CFLAGS += -DA2DP_OFFLOAD_ENABLED
-    LOCAL_SRC_FILES += audio_extn/a2dp.c
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_IP_HDLR_ENABLED)),true)
-    LOCAL_CFLAGS += -DAUDIO_EXTN_IP_HDLR_ENABLED
-    LOCAL_SRC_FILES += audio_extn/ip_hdlr_intf.c
-endif
+#This feature is depricated, file disabled
+#ifeq ($(strip $(AUDIO_FEATURE_IP_HDLR_ENABLED)),true)
+#    LOCAL_CFLAGS += -DAUDIO_EXTN_IP_HDLR_ENABLED
+#    LOCAL_SRC_FILES += audio_extn/ip_hdlr_intf.c
+#endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_QAF)),true)
     LOCAL_CFLAGS += -DQAF_EXTN_ENABLED
@@ -349,7 +339,7 @@
     liblog \
     libcutils \
     libtinyalsa \
-    libtinycompress_vendor \
+    libtinycompress \
     libaudioroute \
     libdl \
     libaudioutils \
@@ -427,9 +417,9 @@
     LOCAL_SHARED_LIBRARIES += libperipheral_client
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DISPLAY_PORT)),true)
-    LOCAL_CFLAGS += -DDISPLAY_PORT_ENABLED
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DISPLAY_PORT)),true)
+#     LOCAL_CFLAGS += -DDISPLAY_PORT_ENABLED
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_GEF_SUPPORT)),true)
     LOCAL_CFLAGS += -DAUDIO_GENERIC_EFFECT_FRAMEWORK_ENABLED
@@ -455,10 +445,6 @@
     LOCAL_CFLAGS += -DINSTANCE_ID_ENABLED
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_BURST_MODE)), true)
-    LOCAL_CFLAGS += -DUSB_BURST_MODE_ENABLED
-endif
-
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_BATTERY_LISTENER)), true)
     LOCAL_CFLAGS += -DBATTERY_LISTENER_ENABLED
     LOCAL_SRC_FILES += audio_extn/battery_listener.cpp
@@ -483,10 +469,15 @@
 LOCAL_COPY_HEADERS_TO   := mm-audio
 LOCAL_COPY_HEADERS      := audio_extn/audio_defs.h
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SND_MONITOR)), true)
-    LOCAL_CFLAGS += -DSND_MONITOR_ENABLED
-    LOCAL_SRC_FILES += audio_extn/sndmonitor.c
-endif
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SND_MONITOR)), true)
+#     LOCAL_CFLAGS += -DSND_MONITOR_ENABLED
+#     LOCAL_SRC_FILES += audio_extn/sndmonitor.c
+# endif
+
+# ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MAXX_AUDIO)), true)
+#     LOCAL_CFLAGS += -DMAXXAUDIO_QDSP_ENABLED
+#     LOCAL_SRC_FILES += audio_extn/maxxaudio.c
+# endif
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_GCOV)),true)
     LOCAL_CFLAGS += --coverage -fprofile-arcs -ftest-coverage
diff --git a/hal/audio_extn/Android.mk b/hal/audio_extn/Android.mk
new file mode 100644
index 0000000..3897ba4
--- /dev/null
+++ b/hal/audio_extn/Android.mk
@@ -0,0 +1,399 @@
+#--------------------------------------------
+#          Build SND_MONITOR LIB
+#--------------------------------------------
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= libsndmonitor
+LOCAL_MODULE_OWNER := third_party
+LOCAL_PROPRIETARY_MODULE := true
+
+AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
+
+LOCAL_SRC_FILES:= \
+        sndmonitor.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable \
+
+LOCAL_SHARED_LIBRARIES := \
+	libaudioutils \
+	libcutils \
+	liblog \
+	libtinyalsa \
+	libtinycompress \
+	libaudioroute \
+	libdl \
+	libexpat
+
+LOCAL_C_INCLUDES := \
+	external/tinyalsa/include \
+	external/tinycompress/include \
+	system/media/audio_utils/include \
+	external/expat/lib \
+	$(call include-path-for, audio-route) \
+	vendor/qcom/opensource/audio-hal/primary-hal/hal \
+	$(call include-path-for, audio-effects)
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
+  LOCAL_HEADER_LIBRARIES += audio_kernel_headers
+  LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/vendor/qcom/opensource/audio-kernel/include
+  LOCAL_ADDITIONAL_DEPENDENCIES += $(BOARD_VENDOR_KERNEL_MODULES)
+endif
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
+
+#--------------------------------------------
+#          Build COMPRESS_CAPTURE LIB
+#--------------------------------------------
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= libcomprcapture
+LOCAL_MODULE_OWNER := third_party
+LOCAL_PROPRIETARY_MODULE := true
+
+AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
+
+ifneq ($(filter sdm845 sdm710 qcs605 msmnile $(MSMSTEPPE),$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+  MULTIPLE_HW_VARIANTS_ENABLED := true
+endif
+
+LOCAL_SRC_FILES:= \
+        compress_capture.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable \
+
+LOCAL_SHARED_LIBRARIES := \
+	libaudioutils \
+	libcutils \
+	liblog \
+	libtinyalsa \
+	libtinycompress \
+	libaudioroute \
+	libdl \
+	libexpat
+
+LOCAL_C_INCLUDES := \
+	external/tinyalsa/include \
+	external/tinycompress/include \
+	system/media/audio_utils/include \
+	external/expat/lib \
+	$(call include-path-for, audio-route) \
+	vendor/qcom/opensource/audio-hal/primary-hal/hal \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/$(AUDIO_PLATFORM) \
+	$(call include-path-for, audio-effects)
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
+  LOCAL_HEADER_LIBRARIES += audio_kernel_headers
+  LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/vendor/qcom/opensource/audio-kernel/include
+  LOCAL_ADDITIONAL_DEPENDENCIES += $(BOARD_VENDOR_KERNEL_MODULES)
+endif
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
+
+#-------------------------------------------
+#            Build SSREC LIB
+#-------------------------------------------
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= libssrec
+LOCAL_VENDOR_MODULE := true
+
+AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
+
+ifneq ($(filter sdm845 msmnile $(MSMSTEPPE),$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+  MULTIPLE_HW_VARIANTS_ENABLED := true
+endif
+
+LOCAL_SRC_FILES:= ssr.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable
+
+LOCAL_SHARED_LIBRARIES := \
+    libaudioutils \
+    libcutils \
+    liblog \
+    libtinyalsa \
+    libtinycompress \
+    libaudioroute \
+    libdl \
+    libexpat
+
+LOCAL_C_INCLUDES := \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/$(AUDIO_PLATFORM) \
+    external/tinyalsa/include \
+    external/tinycompress/include \
+    external/expat/lib \
+    system/media/audio_utils/include \
+    $(call include-path-for, audio-route) \
+    $(call include-path-for, audio-effects) \
+    $(TARGET_OUT_HEADERS)/mm-audio/surround_sound_3mic/ \
+    $(TARGET_OUT_HEADERS)/common/inc/
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
+  LOCAL_HEADER_LIBRARIES += audio_kernel_headers
+  LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/vendor/qcom/opensource/audio-kernel/include
+  LOCAL_ADDITIONAL_DEPENDENCIES += $(BOARD_VENDOR_KERNEL_MODULES)
+endif
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+#include $(BUILD_SHARED_LIBRARY)
+
+#--------------------------------------------
+#          Build HDMI_EDID LIB
+#--------------------------------------------
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= libhdmiedid
+LOCAL_MODULE_OWNER := third_party
+LOCAL_PROPRIETARY_MODULE := true
+
+PRIMARY_HAL_PATH := vendor/qcom/opensource/audio-hal/primary-hal/hal
+AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
+
+ifneq ($(filter sdm845 msmnile $(MSMSTEPPE) $(TRINKET),$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+endif
+
+LOCAL_SRC_FILES:= \
+        edid.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable \
+
+LOCAL_SHARED_LIBRARIES := \
+	libaudioutils \
+	libcutils \
+	liblog \
+	libtinyalsa \
+	libtinycompress \
+	libaudioroute \
+	libdl \
+	libexpat
+
+LOCAL_C_INCLUDES := \
+	external/tinyalsa/include \
+	external/tinycompress/include \
+	system/media/audio_utils/include \
+	external/expat/lib \
+	$(call include-path-for, audio-route) \
+	$(PRIMARY_HAL_PATH) \
+	$(PRIMARY_HAL_PATH)/$(AUDIO_PLATFORM) \
+	$(call include-path-for, audio-effects)
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
+  LOCAL_HEADER_LIBRARIES += audio_kernel_headers
+  LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/vendor/qcom/opensource/audio-kernel/include
+  LOCAL_ADDITIONAL_DEPENDENCIES += $(BOARD_VENDOR_KERNEL_MODULES)
+endif
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
+
+#--------------------------------------------
+#          Build SPKR_PROTECT LIB
+#--------------------------------------------
+include $(CLEAR_VARS)
+
+ifneq ($(filter sdm845 msmnile $(MSMSTEPPE) $(TRINKET) kona,$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+endif
+
+LOCAL_MODULE:= libspkrprot
+LOCAL_MODULE_OWNER := third_party
+LOCAL_PROPRIETARY_MODULE := true
+
+LOCAL_SRC_FILES:= \
+        spkr_protection.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable \
+
+LOCAL_CFLAGS += -DSPKR_PROT_ENABLED
+
+LOCAL_SHARED_LIBRARIES := \
+    libaudioutils \
+    libcutils \
+    liblog \
+    libtinyalsa \
+    libtinycompress \
+    libaudioroute \
+    libdl \
+    libexpat
+
+LOCAL_C_INCLUDES := \
+    external/tinyalsa/include \
+    external/tinycompress/include \
+    system/media/audio_utils/include \
+    external/expat/lib \
+    $(call include-path-for, audio-route) \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/audio_extn \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/$(AUDIO_PLATFORM) \
+    vendor/qcom/opensource/audio-kernel/include/uapi/ \
+    $(call include-path-for, audio-effects)
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
+#====================================================================================================
+# --- enable 3rd Party Spkr-prot lib
+#====================================================================================================
+
+include $(CLEAR_VARS)
+
+ifneq ($(filter sdm845 msmnile $(MSMSTEPPE) $(TRINKET) kona,$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+endif
+
+LOCAL_MODULE:= libcirrusspkrprot
+LOCAL_MODULE_OWNER := third_party
+LOCAL_PROPRIETARY_MODULE := true
+
+LOCAL_SRC_FILES:= \
+        cirrus_playback.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable \
+
+LOCAL_CFLAGS += -DENABLE_CIRRUS_DETECTION
+LOCAL_CFLAGS += -DCIRRUS_FACTORY_CALIBRATION
+
+LOCAL_SHARED_LIBRARIES := \
+    libaudioutils \
+    libcutils \
+    liblog \
+    libtinyalsa \
+    libaudioroute \
+    libdl \
+    libexpat
+
+LOCAL_C_INCLUDES := \
+    external/tinyalsa/include \
+    external/tinycompress/include \
+    system/media/audio_utils/include \
+    external/expat/lib \
+    $(call include-path-for, audio-route) \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/audio_extn \
+    vendor/qcom/opensource/audio-hal/primary-hal/hal/$(AUDIO_PLATFORM) \
+    vendor/qcom/opensource/audio-kernel/include/uapi/ \
+    $(call include-path-for, audio-effects)
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
+
+#-------------------------------------------
+#            Build A2DP_OFFLOAD LIB
+#-------------------------------------------
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= liba2dpoffload
+LOCAL_PROPRIETARY_MODULE := true
+
+PRIMARY_HAL_PATH := vendor/qcom/opensource/audio-hal/primary-hal/hal
+AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
+
+ifneq ($(filter sdm845 msmnile $(MSMSTEPPE),$(TARGET_BOARD_PLATFORM)),)
+  # B-family platform uses msm8974 code base
+  AUDIO_PLATFORM = msm8974
+  MULTIPLE_HW_VARIANTS_ENABLED := true
+endif
+
+LOCAL_SRC_FILES:= \
+        a2dp.c
+
+LOCAL_CFLAGS += \
+    -Wall \
+    -Werror \
+    -Wno-unused-function \
+    -Wno-unused-variable
+
+LOCAL_SHARED_LIBRARIES := \
+    libaudioutils \
+    libcutils \
+    liblog \
+    libtinyalsa \
+    libtinycompress \
+    libaudioroute \
+    libdl \
+    libexpat
+
+LOCAL_C_INCLUDES := \
+    $(PRIMARY_HAL_PATH) \
+    $(PRIMARY_HAL_PATH)/$(AUDIO_PLATFORM) \
+    external/tinyalsa/include \
+    external/tinycompress/include \
+    external/expat/lib \
+    system/media/audio_utils/include \
+    $(call include-path-for, audio-route) \
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
+  LOCAL_HEADER_LIBRARIES += audio_kernel_headers
+  LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/vendor/qcom/opensource/audio-kernel/include
+  LOCAL_ADDITIONAL_DEPENDENCIES += $(BOARD_VENDOR_KERNEL_MODULES)
+endif
+
+LOCAL_HEADER_LIBRARIES += libhardware_headers
+LOCAL_HEADER_LIBRARIES += libsystem_headers
+include $(BUILD_SHARED_LIBRARY)
diff --git a/hal/audio_extn/a2dp.c b/hal/audio_extn/a2dp.c
index b193d67..fb71083 100644
--- a/hal/audio_extn/a2dp.c
+++ b/hal/audio_extn/a2dp.c
@@ -49,7 +49,6 @@
 #include <log_utils.h>
 #endif
 
-#ifdef A2DP_OFFLOAD_ENABLED
 #define AUDIO_PARAMETER_A2DP_STARTED "A2dpStarted"
 #define BT_IPC_SOURCE_LIB_NAME  "libbthost_if.so"
 #define BT_IPC_SINK_LIB_NAME    "libbthost_if_sink.so"
@@ -228,6 +227,10 @@
     PEAK_BIT_RATE,
 } frame_control_type_t;
 
+// --- external function dependency ---
+fp_platform_get_pcm_device_id_t fp_platform_get_pcm_device_id;
+fp_check_a2dp_restore_t fp_check_a2dp_restore;
+
 /* PCM config for ABR Feedback hostless front end */
 static struct pcm_config pcm_config_abr = {
     .channels = 1,
@@ -782,7 +785,7 @@
     }
 
     // Open hostless front end and prepare ABR Tx path
-    abr_device_id = platform_get_pcm_device_id(USECASE_AUDIO_A2DP_ABR_FEEDBACK,
+    abr_device_id = fp_platform_get_pcm_device_id(USECASE_AUDIO_A2DP_ABR_FEEDBACK,
                                                PCM_CAPTURE);
     if (!a2dp.abr_config.abr_tx_handle) {
         a2dp.abr_config.abr_tx_handle = pcm_open(a2dp.adev->snd_card,
@@ -2157,11 +2160,11 @@
     return is_configured;
 }
 
-int audio_extn_a2dp_start_playback()
+int a2dp_start_playback()
 {
     int ret = 0;
 
-    ALOGD("audio_extn_a2dp_start_playback start");
+    ALOGD("a2dp_start_playback start");
 
     if(!(a2dp.bt_lib_source_handle && a2dp.audio_source_start
        && a2dp.audio_get_enc_config)) {
@@ -2209,7 +2212,7 @@
     return ret;
 }
 
-uint64_t audio_extn_a2dp_get_decoder_latency()
+uint64_t a2dp_get_decoder_latency()
 {
     uint32_t latency = 0;
 
@@ -2232,7 +2235,7 @@
     uint64_t system_latency = 0;
     bool is_complete = false;
 
-    system_latency = audio_extn_a2dp_get_decoder_latency();
+    system_latency = a2dp_get_decoder_latency();
 
     if (a2dp.audio_sink_session_setup_complete(system_latency) == 0) {
         is_complete = true;
@@ -2240,11 +2243,22 @@
     return is_complete;
 }
 
-int audio_extn_a2dp_start_capture()
+bool a2dp_sink_is_ready()
+{
+    bool ret = false;
+
+    if ((a2dp.bt_state_sink != A2DP_STATE_DISCONNECTED) &&
+        (a2dp.is_a2dp_offload_supported) &&
+        (a2dp.audio_sink_check_a2dp_ready))
+           ret = a2dp.audio_sink_check_a2dp_ready();
+    return ret;
+}
+
+int a2dp_start_capture()
 {
     int ret = 0;
 
-    ALOGD("audio_extn_a2dp_start_capture start");
+    ALOGD("a2dp_start_capture start");
 
     if(!(a2dp.bt_lib_sink_handle && a2dp.audio_sink_start
        && a2dp.audio_get_dec_config)) {
@@ -2262,7 +2276,7 @@
            a2dp.a2dp_sink_started = false;
         } else {
 
-           if(!audio_extn_a2dp_sink_is_ready()) {
+           if(!a2dp_sink_is_ready()) {
                 ALOGD("Wait for capture ready not successful");
                 ret = -ETIMEDOUT;
            }
@@ -2382,11 +2396,11 @@
     }
 }
 
-int audio_extn_a2dp_stop_playback()
+int a2dp_stop_playback()
 {
     int ret =0;
 
-    ALOGV("audio_extn_a2dp_stop_playback start");
+    ALOGV("a2dp_stop_playback start");
     if(!(a2dp.bt_lib_source_handle && a2dp.audio_source_stop)) {
         ALOGE("a2dp handle is not identified, Ignoring stop request");
         return -ENOSYS;
@@ -2420,11 +2434,11 @@
     return 0;
 }
 
-int audio_extn_a2dp_stop_capture()
+int a2dp_stop_capture()
 {
     int ret =0;
 
-    ALOGV("audio_extn_a2dp_stop_capture start");
+    ALOGV("a2dp_stop_capture start");
     if(!(a2dp.bt_lib_sink_handle && a2dp.audio_sink_stop)) {
         ALOGE("a2dp handle is not identified, Ignoring stop request");
         return -ENOSYS;
@@ -2450,7 +2464,7 @@
     return 0;
 }
 
-int audio_extn_a2dp_set_parameters(struct str_parms *parms, bool *reconfig)
+int a2dp_set_parameters(struct str_parms *parms, bool *reconfig)
 {
      int ret = 0, val, status = 0;
      char value[32]={0};
@@ -2522,7 +2536,7 @@
                     if (uc_info->type == PCM_PLAYBACK &&
                          (uc_info->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
                         pthread_mutex_unlock(&a2dp.adev->lock);
-                        check_a2dp_restore(a2dp.adev, uc_info->stream.out, false);
+                        fp_check_a2dp_restore(a2dp.adev, uc_info->stream.out, false);
                         pthread_mutex_lock(&a2dp.adev->lock);
                     }
                 }
@@ -2563,7 +2577,7 @@
                     if (uc_info->type == PCM_PLAYBACK &&
                          (uc_info->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
                         pthread_mutex_unlock(&a2dp.adev->lock);
-                        check_a2dp_restore(a2dp.adev, uc_info->stream.out, true);
+                        fp_check_a2dp_restore(a2dp.adev, uc_info->stream.out, true);
                         pthread_mutex_lock(&a2dp.adev->lock);
                     }
                 }
@@ -2587,12 +2601,12 @@
      return status;
 }
 
-void audio_extn_a2dp_set_handoff_mode(bool is_on)
+void a2dp_set_handoff_mode(bool is_on)
 {
     a2dp.is_handoff_in_progress = is_on;
 }
 
-bool audio_extn_a2dp_is_force_device_switch()
+bool a2dp_is_force_device_switch()
 {
     //During encoder reconfiguration mode, force a2dp device switch
     // Or if a2dp device is selected but earlier start failed ( as a2dp
@@ -2600,17 +2614,17 @@
     return a2dp.is_handoff_in_progress || !a2dp.a2dp_source_started;
 }
 
-void audio_extn_a2dp_get_enc_sample_rate(int *sample_rate)
+void a2dp_get_enc_sample_rate(int *sample_rate)
 {
     *sample_rate = a2dp.enc_sampling_rate;
 }
 
-void audio_extn_a2dp_get_dec_sample_rate(int *sample_rate)
+void a2dp_get_dec_sample_rate(int *sample_rate)
 {
     *sample_rate = a2dp.dec_sampling_rate;
 }
 
-bool audio_extn_a2dp_source_is_ready()
+bool a2dp_source_is_ready()
 {
     bool ret = false;
 
@@ -2624,23 +2638,13 @@
     return ret;
 }
 
-bool audio_extn_a2dp_sink_is_ready()
-{
-    bool ret = false;
-
-    if ((a2dp.bt_state_sink != A2DP_STATE_DISCONNECTED) &&
-        (a2dp.is_a2dp_offload_supported) &&
-        (a2dp.audio_sink_check_a2dp_ready))
-           ret = a2dp.audio_sink_check_a2dp_ready();
-    return ret;
-}
-
-bool audio_extn_a2dp_source_is_suspended()
+bool a2dp_source_is_suspended()
 {
     return a2dp.a2dp_source_suspended;
 }
 
-void audio_extn_a2dp_init (void *adev)
+void a2dp_init(void *adev,
+               a2dp_offload_init_config_t *init_config)
 {
   a2dp.adev = (struct audio_device*)adev;
   a2dp.bt_lib_source_handle = NULL;
@@ -2658,6 +2662,12 @@
   a2dp.abr_config.imc_instance = 0;
   a2dp.abr_config.abr_tx_handle = NULL;
   a2dp.is_tws_mono_mode_on = false;
+
+  // init function pointers
+  fp_platform_get_pcm_device_id =
+              init_config->fp_platform_get_pcm_device_id;
+  fp_check_a2dp_restore = init_config->fp_check_a2dp_restore;
+
   reset_a2dp_enc_config_params();
   reset_a2dp_source_dec_config_params();
   reset_a2dp_sink_dec_config_params();
@@ -2672,7 +2682,7 @@
   update_offload_codec_capabilities();
 }
 
-uint32_t audio_extn_a2dp_get_encoder_latency()
+uint32_t a2dp_get_encoder_latency()
 {
     uint32_t latency = 0;
     int avsync_runtime_prop = 0;
@@ -2734,7 +2744,7 @@
     return latency;
 }
 
-int audio_extn_a2dp_get_parameters(struct str_parms *query,
+int a2dp_get_parameters(struct str_parms *query,
                                    struct str_parms *reply)
 {
     int ret, val = 0;
@@ -2750,4 +2760,3 @@
 
     return 0;
 }
-#endif // A2DP_OFFLOAD_ENABLED
diff --git a/hal/audio_extn/audio_extn.c b/hal/audio_extn/audio_extn.c
index 2d18d96..e0b07c6 100644
--- a/hal/audio_extn/audio_extn.c
+++ b/hal/audio_extn/audio_extn.c
@@ -46,14 +46,14 @@
 #include <cutils/properties.h>
 #include <log/log.h>
 #include <unistd.h>
-
 #include "audio_hw.h"
 #include "audio_extn.h"
+#include "voice_extn.h"
 #include "audio_defs.h"
 #include "platform.h"
 #include "platform_api.h"
 #include "edid.h"
-
+#include "audio_feature_manager.h"
 #include "sound/compress_params.h"
 
 #ifdef DYNAMIC_LOG_ENABLED
@@ -67,6 +67,9 @@
 #define MAX_NUM_CHANNELS 8
 #define Q14_GAIN_UNITY 0x4000
 
+static bool is_running_on_stock_version = true;
+static bool is_compress_meta_data_enabled = false;
+
 struct snd_card_split cur_snd_card_split = {
     .device = {0},
     .snd_card = {0},
@@ -78,6 +81,17 @@
     return &cur_snd_card_split;
 }
 
+void fm_set_parameters(struct audio_device *adev,
+                                  struct str_parms *parms);
+void fm_get_parameters(struct str_parms *query, struct str_parms *reply);
+
+void keep_alive_init(struct audio_device *adev);
+void keep_alive_deinit();
+void keep_alive_start(ka_mode_t ka_mode);
+void keep_alive_stop(ka_mode_t ka_mode);
+int keep_alive_set_parameters(struct audio_device *adev,
+                                         struct str_parms *parms);
+
 void audio_extn_set_snd_card_split(const char* in_snd_card_name)
 {
     /* sound card name follows below mentioned convention
@@ -139,6 +153,16 @@
 };
 
 static struct audio_extn_module aextnmod;
+static bool audio_extn_fm_power_opt_enabled = false;
+static bool audio_extn_keep_alive_enabled = false;
+static bool audio_extn_hifi_audio_enabled = false;
+static bool audio_extn_ras_feature_enabled = false;
+static bool audio_extn_kpi_optimize_feature_enabled = false;
+static bool audio_extn_display_port_feature_enabled = false;
+static bool audio_extn_fluence_feature_enabled = false;
+static bool audio_extn_custom_stereo_feature_enabled = false;
+static bool audio_extn_anc_headset_feature_enabled = false;
+static bool audio_extn_vbat_enabled = false;
 
 #define AUDIO_PARAMETER_KEY_AANC_NOISE_LEVEL "aanc_noise_level"
 #define AUDIO_PARAMETER_KEY_ANC        "anc_enabled"
@@ -161,6 +185,8 @@
 * this is done when device switch happens by setting audioparamter
 */
 
+#define IS_BIT_SET(NUM, bitno) (NUM & (1 << bitno))
+
 #define EXT_DISPLAY_PLUG_STATUS_NOTIFY_ENABLE 0x30
 
 static ssize_t update_sysfs_node(const char *path, const char *data, size_t len)
@@ -312,124 +338,6 @@
     }
 }
 
-#ifndef SOURCE_TRACKING_ENABLED
-#define audio_extn_source_track_set_parameters(adev, parms) (0)
-#define audio_extn_source_track_get_parameters(adev, query, reply) (0)
-#else
-void audio_extn_source_track_set_parameters(struct audio_device *adev,
-                                            struct str_parms *parms);
-void audio_extn_source_track_get_parameters(const struct audio_device *adev,
-                                            struct str_parms *query,
-                                            struct str_parms *reply);
-#endif
-
-#ifndef CUSTOM_STEREO_ENABLED
-#define audio_extn_customstereo_set_parameters(adev, parms)         (0)
-#else
-void audio_extn_customstereo_set_parameters(struct audio_device *adev,
-                                           struct str_parms *parms)
-{
-    int ret = 0;
-    char value[32]={0};
-    bool custom_stereo_state = false;
-    const char *mixer_ctl_name = "Set Custom Stereo OnOff";
-    struct mixer_ctl *ctl;
-
-    ALOGV("%s", __func__);
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_CUSTOM_STEREO, value,
-                            sizeof(value));
-    if (ret >= 0) {
-        if (!strncmp("true", value, sizeof("true")) || atoi(value))
-            custom_stereo_state = true;
-
-        if (custom_stereo_state == aextnmod.custom_stereo_enabled)
-            return;
-
-        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-        if (!ctl) {
-            ALOGE("%s: Could not get ctl for mixer cmd - %s",
-                  __func__, mixer_ctl_name);
-            return;
-        }
-        if (mixer_ctl_set_value(ctl, 0, custom_stereo_state) < 0) {
-            ALOGE("%s: Could not set custom stereo state %d",
-                  __func__, custom_stereo_state);
-            return;
-        }
-        aextnmod.custom_stereo_enabled = custom_stereo_state;
-        ALOGV("%s: Setting custom stereo state success", __func__);
-    }
-}
-
-void audio_extn_send_dual_mono_mixing_coefficients(struct stream_out *out)
-{
-    struct audio_device *adev = out->dev;
-    struct mixer_ctl *ctl;
-    char mixer_ctl_name[128];
-    int cust_ch_mixer_cfg[128], len = 0;
-    int ip_channel_cnt = audio_channel_count_from_out_mask(out->channel_mask);
-    int pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
-    int op_channel_cnt= 2;
-    int i, j, err;
-
-    ALOGV("%s", __func__);
-    if (!out->started) {
-        out->set_dual_mono = true;
-        goto exit;
-    }
-
-    ALOGD("%s: i/p channel count %d, o/p channel count %d, pcm id %d", __func__,
-           ip_channel_cnt, op_channel_cnt, pcm_device_id);
-
-    snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
-             "Audio Stream %d Channel Mix Cfg", pcm_device_id);
-    ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-    if (!ctl) {
-        ALOGE("%s: ERROR. Could not get ctl for mixer cmd - %s",
-        __func__, mixer_ctl_name);
-        goto exit;
-    }
-
-    /* Output channel count corresponds to backend configuration channels.
-     * Input channel count corresponds to ASM session channels.
-     * Set params is called with channels that need to be selected from
-     * input to generate output.
-     * ex: "8,2" to downmix from 8 to 2 i.e. to downmix from 8 to 2,
-     *
-     * This mixer control takes values in the following sequence:
-     * - input channel count(m)
-     * - output channel count(n)
-     * - weight coeff for [out ch#1, in ch#1]
-     * ....
-     * - weight coeff for [out ch#1, in ch#m]
-     *
-     * - weight coeff for [out ch#2, in ch#1]
-     * ....
-     * - weight coeff for [out ch#2, in ch#m]
-     *
-     * - weight coeff for [out ch#n, in ch#1]
-     * ....
-     * - weight coeff for [out ch#n, in ch#m]
-     *
-     * To get dualmono ouptu weightage coeff is calculated as Unity gain
-     * divided by number of input channels.
-     */
-    cust_ch_mixer_cfg[len++] = ip_channel_cnt;
-    cust_ch_mixer_cfg[len++] = op_channel_cnt;
-    for (i = 0; i < op_channel_cnt; i++) {
-         for (j = 0; j < ip_channel_cnt; j++) {
-              cust_ch_mixer_cfg[len++] = Q14_GAIN_UNITY/ip_channel_cnt;
-         }
-    }
-
-    err = mixer_ctl_set_array(ctl, cust_ch_mixer_cfg, len);
-    if (err)
-        ALOGE("%s: ERROR. Mixer ctl set failed", __func__);
-exit:
-    return;
-}
-#endif /* CUSTOM_STEREO_ENABLED */
-
 #ifndef DTS_EAGLE
 #define audio_extn_hpx_set_parameters(adev, parms)         (0)
 #define audio_extn_hpx_get_parameters(query, reply)  (0)
@@ -501,37 +409,28 @@
 }
 #endif
 
-#ifdef HIFI_AUDIO_ENABLED
-bool audio_extn_is_hifi_audio_enabled(void)
+// START: VBAT =============================================================
+void vbat_feature_init(bool is_feature_enabled)
 {
-    ALOGV("%s: status: %d", __func__, aextnmod.hifi_audio_enabled);
-    return (aextnmod.hifi_audio_enabled ? true: false);
+    audio_extn_vbat_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature VBAT is %s ----",
+                  __func__, is_feature_enabled ? "ENABLED": " NOT ENABLED");
 }
 
-bool audio_extn_is_hifi_audio_supported(void)
-{
-    /*
-     * for internal codec, check for hifiaudio property to enable hifi audio
-     */
-    if (property_get_bool("persist.vendor.audio.hifi.int_codec", false))
-    {
-        ALOGD("%s: hifi audio supported on internal codec", __func__);
-        aextnmod.hifi_audio_enabled = 1;
-    }
-
-    return (aextnmod.hifi_audio_enabled ? true: false);
-}
-#endif
-
-#ifdef VBAT_MONITOR_ENABLED
 bool audio_extn_is_vbat_enabled(void)
 {
+    if (!audio_extn_vbat_enabled)
+        return false;
+
     ALOGD("%s: status: %d", __func__, aextnmod.vbat_enabled);
     return (aextnmod.vbat_enabled ? true: false);
 }
 
 bool audio_extn_can_use_vbat(void)
 {
+    if (!audio_extn_vbat_enabled)
+        return false;
+
     char prop_vbat_enabled[PROPERTY_VALUE_MAX] = "false";
 
     property_get("persist.vendor.audio.vbat.enabled", prop_vbat_enabled, "0");
@@ -545,12 +444,18 @@
 
 bool audio_extn_is_bcl_enabled(void)
 {
+    if (!audio_extn_vbat_enabled)
+        return false;
+
     ALOGD("%s: status: %d", __func__, aextnmod.bcl_enabled);
     return (aextnmod.bcl_enabled ? true: false);
 }
 
 bool audio_extn_can_use_bcl(void)
 {
+    if (!audio_extn_vbat_enabled)
+        return false;
+
     char prop_bcl_enabled[PROPERTY_VALUE_MAX] = "false";
 
     property_get("persist.vendor.audio.bcl.enabled", prop_bcl_enabled, "0");
@@ -561,28 +466,16 @@
     ALOGD("%s: bcl.enabled property is set to %s", __func__, prop_bcl_enabled);
     return (aextnmod.bcl_enabled ? true: false);
 }
-#endif
 
-#ifdef RAS_ENABLED
-bool audio_extn_is_ras_enabled(void)
+// START: ANC_HEADSET -------------------------------------------------------
+void anc_headset_feature_init(bool is_feature_enabled)
 {
-    ALOGD("%s: status: %d", __func__, aextnmod.ras_enabled);
-    return (aextnmod.ras_enabled ? true: false);
+    audio_extn_anc_headset_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature FM_POWER_OPT is %s----", __func__,
+                                    is_feature_enabled? "ENABLED": "NOT ENABLED");
+
 }
 
-bool audio_extn_can_use_ras(void)
-{
-    if (property_get_bool("persist.vendor.audio.ras.enabled", false))
-        aextnmod.ras_enabled = 1;
-
-    ALOGD("%s: ras.enabled property is set to %d", __func__, aextnmod.ras_enabled);
-    return (aextnmod.ras_enabled ? true: false);
-}
-#endif
-
-#ifndef ANC_HEADSET_ENABLED
-#define audio_extn_set_anc_parameters(adev, parms)       (0)
-#else
 bool audio_extn_get_anc_enabled(void)
 {
     ALOGD("%s: anc_enabled:%d", __func__, aextnmod.anc_enabled);
@@ -591,26 +484,31 @@
 
 bool audio_extn_should_use_handset_anc(int in_channels)
 {
-    char prop_aanc[PROPERTY_VALUE_MAX] = "false";
+    if (audio_extn_anc_headset_feature_enabled) {
+        char prop_aanc[PROPERTY_VALUE_MAX] = "false";
 
-    property_get("persist.vendor.audio.aanc.enable", prop_aanc, "0");
-    if (!strncmp("true", prop_aanc, 4)) {
-        ALOGD("%s: AANC enabled in the property", __func__);
-        aextnmod.aanc_enabled = 1;
+        property_get("persist.vendor.audio.aanc.enable", prop_aanc, "0");
+        if (!strncmp("true", prop_aanc, 4)) {
+            ALOGD("%s: AANC enabled in the property", __func__);
+            aextnmod.aanc_enabled = 1;
+        }
+
+        return (aextnmod.aanc_enabled && aextnmod.anc_enabled
+                && (in_channels == 1));
     }
-
-    return (aextnmod.aanc_enabled && aextnmod.anc_enabled
-            && (in_channels == 1));
+    return false;
 }
 
 bool audio_extn_should_use_fb_anc(void)
 {
   char prop_anc[PROPERTY_VALUE_MAX] = "feedforward";
 
-  property_get("persist.vendor.audio.headset.anc.type", prop_anc, "0");
-  if (!strncmp("feedback", prop_anc, sizeof("feedback"))) {
-    ALOGD("%s: FB ANC headset type enabled\n", __func__);
-    return true;
+  if (audio_extn_anc_headset_feature_enabled) {
+      property_get("persist.vendor.audio.headset.anc.type", prop_anc, "0");
+      if (!strncmp("feedback", prop_anc, sizeof("feedback"))) {
+        ALOGD("%s: FB ANC headset type enabled\n", __func__);
+        return true;
+      }
   }
   return false;
 }
@@ -623,15 +521,17 @@
     struct mixer_ctl *ctl = NULL;
     const char *mixer_ctl_name = "AANC Noise Level";
 
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_AANC_NOISE_LEVEL, value,
+    if(audio_extn_anc_headset_feature_enabled) {
+        ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_AANC_NOISE_LEVEL, value,
                             sizeof(value));
-    if (ret >= 0) {
-        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-        if (ctl)
-            mixer_ctl_set_value(ctl, 0, atoi(value));
-        else
-            ALOGW("%s: Not able to get mixer ctl: %s",
-                  __func__, mixer_ctl_name);
+        if (ret >= 0) {
+            ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+            if (ctl)
+                mixer_ctl_set_value(ctl, 0, atoi(value));
+            else
+                ALOGW("%s: Not able to get mixer ctl: %s",
+                      __func__, mixer_ctl_name);
+        }
     }
 }
 
@@ -646,6 +546,9 @@
     struct str_parms *reply_44_1;
     struct str_parms *parms_disable_44_1;
 
+    if(!audio_extn_anc_headset_feature_enabled)
+        return;
+
     ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_ANC, value,
                             sizeof(value));
     if (ret >= 0) {
@@ -715,66 +618,8 @@
 
     ALOGD("%s: anc_enabled:%d", __func__, aextnmod.anc_enabled);
 }
-#endif /* ANC_HEADSET_ENABLED */
+// END: ANC_HEADSET -------------------------------------------------------
 
-#ifndef FLUENCE_ENABLED
-#define audio_extn_set_fluence_parameters(adev, parms) (0)
-#define audio_extn_get_fluence_parameters(adev, query, reply) (0)
-#else
-void audio_extn_set_fluence_parameters(struct audio_device *adev,
-                                            struct str_parms *parms)
-{
-    int ret = 0, err;
-    char value[32];
-    struct listnode *node;
-    struct audio_usecase *usecase;
-
-    err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE,
-                                 value, sizeof(value));
-    ALOGV_IF(err >= 0, "%s: Set Fluence Type to %s", __func__, value);
-    if (err >= 0) {
-        ret = platform_set_fluence_type(adev->platform, value);
-        if (ret != 0) {
-            ALOGE("platform_set_fluence_type returned error: %d", ret);
-        } else {
-            /*
-             *If the fluence is manually set/reset, devices
-             *need to get updated for all the usecases
-             *i.e. audio and voice.
-             */
-             list_for_each(node, &adev->usecase_list) {
-                 usecase = node_to_item(node, struct audio_usecase, list);
-                 select_devices(adev, usecase->id);
-             }
-        }
-    }
-}
-
-int audio_extn_get_fluence_parameters(const struct audio_device *adev,
-                       struct str_parms *query, struct str_parms *reply)
-{
-    int ret = 0, err;
-    char value[256] = {0};
-
-    err = str_parms_get_str(query, AUDIO_PARAMETER_KEY_FLUENCE, value,
-                                                          sizeof(value));
-    if (err >= 0) {
-        ret = platform_get_fluence_type(adev->platform, value, sizeof(value));
-        if (ret >= 0) {
-            ALOGV("%s: Fluence Type is %s", __func__, value);
-            str_parms_add_str(reply, AUDIO_PARAMETER_KEY_FLUENCE, value);
-        } else
-            goto done;
-    }
-done:
-    return ret;
-}
-#endif /* FLUENCE_ENABLED */
-
-#ifndef AFE_PROXY_ENABLED
-#define audio_extn_set_afe_proxy_parameters(adev, parms)  (0)
-#define audio_extn_get_afe_proxy_parameters(adev, query, reply) (0)
-#else
 static int32_t afe_proxy_set_channel_mapping(struct audio_device *adev,
                                                      int channel_count)
 {
@@ -834,6 +679,11 @@
     struct mixer_ctl *ctl = NULL;
     const char *mixer_ctl_name = "PROXY_RX Channels";
 
+    if (!audio_feature_manager_is_feature_enabled(AFE_PROXY)) {
+        ALOGW("%s: AFE_PROXY is disabled", __func__);
+        return -ENOSYS;
+    }
+
     ALOGD("%s: entry", __func__);
     /* use the existing channel count set by hardware params to
     configure the back end for stereo as usb/a2dp would be
@@ -910,6 +760,11 @@
     int ret = 0;
     int channels = aextnmod.proxy_channel_num;
 
+    if (!audio_feature_manager_is_feature_enabled(AFE_PROXY)) {
+        ALOGW("%s: AFE_PROXY is disabled", __func__);
+        return -ENOSYS;
+    }
+
     switch (channels) {
         /*
          * Do not handle stereo output in Multi-channel cases
@@ -934,11 +789,15 @@
 
 int32_t audio_extn_get_afe_proxy_channel_count()
 {
+
+    if (!audio_feature_manager_is_feature_enabled(AFE_PROXY)) {
+        ALOGW("%s: AFE_PROXY is disabled", __func__);
+        return -ENOSYS;
+    }
+
     return aextnmod.proxy_channel_num;
 }
 
-#endif /* AFE_PROXY_ENABLED */
-
 static int get_active_offload_usecases(const struct audio_device *adev,
                                        struct str_parms *query,
                                        struct str_parms *reply)
@@ -963,8 +822,1515 @@
     return ret;
 }
 
+void compress_meta_data_feature_init(bool is_featuer_enabled)
+{
+    is_compress_meta_data_enabled = is_featuer_enabled;
+}
+
+bool if_compress_meta_data_feature_enabled()
+{
+    return is_compress_meta_data_enabled;
+}
+
+//START: USB_OFFLOAD ==========================================================
+// LIB is part of hal lib, so no need for dlopen and getting function pointer
+// rather have function declared here
+
+void usb_init(void *adev);
+void usb_deinit();
+void usb_add_device(audio_devices_t device, int card);
+void usb_remove_device(audio_devices_t device, int card);
+bool usb_is_config_supported(unsigned int *bit_width,
+                                        unsigned int *sample_rate,
+                                        unsigned int *ch,
+                                        bool is_playback);
+int usb_enable_sidetone(int device, bool enable);
+void usb_set_sidetone_gain(struct str_parms *parms,
+                                     char *value, int len);
+bool usb_is_capture_supported();
+int usb_get_max_channels(bool playback);
+int usb_get_max_bit_width(bool playback);
+int usb_get_sup_sample_rates(bool type, uint32_t *sr, uint32_t l);
+bool usb_is_tunnel_supported();
+bool usb_alive(int card);
+bool usb_connected(struct str_parms *parms);
+unsigned long usb_find_service_interval(bool min, bool playback);
+int usb_altset_for_service_interval(bool is_playback,
+                                               unsigned long service_interval,
+                                               uint32_t *bit_width,
+                                               uint32_t *sample_rate,
+                                               uint32_t *channel_count);
+int usb_set_service_interval(bool playback,
+                                        unsigned long service_interval,
+                                        bool *reconfig);
+int usb_get_service_interval(bool playback,
+                                        unsigned long *service_interval);
+int usb_check_and_set_svc_int(struct audio_usecase *uc_info,
+                                         bool starting_output_stream);
+bool usb_is_reconfig_req();
+void usb_set_reconfig(bool is_required);
+
+static bool is_usb_offload_enabled = false;
+static bool is_usb_burst_mode_enabled = false;
+static bool is_usb_sidetone_vol_enabled = false;
+
+void usb_offload_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    is_usb_offload_enabled = is_feature_enabled;
+}
+
+void usb_offload_burst_mode_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    is_usb_burst_mode_enabled = is_feature_enabled;
+}
+
+void usb_offload_sidetone_volume_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    is_usb_sidetone_vol_enabled = is_feature_enabled;
+}
+
+bool audio_extn_usb_is_sidetone_volume_enabled()
+{
+    return is_usb_sidetone_vol_enabled;
+}
+
+void audio_extn_usb_init(void *adev)
+{
+    if (is_usb_offload_enabled)
+        usb_init(adev);
+}
+
+
+void audio_extn_usb_deinit()
+{
+    if (is_usb_offload_enabled)
+        usb_deinit();
+}
+
+void audio_extn_usb_add_device(audio_devices_t device, int card)
+{
+    if (is_usb_offload_enabled)
+        usb_add_device(device, card);
+}
+
+void audio_extn_usb_remove_device(audio_devices_t device, int card)
+{
+    if (is_usb_offload_enabled)
+        usb_remove_device(device, card);
+}
+
+bool audio_extn_usb_is_config_supported(unsigned int *bit_width,
+                                        unsigned int *sample_rate,
+                                        unsigned int *ch,
+                                        bool is_playback)
+{
+    bool ret_val = false;
+    if (is_usb_offload_enabled)
+        ret_val = usb_is_config_supported(bit_width, sample_rate, ch, is_playback);
+
+    return ret_val;
+}
+
+int audio_extn_usb_enable_sidetone(int device, bool enable)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled)
+        ret_val = usb_enable_sidetone(device, enable);
+
+    return ret_val;
+}
+
+void audio_extn_usb_set_sidetone_gain(struct str_parms *parms,
+                                      char *value, int len)
+{
+    if (is_usb_offload_enabled)
+        usb_set_sidetone_gain(parms, value, len);
+}
+
+bool audio_extn_usb_is_capture_supported()
+{
+    bool ret_val = false;
+    if (is_usb_offload_enabled)
+        ret_val = usb_is_capture_supported();
+
+    return ret_val;
+}
+
+int audio_extn_usb_get_max_channels(bool playback)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled)
+        ret_val = usb_get_max_channels(playback);
+
+    return ret_val;
+}
+
+int audio_extn_usb_get_max_bit_width(bool playback)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled)
+        ret_val = usb_get_max_bit_width(playback);
+
+    return ret_val;
+}
+
+
+int audio_extn_usb_get_sup_sample_rates(bool type, uint32_t *sr, uint32_t l)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled)
+        ret_val = usb_get_sup_sample_rates(type, sr, l);
+
+    return ret_val;
+}
+
+bool audio_extn_usb_is_tunnel_supported()
+{
+    bool ret_val = false;
+    if (is_usb_offload_enabled)
+        ret_val = usb_is_tunnel_supported();
+
+    return ret_val;
+}
+
+bool audio_extn_usb_alive(int card)
+{
+    bool ret_val = false;
+    if (is_usb_offload_enabled)
+        ret_val = usb_alive(card);
+
+    return ret_val;
+}
+
+bool audio_extn_usb_connected(struct str_parms *parms)
+{
+    bool ret_val = false;
+    if (is_usb_offload_enabled)
+        ret_val = usb_connected(parms);
+
+    return ret_val;
+}
+
+unsigned long audio_extn_usb_find_service_interval(bool min, bool playback)
+{
+    unsigned long ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_find_service_interval(min, playback);
+
+    return ret_val;
+}
+
+int audio_extn_usb_altset_for_service_interval(bool is_playback,
+                                               unsigned long service_interval,
+                                               uint32_t *bit_width,
+                                               uint32_t *sample_rate,
+                                               uint32_t *channel_count)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_altset_for_service_interval(is_playback, service_interval,
+                                         bit_width, sample_rate, channel_count);
+
+    return ret_val;
+}
+
+int audio_extn_usb_set_service_interval(bool playback,
+                                        unsigned long service_interval,
+                                        bool *reconfig)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_set_service_interval(playback, service_interval, reconfig);
+
+    return ret_val;
+}
+
+int audio_extn_usb_get_service_interval(bool playback,
+                                        unsigned long *service_interval)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_get_service_interval(playback, service_interval);
+
+    return ret_val;
+}
+
+int audio_extn_usb_check_and_set_svc_int(struct audio_usecase *uc_info,
+                                         bool starting_output_stream)
+{
+    int ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_check_and_set_svc_int(uc_info, starting_output_stream);
+
+    return ret_val;
+}
+
+bool audio_extn_usb_is_reconfig_req()
+{
+    bool ret_val = 0;
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        ret_val = usb_is_reconfig_req();
+
+    return ret_val;
+}
+
+void audio_extn_usb_set_reconfig(bool is_required)
+{
+    if (is_usb_offload_enabled && is_usb_burst_mode_enabled)
+        usb_set_reconfig(is_required);
+}
+
+//END: USB_OFFLOAD ===========================================================
+
+//START: SPEAKER_PROTECTION ==========================================================
+#ifdef __LP64__
+#define SPKR_PROT_LIB_PATH  "/vendor/lib64/libspkrprot.so"
+#define CIRRUS_SPKR_PROT_LIB_PATH  "/vendor/lib64/libcirrusspkrprot.so"
+#else
+#define SPKR_PROT_LIB_PATH  "/vendor/lib/libspkrprot.so"
+#define CIRRUS_SPKR_PROT_LIB_PATH  "/vendor/lib/libcirrusspkrprot.so"
+#endif
+
+static void *spkr_prot_lib_handle = NULL;
+
+typedef void (*spkr_prot_init_t)(void *, spkr_prot_init_config_t);
+static spkr_prot_init_t spkr_prot_init;
+
+typedef int (*spkr_prot_deinit_t)();
+static spkr_prot_deinit_t spkr_prot_deinit;
+
+typedef int (*spkr_prot_start_processing_t)(snd_device_t);
+static spkr_prot_start_processing_t spkr_prot_start_processing;
+
+typedef void (*spkr_prot_stop_processing_t)(snd_device_t);
+static spkr_prot_stop_processing_t spkr_prot_stop_processing;
+
+typedef bool (*spkr_prot_is_enabled_t)();
+static spkr_prot_is_enabled_t spkr_prot_is_enabled;
+
+typedef void (*spkr_prot_calib_cancel_t)(void *);
+static spkr_prot_calib_cancel_t spkr_prot_calib_cancel;
+
+typedef void (*spkr_prot_set_parameters_t)(struct str_parms *,
+                                           char *, int);
+static spkr_prot_set_parameters_t spkr_prot_set_parameters;
+
+typedef int (*fbsp_set_parameters_t)(struct str_parms *);
+static fbsp_set_parameters_t fbsp_set_parameters;
+
+typedef int (*fbsp_get_parameters_t)(struct str_parms *,
+                                   struct str_parms *);
+static fbsp_get_parameters_t fbsp_get_parameters;
+
+typedef int (*get_spkr_prot_snd_device_t)(snd_device_t);
+static get_spkr_prot_snd_device_t get_spkr_prot_snd_device;
+
+void spkr_prot_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        if (is_running_on_stock_version)
+            spkr_prot_lib_handle = dlopen(CIRRUS_SPKR_PROT_LIB_PATH, RTLD_NOW);
+        else
+            spkr_prot_lib_handle = dlopen(SPKR_PROT_LIB_PATH, RTLD_NOW);
+
+        if (spkr_prot_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //if mandatoy functions are not found, disble feature
+
+        // Mandatory functions
+        if (((spkr_prot_init =
+             (spkr_prot_init_t)dlsym(spkr_prot_lib_handle, "spkr_prot_init")) == NULL) ||
+            ((spkr_prot_deinit =
+             (spkr_prot_deinit_t)dlsym(spkr_prot_lib_handle, "spkr_prot_deinit")) == NULL) ||
+            ((spkr_prot_start_processing =
+             (spkr_prot_start_processing_t)dlsym(spkr_prot_lib_handle, "spkr_prot_start_processing")) == NULL) ||
+            ((spkr_prot_stop_processing =
+             (spkr_prot_stop_processing_t)dlsym(spkr_prot_lib_handle, "spkr_prot_stop_processing")) == NULL) ||
+            ((spkr_prot_is_enabled =
+             (spkr_prot_is_enabled_t)dlsym(spkr_prot_lib_handle, "spkr_prot_is_enabled")) == NULL) ||
+            ((spkr_prot_calib_cancel =
+             (spkr_prot_calib_cancel_t)dlsym(spkr_prot_lib_handle, "spkr_prot_calib_cancel")) == NULL) ||
+            ((get_spkr_prot_snd_device =
+             (get_spkr_prot_snd_device_t)dlsym(spkr_prot_lib_handle, "get_spkr_prot_snd_device")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        // options functions, can be NULL
+
+        spkr_prot_set_parameters = NULL;
+        fbsp_set_parameters = NULL;
+        fbsp_get_parameters = NULL;
+        if ((spkr_prot_set_parameters =
+             (spkr_prot_set_parameters_t)dlsym(spkr_prot_lib_handle, "spkr_prot_set_parameters")) == NULL) {
+            ALOGW("%s: dlsym failed for spkr_prot_set_parameters", __func__);
+        }
+
+        if ((fbsp_set_parameters =
+             (fbsp_set_parameters_t)dlsym(spkr_prot_lib_handle, "fbsp_set_parameters")) == NULL) {
+            ALOGW("%s: dlsym failed for fbsp_set_parameters", __func__);
+        }
+
+        if ((fbsp_get_parameters =
+             (fbsp_get_parameters_t)dlsym(spkr_prot_lib_handle, "fbsp_get_parameters")) == NULL) {
+            ALOGW("%s: dlsym failed for fbsp_get_parameters", __func__);
+        }
+
+        ALOGD("%s:: ---- Feature SPKR_PROT is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (spkr_prot_lib_handle) {
+        dlclose(spkr_prot_lib_handle);
+        spkr_prot_lib_handle = NULL;
+    }
+
+    spkr_prot_init = NULL;
+    spkr_prot_deinit = NULL;
+    spkr_prot_start_processing = NULL;
+    spkr_prot_stop_processing = NULL;
+    spkr_prot_is_enabled = NULL;
+    spkr_prot_calib_cancel = NULL;
+    spkr_prot_set_parameters = NULL;
+    fbsp_set_parameters = NULL;
+    fbsp_get_parameters = NULL;
+    get_spkr_prot_snd_device = NULL;
+
+    ALOGW(":: %s: ---- Feature SPKR_PROT is disabled ----", __func__);
+    return;
+}
+
+void audio_extn_spkr_prot_init(void *adev) {
+    if (spkr_prot_init != NULL) {
+        // init function pointers
+        spkr_prot_init_config_t spkr_prot_config_val;
+        spkr_prot_config_val.fp_read_line_from_file = read_line_from_file;
+        spkr_prot_config_val.fp_get_usecase_from_list = get_usecase_from_list;
+        spkr_prot_config_val.fp_disable_snd_device  = disable_snd_device;
+        spkr_prot_config_val.fp_enable_snd_device = enable_snd_device;
+        spkr_prot_config_val.fp_disable_audio_route = disable_audio_route;
+        spkr_prot_config_val.fp_enable_audio_route = enable_audio_route;
+        spkr_prot_config_val.fp_platform_set_snd_device_backend = platform_set_snd_device_backend;
+        spkr_prot_config_val.fp_platform_get_snd_device_name_extn = platform_get_snd_device_name_extn;
+        spkr_prot_config_val.fp_platform_get_default_app_type_v2 = platform_get_default_app_type_v2;
+        spkr_prot_config_val.fp_platform_send_audio_calibration = platform_send_audio_calibration;
+        spkr_prot_config_val.fp_platform_get_pcm_device_id = platform_get_pcm_device_id;
+        spkr_prot_config_val.fp_platform_get_snd_device_name = platform_get_snd_device_name;
+        spkr_prot_config_val.fp_platform_spkr_prot_is_wsa_analog_mode = platform_spkr_prot_is_wsa_analog_mode;
+        spkr_prot_config_val.fp_platform_get_vi_feedback_snd_device = platform_get_vi_feedback_snd_device;
+        spkr_prot_config_val.fp_platform_get_spkr_prot_snd_device = platform_get_spkr_prot_snd_device;
+        spkr_prot_config_val.fp_platform_check_and_set_codec_backend_cfg = platform_check_and_set_codec_backend_cfg;
+        spkr_prot_config_val.fp_audio_extn_get_snd_card_split = audio_extn_get_snd_card_split;
+        spkr_prot_config_val.fp_audio_extn_is_vbat_enabled = audio_extn_is_vbat_enabled;
+
+        spkr_prot_init(adev, spkr_prot_config_val);
+    }
+
+    return;
+}
+
+int audio_extn_spkr_prot_deinit() {
+    int ret_val = 0;
+
+    if (spkr_prot_deinit != NULL)
+        ret_val = spkr_prot_deinit();
+
+    return ret_val;
+}
+
+int audio_extn_spkr_prot_start_processing(snd_device_t snd_device) {
+    int ret_val = 0;
+
+    if (spkr_prot_start_processing != NULL)
+        ret_val = spkr_prot_start_processing(snd_device);
+
+    return ret_val;
+}
+
+void audio_extn_spkr_prot_stop_processing(snd_device_t snd_device)
+{
+    if (spkr_prot_stop_processing != NULL)
+        spkr_prot_stop_processing(snd_device);
+
+    return;
+}
+
+bool audio_extn_spkr_prot_is_enabled()
+{
+    bool ret_val = false;
+
+    if (spkr_prot_is_enabled != NULL)
+        ret_val = spkr_prot_is_enabled();
+
+    return ret_val;
+}
+
+void audio_extn_spkr_prot_calib_cancel(void *adev)
+{
+    if (spkr_prot_calib_cancel != NULL)
+        spkr_prot_calib_cancel(adev);
+
+    return;
+}
+
+void audio_extn_spkr_prot_set_parameters(struct str_parms *parms,
+                                         char *value, int len)
+{
+    if (spkr_prot_set_parameters != NULL)
+        spkr_prot_set_parameters(parms, value, len);
+
+    return;
+}
+
+int audio_extn_fbsp_set_parameters(struct str_parms *parms)
+{
+    int ret_val = 0;
+
+    if (fbsp_set_parameters != NULL)
+        ret_val = fbsp_set_parameters(parms);
+
+    return ret_val;
+}
+
+int audio_extn_fbsp_get_parameters(struct str_parms *query,
+                                   struct str_parms *reply)
+{
+    int ret_val = 0;
+
+    if (fbsp_get_parameters != NULL)
+        ret_val = fbsp_get_parameters(query, reply);
+
+    return ret_val;
+}
+
+int audio_extn_get_spkr_prot_snd_device(snd_device_t snd_device)
+{
+    int ret_val = snd_device;
+
+    if (get_spkr_prot_snd_device != NULL)
+        ret_val = get_spkr_prot_snd_device(snd_device);
+
+    return ret_val;
+}
+
+//END: SPEAKER_PROTECTION ==========================================================
+
+//START: EXTERNAL_QDSP ================================================================
+#ifdef __LP64__
+#define EXTERNAL_QDSP_LIB_PATH  "/vendor/lib64/libextqdsp.so"
+#else
+#define EXTERNAL_QDSP_LIB_PATH  "/vendor/lib/libextqdsp.so"
+#endif
+
+static void *external_qdsp_lib_handle = NULL;
+
+typedef void (*external_qdsp_init_t)(void *);
+static external_qdsp_init_t external_qdsp_init;
+
+typedef void (*external_qdsp_deinit_t)(void);
+static external_qdsp_deinit_t external_qdsp_deinit;
+
+typedef bool (*external_qdsp_set_state_t)(struct audio_device *,
+                                        int , float , bool);
+static external_qdsp_set_state_t external_qdsp_set_state;
+
+typedef void (*external_qdsp_set_device_t)(struct audio_usecase *);
+static external_qdsp_set_device_t external_qdsp_set_device;
+
+typedef void (*external_qdsp_set_parameter_t)(struct audio_device *,
+                                              struct str_parms *);
+static external_qdsp_set_parameter_t external_qdsp_set_parameter;
+
+typedef bool (*external_qdsp_supported_usb_t)(void);
+static external_qdsp_supported_usb_t external_qdsp_supported_usb;
+
+void external_qdsp_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        external_qdsp_lib_handle = dlopen(EXTERNAL_QDSP_LIB_PATH, RTLD_NOW);
+        if (external_qdsp_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((external_qdsp_init =
+             (external_qdsp_init_t)dlsym(external_qdsp_lib_handle, "ma_init")) == NULL) ||
+            ((external_qdsp_deinit =
+             (external_qdsp_deinit_t)dlsym(external_qdsp_lib_handle, "ma_deinit")) == NULL) ||
+            ((external_qdsp_set_state =
+             (external_qdsp_set_state_t)dlsym(external_qdsp_lib_handle, "set_state")) == NULL) ||
+            ((external_qdsp_set_device =
+             (external_qdsp_set_device_t)dlsym(external_qdsp_lib_handle, "set_device")) == NULL) ||
+            ((external_qdsp_set_parameter =
+             (external_qdsp_set_parameter_t)dlsym(external_qdsp_lib_handle, "set_parameters")) == NULL) ||
+            ((external_qdsp_supported_usb =
+             (external_qdsp_supported_usb_t)dlsym(external_qdsp_lib_handle, "supported_usb")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature EXTERNAL_QDSP is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (external_qdsp_lib_handle) {
+        dlclose(external_qdsp_lib_handle);
+        external_qdsp_lib_handle = NULL;
+    }
+
+    external_qdsp_init = NULL;
+    external_qdsp_deinit = NULL;
+    external_qdsp_set_state = NULL;
+    external_qdsp_set_device = NULL;
+    external_qdsp_set_parameter = NULL;
+    external_qdsp_supported_usb = NULL;
+
+    ALOGW(":: %s: ---- Feature EXTERNAL_QDSP is disabled ----", __func__);
+    return;
+}
+
+void audio_extn_qdsp_init(void *platform) {
+    if (external_qdsp_init != NULL)
+        external_qdsp_init(platform);
+
+    return;
+}
+
+void audio_extn_qdsp_deinit() {
+    if (external_qdsp_deinit != NULL)
+        external_qdsp_deinit();
+
+    return;
+}
+
+bool audio_extn_qdsp_set_state(struct audio_device *adev, int stream_type,
+                             float vol, bool active) {
+    bool ret_val = false;
+
+    if (external_qdsp_set_state != NULL)
+        ret_val = external_qdsp_set_state(adev, stream_type, vol, active);
+
+    return ret_val;
+}
+
+void audio_extn_qdsp_set_device(struct audio_usecase *usecase) {
+    if (external_qdsp_set_device != NULL)
+        external_qdsp_set_device(usecase);
+
+    return;
+}
+
+void audio_extn_qdsp_set_parameters(struct audio_device *adev,
+                                  struct str_parms *parms) {
+    if (external_qdsp_set_parameter != NULL)
+        external_qdsp_set_parameter(adev, parms);
+
+    return;
+}
+
+bool audio_extn_qdsp_supported_usb() {
+    bool ret_val = false;
+
+    if (external_qdsp_supported_usb != NULL)
+        ret_val = external_qdsp_supported_usb();
+
+    return ret_val;
+}
+
+
+//END: EXTERNAL_QDSP ================================================================
+
+//START: EXTERNAL_SPEAKER ================================================================
+#ifdef __LP64__
+#define EXTERNAL_SPKR_LIB_PATH  "/vendor/lib64/libextspkr.so"
+#else
+#define EXTERNAL_SPKR_LIB_PATH  "/vendor/lib/libextspkr.so"
+#endif
+
+static void *external_speaker_lib_handle = NULL;
+
+typedef void* (*external_speaker_init_t)(struct audio_device *);
+static external_speaker_init_t external_speaker_init;
+
+typedef void (*external_speaker_deinit_t)(void *);
+static external_speaker_deinit_t external_speaker_deinit;
+
+typedef void (*external_speaker_update_t)(void *);
+static external_speaker_update_t external_speaker_update;
+
+typedef void (*external_speaker_set_mode_t)(void *, audio_mode_t);
+static external_speaker_set_mode_t external_speaker_set_mode;
+
+typedef void (*external_speaker_set_voice_vol_t)(void *, float);
+static external_speaker_set_voice_vol_t external_speaker_set_voice_vol;
+
+
+void external_speaker_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        external_speaker_lib_handle = dlopen(EXTERNAL_SPKR_LIB_PATH, RTLD_NOW);
+        if (external_speaker_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((external_speaker_init =
+             (external_speaker_init_t)dlsym(external_speaker_lib_handle, "extspk_init")) == NULL) ||
+            ((external_speaker_deinit =
+             (external_speaker_deinit_t)dlsym(external_speaker_lib_handle, "extspk_deinit")) == NULL) ||
+            ((external_speaker_update =
+             (external_speaker_update_t)dlsym(external_speaker_lib_handle, "extspk_update")) == NULL) ||
+            ((external_speaker_set_mode =
+             (external_speaker_set_mode_t)dlsym(external_speaker_lib_handle, "extspk_set_mode")) == NULL) ||
+            ((external_speaker_set_voice_vol =
+             (external_speaker_set_voice_vol_t)dlsym(external_speaker_lib_handle, "extspk_set_voice_vol")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature EXTERNAL_SPKR is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (external_speaker_lib_handle) {
+        dlclose(external_speaker_lib_handle);
+        external_speaker_lib_handle = NULL;
+    }
+
+    external_speaker_init = NULL;
+    external_speaker_deinit = NULL;
+    external_speaker_update = NULL;
+    external_speaker_set_mode = NULL;
+    external_speaker_set_voice_vol = NULL;
+
+    ALOGW(":: %s: ---- Feature EXTERNAL_SPKR is disabled ----", __func__);
+    return;
+}
+
+void *audio_extn_extspk_init(struct audio_device *adev) {
+    void* ret_val = NULL;
+
+    if (external_speaker_init != NULL)
+        ret_val = external_speaker_init(adev);
+
+    return ret_val;
+}
+
+void audio_extn_extspk_deinit(void *extn) {
+    if (external_speaker_deinit != NULL)
+        external_speaker_deinit(extn);
+
+    return;
+}
+
+void audio_extn_extspk_update(void* extn) {
+    if (external_speaker_update != NULL)
+        external_speaker_update(extn);
+
+    return;
+}
+
+void audio_extn_extspk_set_mode(void* extn, audio_mode_t mode) {
+    if (external_speaker_set_mode != NULL)
+        external_speaker_set_mode(extn, mode);
+
+    return;
+}
+
+void audio_extn_extspk_set_voice_vol(void* extn, float vol) {
+    if (external_speaker_set_voice_vol != NULL)
+        external_speaker_set_voice_vol(extn, vol);
+
+    return;
+}
+
+//END: EXTERNAL_SPEAKER ================================================================
+
+
+//START: EXTERNAL_SPEAKER_TFA ================================================================
+#ifdef __LP64__
+#define EXTERNAL_SPKR_TFA_LIB_PATH  "/vendor/lib64/libextspkr_tfa.so"
+#else
+#define EXTERNAL_SPKR_TFA_LIB_PATH  "/vendor/lib/libextspkr_tfa.so"
+#endif
+
+static void *external_speaker_tfa_lib_handle = NULL;
+
+typedef int (*external_speaker_tfa_enable_t)(void);
+static external_speaker_tfa_enable_t external_speaker_tfa_enable;
+
+typedef void (*external_speaker_tfa_disable_t)(snd_device_t);
+static external_speaker_tfa_disable_t external_speaker_tfa_disable;
+
+typedef void (*external_speaker_tfa_set_mode_t)();
+static external_speaker_tfa_set_mode_t external_speaker_tfa_set_mode;
+
+typedef void (*external_speaker_tfa_set_mode_bt_t)();
+static external_speaker_tfa_set_mode_bt_t external_speaker_tfa_set_mode_bt;
+
+typedef void (*external_speaker_tfa_update_t)(void);
+static external_speaker_tfa_update_t external_speaker_tfa_update;
+
+typedef void (*external_speaker_tfa_set_voice_vol_t)(float);
+static external_speaker_tfa_set_voice_vol_t external_speaker_tfa_set_voice_vol;
+
+typedef int (*external_speaker_tfa_init_t)(struct audio_device *);
+static external_speaker_tfa_init_t external_speaker_tfa_init;
+
+typedef void (*external_speaker_tfa_deinit_t)(void);
+static external_speaker_tfa_deinit_t external_speaker_tfa_deinit;
+
+typedef bool (*external_speaker_tfa_is_supported_t)(void);
+static external_speaker_tfa_is_supported_t external_speaker_tfa_is_supported;
+
+void external_speaker_tfa_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        external_speaker_tfa_lib_handle = dlopen(EXTERNAL_SPKR_TFA_LIB_PATH, RTLD_NOW);
+        if (external_speaker_tfa_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((external_speaker_tfa_enable =
+             (external_speaker_tfa_enable_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_enable_speaker")) == NULL) ||
+            ((external_speaker_tfa_disable =
+             (external_speaker_tfa_disable_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_disable_speaker")) == NULL) ||
+            ((external_speaker_tfa_set_mode =
+             (external_speaker_tfa_set_mode_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_set_mode")) == NULL) ||
+            ((external_speaker_tfa_set_mode_bt =
+             (external_speaker_tfa_set_mode_bt_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_set_mode_bt")) == NULL) ||
+            ((external_speaker_tfa_update =
+             (external_speaker_tfa_update_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_update")) == NULL) ||
+            ((external_speaker_tfa_set_voice_vol =
+             (external_speaker_tfa_set_voice_vol_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_set_voice_vol")) == NULL) ||
+            ((external_speaker_tfa_init =
+             (external_speaker_tfa_init_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_init")) == NULL) ||
+            ((external_speaker_tfa_deinit =
+             (external_speaker_tfa_deinit_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_deinit")) == NULL) ||
+            ((external_speaker_tfa_is_supported =
+             (external_speaker_tfa_is_supported_t)dlsym(external_speaker_tfa_lib_handle, "tfa_98xx_is_supported")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature EXTERNAL_SPKR is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (external_speaker_tfa_lib_handle) {
+        dlclose(external_speaker_tfa_lib_handle);
+        external_speaker_tfa_lib_handle = NULL;
+    }
+
+    external_speaker_tfa_enable = NULL;
+    external_speaker_tfa_disable = NULL;
+    external_speaker_tfa_set_mode = NULL;
+    external_speaker_tfa_update = NULL;
+    external_speaker_tfa_set_voice_vol = NULL;
+    external_speaker_tfa_init = NULL;
+    external_speaker_tfa_deinit = NULL;
+    external_speaker_tfa_is_supported = NULL;
+
+    ALOGW(":: %s: ---- Feature EXTERNAL_SPKR_TFA is disabled ----", __func__);
+    return;
+}
+
+int audio_extn_external_speaker_tfa_enable_speaker() {
+    int ret_val = 0;
+
+    if (external_speaker_tfa_enable != NULL)
+        ret_val = external_speaker_tfa_enable();
+
+    return ret_val;
+}
+
+void audio_extn_external_speaker_tfa_disable_speaker(snd_device_t snd_device) {
+    if (external_speaker_tfa_disable != NULL)
+        external_speaker_tfa_disable(snd_device);
+
+    return;
+}
+
+void audio_extn_external_speaker_tfa_set_mode(bool is_mode_bt) {
+    if (is_mode_bt && (external_speaker_tfa_set_mode_bt != NULL))
+        external_speaker_tfa_set_mode_bt();
+    else if (external_speaker_tfa_set_mode != NULL)
+        external_speaker_tfa_set_mode();
+
+    return;
+}
+
+void audio_extn_external_speaker_tfa_update() {
+    if (external_speaker_tfa_update != NULL)
+        external_speaker_tfa_update();
+
+    return;
+}
+
+void audio_extn_external_speaker_tfa_set_voice_vol(float vol) {
+    if (external_speaker_tfa_set_voice_vol != NULL)
+        external_speaker_tfa_set_voice_vol(vol);
+
+    return;
+}
+
+int  audio_extn_external_tfa_speaker_init(struct audio_device *adev) {
+    int ret_val = 0;
+
+    if (external_speaker_tfa_init != NULL)
+        ret_val = external_speaker_tfa_init(adev);
+
+    return ret_val;
+}
+
+void audio_extn_external_speaker_tfa_deinit() {
+    if (external_speaker_tfa_deinit != NULL)
+        external_speaker_tfa_deinit();
+
+    return;
+}
+
+bool audio_extn_external_speaker_tfa_is_supported() {
+    bool ret_val = false;
+
+    if (external_speaker_tfa_is_supported != NULL)
+        ret_val = external_speaker_tfa_is_supported;
+
+    return ret_val;
+}
+
+
+//END: EXTERNAL_SPEAKER_TFA ================================================================
+
+
+//START: HWDEP_CAL ================================================================
+#ifdef __LP64__
+#define HWDEP_CAL_LIB_PATH  "/vendor/lib64/libhwdepcal.so"
+#else
+#define HWDEP_CAL_LIB_PATH  "/vendor/lib/libhwdepcal.so"
+#endif
+
+static void *hwdep_cal_lib_handle = NULL;
+
+typedef void (*hwdep_cal_send_t)(int, void*);
+static hwdep_cal_send_t hwdep_cal_send;
+
+void hwdep_cal_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        hwdep_cal_lib_handle = dlopen(HWDEP_CAL_LIB_PATH, RTLD_NOW);
+        if (hwdep_cal_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if ((hwdep_cal_send =
+            (hwdep_cal_send_t)dlsym(hwdep_cal_lib_handle, "hwdep_cal_send")) == NULL) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature HWDEP_CAL is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (hwdep_cal_lib_handle) {
+        dlclose(hwdep_cal_lib_handle);
+        hwdep_cal_lib_handle = NULL;
+    }
+
+    hwdep_cal_send = NULL;
+
+    ALOGW(":: %s: ---- Feature HWDEP_CAL is disabled ----", __func__);
+    return;
+}
+
+void audio_extn_hwdep_cal_send(int snd_card, void *acdb_handle)
+{
+    if (hwdep_cal_send != NULL)
+        hwdep_cal_send(snd_card, acdb_handle);
+
+    return;
+}
+
+
+//END: HWDEP_CAL =====================================================================
+
+
+//START: DSM_FEEDBACK ================================================================
+#ifdef __LP64__
+#define DSM_FEEDBACK_LIB_PATH  "/vendor/lib64/libdsmfeedback.so"
+#else
+#define DSM_FEEDBACK_LIB_PATH  "/vendor/lib/libdsmfeedback.so"
+#endif
+
+static void *dsm_feedback_lib_handle = NULL;
+
+typedef void (*dsm_feedback_enable_t)(struct audio_device*, snd_device_t, bool);
+static dsm_feedback_enable_t dsm_feedback_enable;
+
+void dsm_feedback_feature_init (bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        dsm_feedback_lib_handle = dlopen(DSM_FEEDBACK_LIB_PATH, RTLD_NOW);
+        if (dsm_feedback_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if ((dsm_feedback_enable =
+            (dsm_feedback_enable_t)dlsym(dsm_feedback_lib_handle, "dsm_feedback_enable")) == NULL) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature DSM_FEEDBACK is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (dsm_feedback_lib_handle) {
+        dlclose(dsm_feedback_lib_handle);
+        dsm_feedback_lib_handle = NULL;
+    }
+
+    dsm_feedback_enable = NULL;
+
+    ALOGW(":: %s: ---- Feature DSM_FEEDBACK is disabled ----", __func__);
+    return;
+}
+
+void audio_extn_dsm_feedback_enable(struct audio_device *adev, snd_device_t snd_device, bool benable)
+{
+    if (dsm_feedback_enable != NULL)
+        dsm_feedback_enable(adev, snd_device, benable);
+
+    return;
+}
+
+//END:   DSM_FEEDBACK ================================================================
+
+//START: SND_MONITOR_FEATURE ================================================================
+#ifdef __LP64__
+#define SND_MONITOR_PATH  "/vendor/lib64/libsndmonitor.so"
+#else
+#define SND_MONITOR_PATH  "/vendor/lib/libsndmonitor.so"
+#endif
+static void *snd_mnt_lib_handle = NULL;
+
+typedef int (*snd_mon_init_t)();
+static snd_mon_init_t snd_mon_init;
+typedef int (*snd_mon_deinit_t)();
+static snd_mon_deinit_t snd_mon_deinit;
+typedef int (*snd_mon_register_listener_t)(void *, snd_mon_cb);
+static snd_mon_register_listener_t snd_mon_register_listener;
+typedef int (*snd_mon_unregister_listener_t)(void *);
+static snd_mon_unregister_listener_t snd_mon_unregister_listener;
+
+void snd_mon_feature_init (bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        snd_mnt_lib_handle = dlopen(SND_MONITOR_PATH, RTLD_NOW);
+        if (snd_mnt_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((snd_mon_init = (snd_mon_init_t)dlsym(snd_mnt_lib_handle,"snd_mon_init")) == NULL) ||
+            ((snd_mon_deinit = (snd_mon_deinit_t)dlsym(snd_mnt_lib_handle,"snd_mon_deinit")) == NULL) ||
+            ((snd_mon_register_listener = (snd_mon_register_listener_t)dlsym(snd_mnt_lib_handle,"snd_mon_register_listener")) == NULL) ||
+            ((snd_mon_unregister_listener = (snd_mon_unregister_listener_t)dlsym(snd_mnt_lib_handle,"snd_mon_unregister_listener")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+        ALOGD("%s:: ---- Feature SND_MONITOR is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (snd_mnt_lib_handle) {
+        dlclose(snd_mnt_lib_handle);
+        snd_mnt_lib_handle = NULL;
+    }
+
+    snd_mon_init                = NULL;
+    snd_mon_deinit              = NULL;
+    snd_mon_register_listener   = NULL;
+    snd_mon_unregister_listener = NULL;
+    ALOGW(":: %s: ---- Feature SND_MONITOR is disabled ----", __func__);
+    return;
+}
+
+int audio_extn_snd_mon_init()
+{
+    int ret = 0;
+    if (snd_mon_init != NULL)
+        ret = snd_mon_init();
+
+    return ret;
+}
+
+int audio_extn_snd_mon_deinit()
+{
+    int ret = 0;
+    if (snd_mon_deinit != NULL)
+        ret = snd_mon_deinit();
+
+    return ret;
+}
+
+int audio_extn_snd_mon_register_listener(void *stream, snd_mon_cb cb)
+{
+    int ret = 0;
+    if (snd_mon_register_listener != NULL)
+        ret = snd_mon_register_listener(stream, cb);
+
+    return ret;
+}
+
+int audio_extn_snd_mon_unregister_listener(void *stream)
+{
+    int ret = 0;
+    if (snd_mon_unregister_listener != NULL)
+        ret = snd_mon_unregister_listener(stream);
+
+    return ret;
+}
+
+//END: SND_MONITOR_FEATURE ================================================================
+
+//START: SOURCE_TRACKING_FEATURE ==============================================
+int get_soundfocus_data(const struct audio_device *adev,
+                                   struct sound_focus_param *payload);
+int get_sourcetrack_data(const struct audio_device *adev,
+                                    struct source_tracking_param *payload);
+int set_soundfocus_data(struct audio_device *adev,
+                                   struct sound_focus_param *payload);
+void source_track_set_parameters(struct audio_device *adev,
+                                            struct str_parms *parms);
+void source_track_get_parameters(const struct audio_device *adev,
+                                            struct str_parms *query,
+                                            struct str_parms *reply);
+
+static bool is_src_trkn_enabled = false;
+
+void src_trkn_feature_init(bool is_feature_enabled) {
+    is_src_trkn_enabled = is_feature_enabled;
+
+    if (is_src_trkn_enabled) {
+        ALOGD("%s:: ---- Feature SOURCE_TRACKING is Enabled ----", __func__);
+        return;
+    }
+
+    ALOGW(":: %s: ---- Feature SOURCE_TRACKING is disabled ----", __func__);
+}
+
+int audio_extn_get_soundfocus_data(const struct audio_device *adev,
+                                   struct sound_focus_param *payload) {
+    int ret = 0;
+
+    if (is_src_trkn_enabled)
+        ret = get_soundfocus_data(adev, payload);
+
+    return ret;
+}
+
+int audio_extn_get_sourcetrack_data(const struct audio_device *adev,
+                                    struct source_tracking_param *payload) {
+    int ret = 0;
+
+    if (is_src_trkn_enabled)
+        ret = get_sourcetrack_data(adev, payload);
+
+    return ret;
+}
+
+int audio_extn_set_soundfocus_data(struct audio_device *adev,
+                                   struct sound_focus_param *payload) {
+    int ret = 0;
+
+    if (is_src_trkn_enabled)
+        ret = set_soundfocus_data(adev, payload);
+
+    return ret;
+}
+
+void audio_extn_source_track_set_parameters(struct audio_device *adev,
+                                            struct str_parms *parms) {
+    if (is_src_trkn_enabled)
+        source_track_set_parameters(adev, parms);
+}
+
+void audio_extn_source_track_get_parameters(const struct audio_device *adev,
+                                            struct str_parms *query,
+                                            struct str_parms *reply) {
+    if (is_src_trkn_enabled)
+        source_track_get_parameters(adev, query, reply);
+}
+//END: SOURCE_TRACKING_FEATURE ================================================
+
+//START: SSREC_FEATURE ==========================================================
+#ifdef __LP64__
+#define SSREC_LIB_PATH  "/vendor/lib64/libssrec.so"
+#else
+#define SSREC_LIB_PATH  "/vendor/lib/libssrec.so"
+#endif
+
+static void *ssrec_lib_handle = NULL;
+
+typedef bool (*ssr_check_usecase_t)(struct stream_in *);
+static ssr_check_usecase_t ssr_check_usecase;
+
+typedef int (*ssr_set_usecase_t)(struct stream_in *,
+                                 struct audio_config *,
+                                 bool *);
+static ssr_set_usecase_t ssr_set_usecase;
+
+typedef int32_t (*ssr_init_t)(struct stream_in *,
+                              int num_out_chan);
+static ssr_init_t ssr_init;
+
+typedef int32_t (*ssr_deinit_t)();
+static ssr_deinit_t ssr_deinit;
+
+typedef void (*ssr_update_enabled_t)();
+static ssr_update_enabled_t ssr_update_enabled;
+
+typedef bool (*ssr_get_enabled_t)();
+static ssr_get_enabled_t ssr_get_enabled;
+
+typedef int32_t (*ssr_read_t)(struct audio_stream_in *,
+                              void *,
+                              size_t);
+static ssr_read_t ssr_read;
+
+typedef void (*ssr_set_parameters_t)(struct audio_device *,
+                                     struct str_parms *);
+static ssr_set_parameters_t ssr_set_parameters;
+
+typedef void (*ssr_get_parameters_t)(const struct audio_device *,
+                                     struct str_parms *,
+                                     struct str_parms *);
+static ssr_get_parameters_t ssr_get_parameters;
+
+typedef struct stream_in *(*ssr_get_stream_t)();
+static ssr_get_stream_t ssr_get_stream;
+
+void ssrec_feature_init(bool is_feature_enabled) {
+
+    if (is_feature_enabled) {
+        ssrec_lib_handle = dlopen(SSREC_LIB_PATH, RTLD_NOW);
+        if (ssrec_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+
+        if (((ssr_check_usecase = (ssr_check_usecase_t)dlsym(ssrec_lib_handle, "ssr_check_usecase")) == NULL) ||
+            ((ssr_set_usecase = (ssr_set_usecase_t)dlsym(ssrec_lib_handle, "ssr_set_usecase")) == NULL) ||
+            ((ssr_init = (ssr_init_t)dlsym(ssrec_lib_handle, "ssr_init")) == NULL) ||
+            ((ssr_deinit = (ssr_deinit_t)dlsym(ssrec_lib_handle, "ssr_deinit")) == NULL) ||
+            ((ssr_update_enabled = (ssr_update_enabled_t)dlsym(ssrec_lib_handle, "ssr_update_enabled")) == NULL) ||
+            ((ssr_get_enabled = (ssr_get_enabled_t)dlsym(ssrec_lib_handle, "ssr_get_enabled")) == NULL) ||
+            ((ssr_read = (ssr_read_t)dlsym(ssrec_lib_handle, "ssr_read")) == NULL) ||
+            ((ssr_set_parameters = (ssr_set_parameters_t)dlsym(ssrec_lib_handle, "ssr_set_parameters")) == NULL) ||
+            ((ssr_get_parameters = (ssr_get_parameters_t)dlsym(ssrec_lib_handle, "ssr_get_parameters")) == NULL) ||
+            ((ssr_get_stream = (ssr_get_stream_t)dlsym(ssrec_lib_handle, "ssr_get_stream")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature SSREC is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if(ssrec_lib_handle) {
+        dlclose(ssrec_lib_handle);
+        ssrec_lib_handle = NULL;
+    }
+
+    ssr_check_usecase = NULL;
+    ssr_set_usecase = NULL;
+    ssr_init = NULL;
+    ssr_deinit = NULL;
+    ssr_update_enabled = NULL;
+    ssr_get_enabled = NULL;
+    ssr_read = NULL;
+    ssr_set_parameters = NULL;
+    ssr_get_parameters = NULL;
+    ssr_get_stream = NULL;
+
+    ALOGW(":: %s: ---- Feature SSREC is disabled ----", __func__);
+}
+
+bool audio_extn_ssr_check_usecase(struct stream_in *in) {
+    bool ret = false;
+
+    if (ssrec_lib_handle != NULL)
+        ret = ssr_check_usecase(in);
+
+    return ret;
+}
+
+int audio_extn_ssr_set_usecase(struct stream_in *in,
+                               struct audio_config *config,
+                               bool *channel_mask_updated) {
+    int ret = 0;
+
+    if (ssrec_lib_handle != NULL)
+        ret = ssr_set_usecase(in, config, channel_mask_updated);
+
+    return ret;
+}
+
+int32_t audio_extn_ssr_init(struct stream_in *in,
+                            int num_out_chan) {
+    int32_t ret = 0;
+
+    if (ssrec_lib_handle != NULL)
+        ret = ssr_init(in, num_out_chan);
+
+    return ret;
+}
+
+int32_t audio_extn_ssr_deinit() {
+    int32_t ret = 0;
+
+    if (ssrec_lib_handle != NULL)
+        ret = ssr_deinit();
+
+    return ret;
+}
+
+void audio_extn_ssr_update_enabled() {
+
+    if (ssrec_lib_handle)
+        ssr_update_enabled();
+}
+
+bool audio_extn_ssr_get_enabled() {
+    bool ret = false;
+
+    if (ssrec_lib_handle)
+        ret = ssr_get_enabled();
+
+    return ret;
+}
+
+int32_t audio_extn_ssr_read(struct audio_stream_in *stream,
+                            void *buffer,
+                            size_t bytes) {
+    int32_t ret = 0;
+
+    if (ssrec_lib_handle)
+        ret = ssr_read(stream, buffer, bytes);
+
+    return ret;
+}
+
+void audio_extn_ssr_set_parameters(struct audio_device *adev,
+                                   struct str_parms *parms) {
+
+    if (ssrec_lib_handle)
+        ssr_set_parameters(adev, parms);
+}
+
+void audio_extn_ssr_get_parameters(const struct audio_device *adev,
+                                   struct str_parms *query,
+                                   struct str_parms *reply) {
+
+    if (ssrec_lib_handle)
+        ssr_get_parameters(adev, query, reply);
+}
+
+struct stream_in *audio_extn_ssr_get_stream() {
+    struct stream_in *ret = NULL;
+
+    if (ssrec_lib_handle)
+        ret = ssr_get_stream();
+
+    return ret;
+}
+//END: SSREC_FEATURE ============================================================
+
+//START: COMPRESS_CAPTURE_FEATURE ================================================================
+#ifdef __LP64__
+#define COMPRESS_CAPTURE_PATH  "/vendor/lib64/libcomprcapture.so"
+#else
+#define COMPRESS_CAPTURE_PATH  "/vendor/lib/libcomprcapture.so"
+#endif
+static void *compr_cap_lib_handle = NULL;
+
+typedef void (*compr_cap_init_t)(struct stream_in*);
+static compr_cap_init_t compr_cap_init;
+
+typedef void (*compr_cap_deinit_t)();
+static compr_cap_deinit_t compr_cap_deinit;
+
+typedef bool (*compr_cap_enabled_t)();
+static compr_cap_enabled_t compr_cap_enabled;
+
+typedef bool (*compr_cap_format_supported_t)(audio_format_t);
+static compr_cap_format_supported_t compr_cap_format_supported;
+
+typedef bool (*compr_cap_usecase_supported_t)(audio_usecase_t);
+static compr_cap_usecase_supported_t compr_cap_usecase_supported;
+
+typedef size_t (*compr_cap_get_buffer_size_t)(audio_usecase_t);
+static compr_cap_get_buffer_size_t compr_cap_get_buffer_size;
+
+typedef int (*compr_cap_read_t)(struct stream_in*, void*, size_t);
+static compr_cap_read_t compr_cap_read;
+
+void compr_cap_feature_init(bool is_feature_enabled)
+{
+    if(is_feature_enabled) {
+        //dlopen lib
+        compr_cap_lib_handle = dlopen(COMPRESS_CAPTURE_PATH, RTLD_NOW);
+        if (compr_cap_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((compr_cap_init = (compr_cap_init_t)dlsym(compr_cap_lib_handle,"compr_cap_init")) == NULL) ||
+            ((compr_cap_deinit = (compr_cap_deinit_t)dlsym(compr_cap_lib_handle,"compr_cap_deinit")) == NULL) ||
+            ((compr_cap_enabled = (compr_cap_enabled_t)dlsym(compr_cap_lib_handle,"compr_cap_enabled")) == NULL) ||
+            ((compr_cap_format_supported = (compr_cap_format_supported_t)dlsym(compr_cap_lib_handle,"compr_cap_format_supported")) == NULL) ||
+            ((compr_cap_usecase_supported = (compr_cap_usecase_supported_t)dlsym(compr_cap_lib_handle,"compr_cap_usecase_supported")) == NULL) ||
+            ((compr_cap_get_buffer_size = (compr_cap_get_buffer_size_t)dlsym(compr_cap_lib_handle,"compr_cap_get_buffer_size")) == NULL) ||
+            ((compr_cap_read = (compr_cap_read_t)dlsym(compr_cap_lib_handle,"compr_cap_read")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature COMPRESS_CAPTURE is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (compr_cap_lib_handle) {
+        dlclose(compr_cap_lib_handle);
+        compr_cap_lib_handle = NULL;
+    }
+
+    compr_cap_init                 = NULL;
+    compr_cap_deinit               = NULL;
+    compr_cap_enabled              = NULL;
+    compr_cap_format_supported     = NULL;
+    compr_cap_usecase_supported    = NULL;
+    compr_cap_get_buffer_size      = NULL;
+    compr_cap_read                 = NULL;
+
+    ALOGW(":: %s: ---- Feature COMPRESS_CAPTURE is disabled ----", __func__);
+    return;
+}
+
+void audio_extn_compr_cap_init(struct stream_in* instream)
+{
+    if (compr_cap_init != NULL)
+        compr_cap_init(instream);
+
+    return;
+}
+
+void audio_extn_compr_cap_deinit()
+{
+    if(compr_cap_deinit)
+        compr_cap_deinit();
+
+    return;
+}
+
+bool audio_extn_compr_cap_enabled()
+{
+    bool ret_val = false;
+
+    if (compr_cap_enabled)
+        ret_val = compr_cap_enabled();
+
+    return ret_val;
+}
+
+bool audio_extn_compr_cap_format_supported(audio_format_t format)
+{
+    bool ret_val = false;
+
+    if (compr_cap_format_supported != NULL)
+        ret_val =  compr_cap_format_supported(format);
+
+    return ret_val;
+}
+
+bool audio_extn_compr_cap_usecase_supported(audio_usecase_t usecase)
+{
+    bool ret_val = false;
+
+    if (compr_cap_usecase_supported != NULL)
+        ret_val =  compr_cap_usecase_supported(usecase);
+
+    return ret_val;
+}
+
+size_t audio_extn_compr_cap_get_buffer_size(audio_format_t format)
+{
+    size_t ret_val = 0;
+
+    if (compr_cap_get_buffer_size != NULL)
+        ret_val =  compr_cap_get_buffer_size(format);
+
+    return ret_val;
+}
+
+size_t audio_extn_compr_cap_read(struct stream_in *in,
+                                        void *buffer, size_t bytes)
+{
+    size_t ret_val = 0;
+
+    if (compr_cap_read != NULL)
+        ret_val =  compr_cap_read(in, buffer, bytes);
+
+    return ret_val;
+}
+
+
 void audio_extn_init(struct audio_device *adev)
 {
+    //fix-me: check running on vendor enhanced build
+    //is_running_on_stock_version = !isRunningWithVendorEnhancedFramework();
+    audio_extn_feature_init();
     aextnmod.anc_enabled = 0;
     aextnmod.aanc_enabled = 0;
     aextnmod.custom_stereo_enabled = 0;
@@ -982,73 +2348,16 @@
     audio_extn_aptx_dec_set_license(adev);
 }
 
-void audio_extn_set_parameters(struct audio_device *adev,
-                               struct str_parms *parms)
-{
-   bool a2dp_reconfig = false;
-
-   audio_extn_set_aanc_noise_level(adev, parms);
-   audio_extn_set_anc_parameters(adev, parms);
-   audio_extn_set_fluence_parameters(adev, parms);
-   audio_extn_set_afe_proxy_parameters(adev, parms);
-   audio_extn_fm_set_parameters(adev, parms);
-   audio_extn_sound_trigger_set_parameters(adev, parms);
-   audio_extn_listen_set_parameters(adev, parms);
-   audio_extn_ssr_set_parameters(adev, parms);
-   audio_extn_hfp_set_parameters(adev, parms);
-   audio_extn_dts_eagle_set_parameters(adev, parms);
-   audio_extn_a2dp_set_parameters(parms, &a2dp_reconfig);
-   audio_extn_ddp_set_parameters(adev, parms);
-   audio_extn_ds2_set_parameters(adev, parms);
-   audio_extn_customstereo_set_parameters(adev, parms);
-   audio_extn_hpx_set_parameters(adev, parms);
-   audio_extn_pm_set_parameters(parms);
-   audio_extn_source_track_set_parameters(adev, parms);
-   audio_extn_fbsp_set_parameters(parms);
-   audio_extn_keep_alive_set_parameters(adev, parms);
-   audio_extn_passthru_set_parameters(adev, parms);
-   audio_extn_ext_disp_set_parameters(adev, parms);
-   audio_extn_qaf_set_parameters(adev, parms);
-   if (adev->offload_effects_set_parameters != NULL)
-       adev->offload_effects_set_parameters(parms);
-   audio_extn_set_aptx_dec_bt_addr(adev, parms);
-   audio_extn_ffv_set_parameters(adev, parms);
-   audio_extn_ext_hw_plugin_set_parameters(adev->ext_hw_plugin, parms);
-}
-
-void audio_extn_get_parameters(const struct audio_device *adev,
-                              struct str_parms *query,
-                              struct str_parms *reply)
-{
-    char *kv_pairs = NULL;
-    audio_extn_get_afe_proxy_parameters(adev, query, reply);
-    audio_extn_get_fluence_parameters(adev, query, reply);
-    audio_extn_ssr_get_parameters(adev, query, reply);
-    get_active_offload_usecases(adev, query, reply);
-    audio_extn_dts_eagle_get_parameters(adev, query, reply);
-    audio_extn_hpx_get_parameters(query, reply);
-    audio_extn_source_track_get_parameters(adev, query, reply);
-    audio_extn_fbsp_get_parameters(query, reply);
-    audio_extn_sound_trigger_get_parameters(adev, query, reply);
-    audio_extn_fm_get_parameters(query, reply);
-    if (adev->offload_effects_get_parameters != NULL)
-        adev->offload_effects_get_parameters(query, reply);
-    audio_extn_ext_hw_plugin_get_parameters(adev->ext_hw_plugin, query, reply);
-
-    kv_pairs = str_parms_to_str(reply);
-    ALOGD_IF(kv_pairs != NULL, "%s: returns %s", __func__, kv_pairs);
-    free(kv_pairs);
-}
-
-#ifndef COMPRESS_METADATA_NEEDED
-#define audio_extn_parse_compress_metadata(out, parms) (0)
-#else
 int audio_extn_parse_compress_metadata(struct stream_out *out,
                                        struct str_parms *parms)
 {
     int ret = 0;
     char value[32];
 
+    if (!if_compress_meta_data_feature_enabled()) {
+        return ret;
+    }
+
     if (out->format == AUDIO_FORMAT_FLAC) {
         ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MIN_BLK_SIZE, value, sizeof(value));
         if (ret >= 0) {
@@ -1280,7 +2589,6 @@
 
     return ret;
 }
-#endif
 
 #ifdef AUXPCM_BT_ENABLED
 int32_t audio_extn_read_xml(struct audio_device *adev, uint32_t mixer_card,
@@ -1310,85 +2618,6 @@
 }
 #endif /* AUXPCM_BT_ENABLED */
 
-#ifdef KPI_OPTIMIZE_ENABLED
-typedef int (*perf_lock_acquire_t)(int, int, int*, int);
-typedef int (*perf_lock_release_t)(int);
-
-static void *qcopt_handle;
-static perf_lock_acquire_t perf_lock_acq;
-static perf_lock_release_t perf_lock_rel;
-
-char opt_lib_path[512] = {0};
-
-int audio_extn_perf_lock_init(void)
-{
-    int ret = 0;
-    if (qcopt_handle == NULL) {
-        if (property_get("ro.vendor.extension_library",
-                         opt_lib_path, NULL) <= 0) {
-            ALOGE("%s: Failed getting perf property \n", __func__);
-            ret = -EINVAL;
-            goto err;
-        }
-        if ((qcopt_handle = dlopen(opt_lib_path, RTLD_NOW)) == NULL) {
-            ALOGE("%s: Failed to open perf handle \n", __func__);
-            ret = -EINVAL;
-            goto err;
-        } else {
-            perf_lock_acq = (perf_lock_acquire_t)dlsym(qcopt_handle,
-                                                       "perf_lock_acq");
-            if (perf_lock_acq == NULL) {
-                ALOGE("%s: Perf lock Acquire NULL \n", __func__);
-                dlclose(qcopt_handle);
-                ret = -EINVAL;
-                goto err;
-            }
-            perf_lock_rel = (perf_lock_release_t)dlsym(qcopt_handle,
-                                                       "perf_lock_rel");
-            if (perf_lock_rel == NULL) {
-                ALOGE("%s: Perf lock Release NULL \n", __func__);
-                dlclose(qcopt_handle);
-                ret = -EINVAL;
-                goto err;
-            }
-            ALOGE("%s: Perf lock handles Success \n", __func__);
-        }
-    }
-err:
-    return ret;
-}
-
-void audio_extn_perf_lock_acquire(int *handle, int duration,
-                                 int *perf_lock_opts, int size)
-{
-
-    if (!perf_lock_opts || !size || !perf_lock_acq || !handle) {
-        ALOGE("%s: Incorrect params, Failed to acquire perf lock, err ",
-              __func__);
-        return;
-    }
-    /*
-     * Acquire performance lock for 1 sec during device path bringup.
-     * Lock will be released either after 1 sec or when perf_lock_release
-     * function is executed.
-     */
-    *handle = perf_lock_acq(*handle, duration, perf_lock_opts, size);
-    if (*handle <= 0)
-        ALOGE("%s: Failed to acquire perf lock, err: %d\n",
-              __func__, *handle);
-}
-
-void audio_extn_perf_lock_release(int *handle)
-{
-    if (perf_lock_rel && handle && (*handle > 0)) {
-        perf_lock_rel(*handle);
-        *handle = 0;
-    } else {
-        ALOGE("%s: Perf lock release error \n", __func__);
-    }
-}
-#endif /* KPI_OPTIMIZE_ENABLED */
-
 static int audio_extn_set_multichannel_mask(struct audio_device *adev,
                                             struct stream_in *in,
                                             struct audio_config *config,
@@ -1697,22 +2926,904 @@
     return 0;
 }
 
-// TODO: remove after ext spkr file added
-void *audio_extn_extspk_init(struct audio_device *adev __unused)
+//START: FM_POWER_OPT_FEATURE ================================================================
+void fm_feature_init(bool is_feature_enabled)
 {
-    return NULL;
+    audio_extn_fm_power_opt_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature FM_POWER_OPT is %s----", __func__, is_feature_enabled? "ENABLED": "NOT ENABLED");
 }
-void audio_extn_extspk_deinit(void *extn __unused)
+
+
+void audio_extn_fm_get_parameters(struct str_parms *query, struct str_parms *reply)
 {
+    if(audio_extn_fm_power_opt_enabled)
+        fm_get_parameters(query, reply);
 }
-void audio_extn_extspk_update(void* extn __unused)
+
+void audio_extn_fm_set_parameters(struct audio_device *adev,
+                                  struct str_parms *parms)
 {
+    if(audio_extn_fm_power_opt_enabled)
+        fm_set_parameters(adev, parms);
 }
-void audio_extn_extspk_set_mode(void* extn __unused,
-                                audio_mode_t mode __unused)
+//END: FM_POWER_OPT_FEATURE ================================================================
+
+//START: HDMI_EDID =========================================================================
+#ifdef __LP64__
+#define HDMI_EDID_LIB_PATH  "/vendor/lib64/libhdmiedid.so"
+#else
+#define HDMI_EDID_LIB_PATH  "/vendor/lib/libhdmiedid.so"
+#endif
+
+static void *hdmi_edid_lib_handle = NULL;
+
+typedef bool (*hdmi_edid_is_supported_sr_t)(edid_audio_info*, int);
+static hdmi_edid_is_supported_sr_t hdmi_edid_is_supported_sr;
+
+typedef bool (*hdmi_edid_is_supported_bps_t)(edid_audio_info*, int);
+static hdmi_edid_is_supported_bps_t hdmi_edid_is_supported_bps;
+
+typedef int (*hdmi_edid_get_highest_supported_sr_t)(edid_audio_info*);
+static hdmi_edid_get_highest_supported_sr_t hdmi_edid_get_highest_supported_sr;
+
+typedef bool (*hdmi_edid_get_sink_caps_t)(edid_audio_info*, char*);
+static hdmi_edid_get_sink_caps_t hdmi_edid_get_sink_caps;
+
+void hdmi_edid_feature_init(bool is_feature_enabled)
 {
+    ALOGD("%s: HDMI_EDID feature %s", __func__, is_feature_enabled?"Enabled":"NOT Enabled");
+    if (is_feature_enabled) {
+        //dlopen lib
+        hdmi_edid_lib_handle = dlopen(HDMI_EDID_LIB_PATH, RTLD_NOW);
+        if (hdmi_edid_lib_handle == NULL) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+        //map each function
+        //on any faliure to map any function, disble feature
+        if (((hdmi_edid_is_supported_sr =
+             (hdmi_edid_is_supported_sr_t)dlsym(hdmi_edid_lib_handle, 
+                                                "edid_is_supported_sr")) == NULL) ||
+            ((hdmi_edid_is_supported_bps =
+             (hdmi_edid_is_supported_bps_t)dlsym(hdmi_edid_lib_handle,
+                                                "edid_is_supported_bps")) == NULL) ||
+            ((hdmi_edid_get_highest_supported_sr =
+             (hdmi_edid_get_highest_supported_sr_t)dlsym(hdmi_edid_lib_handle, 
+                                                "edid_get_highest_supported_sr")) == NULL) ||
+            ((hdmi_edid_get_sink_caps =
+             (hdmi_edid_get_sink_caps_t)dlsym(hdmi_edid_lib_handle, 
+                                                "edid_get_sink_caps")) == NULL)) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+
+        ALOGD("%s:: ---- Feature HDMI_EDID is Enabled ----", __func__);
+        return;
+    }
+
+feature_disabled:
+    if (hdmi_edid_lib_handle) {
+        dlclose(hdmi_edid_lib_handle);
+        hdmi_edid_lib_handle = NULL;
+    }
+
+    hdmi_edid_is_supported_sr = NULL;
+    hdmi_edid_is_supported_bps = NULL;
+    hdmi_edid_get_highest_supported_sr = NULL;
+    hdmi_edid_get_sink_caps = NULL;
+    ALOGW(":: %s: ---- Feature HDMI_EDID is disabled ----", __func__);
+    return;
 }
-void audio_extn_extspk_set_voice_vol(void* extn __unused,
-                                     float vol __unused)
+
+bool audio_extn_edid_is_supported_sr(edid_audio_info* info, int sr)
 {
+    bool ret = false;
+
+    if(hdmi_edid_is_supported_sr != NULL)
+        ret = hdmi_edid_is_supported_sr(info, sr);
+    return ret;
+}
+
+bool audio_extn_edid_is_supported_bps(edid_audio_info* info, int bps)
+{
+    bool ret = false;
+
+    if(hdmi_edid_is_supported_bps != NULL)
+        ret = hdmi_edid_is_supported_bps(info, bps);
+    return ret;
+}
+int audio_extn_edid_get_highest_supported_sr(edid_audio_info* info)
+{
+    int ret = -1;
+
+    if(hdmi_edid_get_highest_supported_sr != NULL)
+        ret = hdmi_edid_get_highest_supported_sr(info);
+    return ret;
+}
+
+bool audio_extn_edid_get_sink_caps(edid_audio_info* info, char *edid_data)
+{
+    bool ret = false;
+
+    if(hdmi_edid_get_sink_caps != NULL)
+        ret = hdmi_edid_get_sink_caps(info, edid_data);
+    return ret;
+}
+
+//END: HDMI_EDID =========================================================================
+
+
+//START: KEEP_ALIVE =========================================================================
+
+void keep_alive_feature_init(bool is_feature_enabled)
+{
+    audio_extn_keep_alive_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature KEEP_ALIVE is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+void audio_extn_keep_alive_init(struct audio_device *adev)
+{
+    if(audio_extn_keep_alive_enabled)
+        keep_alive_init(adev);
+}
+
+void audio_extn_keep_alive_deinit()
+{
+    if(audio_extn_keep_alive_enabled)
+        keep_alive_deinit();
+}
+
+void audio_extn_keep_alive_start(ka_mode_t ka_mode)
+{
+    if(audio_extn_keep_alive_enabled)
+        keep_alive_start(ka_mode);
+}
+
+void audio_extn_keep_alive_stop(ka_mode_t ka_mode)
+{
+    if(audio_extn_keep_alive_enabled)
+        keep_alive_stop(ka_mode);
+}
+
+bool audio_extn_keep_alive_is_active()
+{
+    bool ret = false;
+    return ret;
+}
+
+int audio_extn_keep_alive_set_parameters(struct audio_device *adev,
+                                         struct str_parms *parms)
+{
+    int ret = -1;
+    if(audio_extn_keep_alive_enabled)
+        return keep_alive_set_parameters(adev, parms);
+    return ret;
+}
+//END: KEEP_ALIVE =========================================================================
+
+//START: HIFI_AUDIO =========================================================================
+void hifi_audio_feature_init(bool is_feature_enabled)
+{
+    audio_extn_hifi_audio_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature HIFI_AUDIO is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool audio_extn_is_hifi_audio_enabled(void)
+{
+    bool ret = false;
+    if(audio_extn_hifi_audio_enabled)
+    {
+        ALOGV("%s: status: %d", __func__, aextnmod.hifi_audio_enabled);
+        return (aextnmod.hifi_audio_enabled ? true: false);
+    }
+    return ret;
+}
+
+bool audio_extn_is_hifi_audio_supported(void)
+{
+    bool ret = false;
+
+    if(audio_extn_hifi_audio_enabled)
+    {
+        /*
+         * for internal codec, check for hifiaudio property to enable hifi audio
+         */
+        if (property_get_bool("persist.vendor.audio.hifi.int_codec", false))
+        {
+            ALOGD("%s: hifi audio supported on internal codec", __func__);
+            aextnmod.hifi_audio_enabled = 1;
+        }
+        return (aextnmod.hifi_audio_enabled ? true: false);
+    }
+    return ret;
+}
+
+//END: HIFI_AUDIO =========================================================================
+
+//START: RAS =============================================================================
+void ras_feature_init(bool is_feature_enabled)
+{
+    audio_extn_ras_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature RAS_FEATURE is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool audio_extn_is_ras_enabled(void)
+{
+    bool ret = false;
+
+    if(audio_extn_ras_feature_enabled)
+    {
+        ALOGD("%s: status: %d", __func__, aextnmod.ras_enabled);
+        return (aextnmod.ras_enabled ? true: false);
+    }
+    return ret;
+}
+
+bool audio_extn_can_use_ras(void)
+{
+    bool ret = false;
+
+    if(audio_extn_ras_feature_enabled)
+    {
+        if (property_get_bool("persist.vendor.audio.ras.enabled", false))
+            aextnmod.ras_enabled = 1;
+        ALOGD("%s: ras.enabled property is set to %d", __func__, aextnmod.ras_enabled);
+        return (aextnmod.ras_enabled ? true: false);
+    }
+    return ret;
+}
+
+//END: RAS ===============================================================================
+
+//START: KPI_OPTIMIZE =============================================================================
+void kpi_optimize_feature_init(bool is_feature_enabled)
+{
+    audio_extn_kpi_optimize_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature KPI_OPTIMIZE is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+typedef int (*perf_lock_acquire_t)(int, int, int*, int);
+typedef int (*perf_lock_release_t)(int);
+
+static void *qcopt_handle;
+static perf_lock_acquire_t perf_lock_acq;
+static perf_lock_release_t perf_lock_rel;
+
+char opt_lib_path[512] = {0};
+
+int audio_extn_perf_lock_init(void)
+{
+    int ret = 0;
+
+    //if feature is disabled, exit immediately
+    if(!audio_extn_kpi_optimize_feature_enabled)
+        goto err;
+
+    if (qcopt_handle == NULL) {
+        if (property_get("ro.vendor.extension_library",
+                         opt_lib_path, NULL) <= 0) {
+            ALOGE("%s: Failed getting perf property \n", __func__);
+            ret = -EINVAL;
+            goto err;
+        }
+        if ((qcopt_handle = dlopen(opt_lib_path, RTLD_NOW)) == NULL) {
+            ALOGE("%s: Failed to open perf handle \n", __func__);
+            ret = -EINVAL;
+            goto err;
+        } else {
+            perf_lock_acq = (perf_lock_acquire_t)dlsym(qcopt_handle,
+                                                       "perf_lock_acq");
+            if (perf_lock_acq == NULL) {
+                ALOGE("%s: Perf lock Acquire NULL \n", __func__);
+                dlclose(qcopt_handle);
+                ret = -EINVAL;
+                goto err;
+            }
+            perf_lock_rel = (perf_lock_release_t)dlsym(qcopt_handle,
+                                                       "perf_lock_rel");
+            if (perf_lock_rel == NULL) {
+                ALOGE("%s: Perf lock Release NULL \n", __func__);
+                dlclose(qcopt_handle);
+                ret = -EINVAL;
+                goto err;
+            }
+            ALOGE("%s: Perf lock handles Success \n", __func__);
+        }
+    }
+err:
+    return ret;
+}
+
+void audio_extn_perf_lock_acquire(int *handle, int duration,
+                                 int *perf_lock_opts, int size)
+{
+    if (audio_extn_kpi_optimize_feature_enabled)
+    {
+        if (!perf_lock_opts || !size || !perf_lock_acq || !handle) {
+            ALOGE("%s: Incorrect params, Failed to acquire perf lock, err ",
+                  __func__);
+            return;
+        }
+        /*
+         * Acquire performance lock for 1 sec during device path bringup.
+         * Lock will be released either after 1 sec or when perf_lock_release
+         * function is executed.
+         */
+        *handle = perf_lock_acq(*handle, duration, perf_lock_opts, size);
+        if (*handle <= 0)
+            ALOGE("%s: Failed to acquire perf lock, err: %d\n",
+                  __func__, *handle);
+    }
+}
+
+void audio_extn_perf_lock_release(int *handle)
+{
+    if (audio_extn_kpi_optimize_feature_enabled) {
+         if (perf_lock_rel && handle && (*handle > 0)) {
+            perf_lock_rel(*handle);
+            *handle = 0;
+        } else
+            ALOGE("%s: Perf lock release error \n", __func__);
+    }
+}
+
+//END: KPI_OPTIMIZE =============================================================================
+
+//START: DISPLAY_PORT =============================================================================
+void display_port_feature_init(bool is_feature_enabled)
+{
+    audio_extn_display_port_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature DISPLAY_PORT is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool audio_extn_is_display_port_enabled()
+{
+    return audio_extn_display_port_feature_enabled;
+}
+//END: DISPLAY_PORT ===============================================================================
+//START: FLUENCE =============================================================================
+void fluence_feature_init(bool is_feature_enabled)
+{
+    audio_extn_fluence_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature FLUENCE is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool audio_extn_is_fluence_enabled()
+{
+    return audio_extn_fluence_feature_enabled;
+}
+
+void audio_extn_set_fluence_parameters(struct audio_device *adev,
+                                            struct str_parms *parms)
+{
+    int ret = 0, err;
+    char value[32];
+    struct listnode *node;
+    struct audio_usecase *usecase;
+
+    if (audio_extn_is_fluence_enabled()) {
+        err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE,
+                                 value, sizeof(value));
+        ALOGV_IF(err >= 0, "%s: Set Fluence Type to %s", __func__, value);
+        if (err >= 0) {
+            ret = platform_set_fluence_type(adev->platform, value);
+            if (ret != 0) {
+                ALOGE("platform_set_fluence_type returned error: %d", ret);
+            } else {
+                /*
+                 *If the fluence is manually set/reset, devices
+                 *need to get updated for all the usecases
+                 *i.e. audio and voice.
+                 */
+                 list_for_each(node, &adev->usecase_list) {
+                     usecase = node_to_item(node, struct audio_usecase, list);
+                     select_devices(adev, usecase->id);
+                 }
+            }
+        }
+
+    }
+}
+
+int audio_extn_get_fluence_parameters(const struct audio_device *adev,
+                       struct str_parms *query, struct str_parms *reply)
+{
+    int ret = -1, err;
+    char value[256] = {0};
+
+    if (audio_extn_is_fluence_enabled()) {
+        err = str_parms_get_str(query, AUDIO_PARAMETER_KEY_FLUENCE, value,
+                                                          sizeof(value));
+        if (err >= 0) {
+            ret = platform_get_fluence_type(adev->platform, value, sizeof(value));
+            if (ret >= 0) {
+                ALOGV("%s: Fluence Type is %s", __func__, value);
+                str_parms_add_str(reply, AUDIO_PARAMETER_KEY_FLUENCE, value);
+            } else
+                goto done;
+        }
+    }
+done:
+    return ret;
+}
+//END: FLUENCE ===============================================================================
+//START: CUSTOM_STEREO =============================================================================
+void custom_stereo_feature_init(bool is_feature_enabled)
+{
+    audio_extn_custom_stereo_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature CUSTOM_STEREO is %s ----", __func__, is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool audio_extn_is_custom_stereo_enabled()
+{
+    return audio_extn_custom_stereo_feature_enabled;
+}
+
+void audio_extn_customstereo_set_parameters(struct audio_device *adev,
+                                           struct str_parms *parms)
+{
+    int ret = 0;
+    char value[32]={0};
+    bool custom_stereo_state = false;
+    const char *mixer_ctl_name = "Set Custom Stereo OnOff";
+    struct mixer_ctl *ctl;
+
+    ALOGV("%s", __func__);
+
+    if (audio_extn_custom_stereo_feature_enabled) {
+        ret = str_parms_get_str(parms, AUDIO_PARAMETER_CUSTOM_STEREO, value,
+                            sizeof(value));
+        if (ret >= 0) {
+            if (!strncmp("true", value, sizeof("true")) || atoi(value))
+                custom_stereo_state = true;
+
+            if (custom_stereo_state == aextnmod.custom_stereo_enabled)
+                return;
+
+            ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+            if (!ctl) {
+                ALOGE("%s: Could not get ctl for mixer cmd - %s",
+                      __func__, mixer_ctl_name);
+                return;
+            }
+            if (mixer_ctl_set_value(ctl, 0, custom_stereo_state) < 0) {
+                ALOGE("%s: Could not set custom stereo state %d",
+                      __func__, custom_stereo_state);
+                return;
+            }
+            aextnmod.custom_stereo_enabled = custom_stereo_state;
+            ALOGV("%s: Setting custom stereo state success", __func__);
+        }
+    }
+}
+
+void audio_extn_send_dual_mono_mixing_coefficients(struct stream_out *out)
+{
+    struct audio_device *adev = out->dev;
+    struct mixer_ctl *ctl;
+    char mixer_ctl_name[128];
+    int cust_ch_mixer_cfg[128], len = 0;
+    int ip_channel_cnt = audio_channel_count_from_out_mask(out->channel_mask);
+    int pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
+    int op_channel_cnt= 2;
+    int i, j, err;
+
+    ALOGV("%s", __func__);
+
+    if (audio_extn_custom_stereo_feature_enabled) {
+        if (!out->started) {
+        out->set_dual_mono = true;
+        goto exit;
+        }
+
+        ALOGD("%s: i/p channel count %d, o/p channel count %d, pcm id %d", __func__,
+               ip_channel_cnt, op_channel_cnt, pcm_device_id);
+
+        snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
+                 "Audio Stream %d Channel Mix Cfg", pcm_device_id);
+        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+        if (!ctl) {
+            ALOGE("%s: ERROR. Could not get ctl for mixer cmd - %s",
+            __func__, mixer_ctl_name);
+            goto exit;
+        }
+
+        /* Output channel count corresponds to backend configuration channels.
+         * Input channel count corresponds to ASM session channels.
+         * Set params is called with channels that need to be selected from
+         * input to generate output.
+         * ex: "8,2" to downmix from 8 to 2 i.e. to downmix from 8 to 2,
+         *
+         * This mixer control takes values in the following sequence:
+         * - input channel count(m)
+         * - output channel count(n)
+         * - weight coeff for [out ch#1, in ch#1]
+         * ....
+         * - weight coeff for [out ch#1, in ch#m]
+         *
+         * - weight coeff for [out ch#2, in ch#1]
+         * ....
+         * - weight coeff for [out ch#2, in ch#m]
+         *
+         * - weight coeff for [out ch#n, in ch#1]
+         * ....
+         * - weight coeff for [out ch#n, in ch#m]
+         *
+         * To get dualmono ouptu weightage coeff is calculated as Unity gain
+         * divided by number of input channels.
+         */
+        cust_ch_mixer_cfg[len++] = ip_channel_cnt;
+        cust_ch_mixer_cfg[len++] = op_channel_cnt;
+        for (i = 0; i < op_channel_cnt; i++) {
+             for (j = 0; j < ip_channel_cnt; j++) {
+                  cust_ch_mixer_cfg[len++] = Q14_GAIN_UNITY/ip_channel_cnt;
+             }
+        }
+
+        err = mixer_ctl_set_array(ctl, cust_ch_mixer_cfg, len);
+        if (err)
+            ALOGE("%s: ERROR. Mixer ctl set failed", __func__);
+
+    }
+exit:
+    return;
+}
+//END: CUSTOM_STEREO =============================================================================
+// START: A2DP_OFFLOAD ===================================================================
+#ifdef __LP64__
+#define A2DP_OFFLOAD_LIB_PATH "/vendor/lib64/liba2dpoffload.so"
+#else
+#define A2DP_OFFLOAD_LIB_PATH "/vendor/lib/liba2dpoffload.so"
+#endif
+
+static void *a2dp_lib_handle = NULL;
+
+typedef void (*a2dp_init_t)(void *, a2dp_offload_init_config_t *);
+static a2dp_init_t a2dp_init;
+
+typedef int (*a2dp_start_playback_t)();
+static a2dp_start_playback_t a2dp_start_playback;
+
+typedef int (*a2dp_stop_playback_t)();
+static a2dp_stop_playback_t a2dp_stop_playback;
+
+typedef int (*a2dp_set_parameters_t)(struct str_parms *,
+                                     bool *);
+static a2dp_set_parameters_t a2dp_set_parameters;
+
+typedef int (*a2dp_get_parameters_t)(struct str_parms *,
+                                   struct str_parms *);
+static a2dp_get_parameters_t a2dp_get_parameters;
+
+typedef bool (*a2dp_is_force_device_switch_t)();
+static a2dp_is_force_device_switch_t a2dp_is_force_device_switch;
+
+typedef void (*a2dp_set_handoff_mode_t)(bool);
+static a2dp_set_handoff_mode_t a2dp_set_handoff_mode;
+
+typedef void (*a2dp_get_enc_sample_rate_t)(int *);
+static a2dp_get_enc_sample_rate_t a2dp_get_enc_sample_rate;
+
+typedef void (*a2dp_get_dec_sample_rate_t)(int *);
+static a2dp_get_dec_sample_rate_t a2dp_get_dec_sample_rate;
+
+typedef uint32_t (*a2dp_get_encoder_latency_t)();
+static a2dp_get_encoder_latency_t a2dp_get_encoder_latency;
+
+typedef bool (*a2dp_sink_is_ready_t)();
+static a2dp_sink_is_ready_t a2dp_sink_is_ready;
+
+typedef bool (*a2dp_source_is_ready_t)();
+static a2dp_source_is_ready_t a2dp_source_is_ready;
+
+typedef bool (*a2dp_source_is_suspended_t)();
+static a2dp_source_is_suspended_t a2dp_source_is_suspended;
+
+typedef int (*a2dp_start_capture_t)();
+static a2dp_start_capture_t a2dp_start_capture;
+
+typedef int (*a2dp_stop_capture_t)();
+static a2dp_stop_capture_t a2dp_stop_capture;
+
+int a2dp_offload_feature_init(bool is_feature_enabled)
+{
+    ALOGD("%s: Called with feature %s", __func__,
+                  is_feature_enabled ? "Enabled" : "NOT Enabled");
+    if (is_feature_enabled) {
+        // dlopen lib
+        a2dp_lib_handle = dlopen(A2DP_OFFLOAD_LIB_PATH, RTLD_NOW);
+
+        if (!a2dp_lib_handle) {
+            ALOGE("%s: dlopen failed", __func__);
+            goto feature_disabled;
+        }
+
+        if (!(a2dp_init = (a2dp_init_t)dlsym(a2dp_lib_handle, "a2dp_init")) ||
+            !(a2dp_start_playback =
+                 (a2dp_start_playback_t)dlsym(a2dp_lib_handle, "a2dp_start_playback")) ||
+            !(a2dp_stop_playback =
+                 (a2dp_stop_playback_t)dlsym(a2dp_lib_handle, "a2dp_stop_playback")) ||
+            !(a2dp_set_parameters =
+                 (a2dp_set_parameters_t)dlsym(a2dp_lib_handle, "a2dp_set_parameters")) ||
+            !(a2dp_get_parameters =
+                 (a2dp_get_parameters_t)dlsym(a2dp_lib_handle, "a2dp_get_parameters")) ||
+            !(a2dp_is_force_device_switch =
+                 (a2dp_is_force_device_switch_t)dlsym(
+                                    a2dp_lib_handle, "a2dp_is_force_device_switch")) ||
+            !(a2dp_set_handoff_mode =
+                 (a2dp_set_handoff_mode_t)dlsym(
+                                          a2dp_lib_handle, "a2dp_set_handoff_mode")) ||
+            !(a2dp_get_enc_sample_rate =
+                 (a2dp_get_enc_sample_rate_t)dlsym(
+                                       a2dp_lib_handle, "a2dp_get_enc_sample_rate")) ||
+            !(a2dp_get_dec_sample_rate =
+                 (a2dp_get_dec_sample_rate_t)dlsym(
+                                       a2dp_lib_handle, "a2dp_get_dec_sample_rate")) ||
+            !(a2dp_get_encoder_latency =
+                 (a2dp_get_encoder_latency_t)dlsym(
+                                       a2dp_lib_handle, "a2dp_get_encoder_latency")) ||
+            !(a2dp_sink_is_ready =
+                 (a2dp_sink_is_ready_t)dlsym(a2dp_lib_handle, "a2dp_sink_is_ready")) ||
+            !(a2dp_source_is_ready =
+                 (a2dp_source_is_ready_t)dlsym(a2dp_lib_handle, "a2dp_source_is_ready")) ||
+            !(a2dp_source_is_suspended =
+                 (a2dp_source_is_suspended_t)dlsym(
+                                       a2dp_lib_handle, "a2dp_source_is_suspended")) ||
+            !(a2dp_start_capture =
+                 (a2dp_start_capture_t)dlsym(a2dp_lib_handle, "a2dp_start_capture")) ||
+            !(a2dp_stop_capture =
+                 (a2dp_stop_capture_t)dlsym(a2dp_lib_handle, "a2dp_stop_capture"))) {
+            ALOGE("%s: dlsym failed", __func__);
+            goto feature_disabled;
+        }
+        ALOGD("%s:: ---- Feature A2DP_OFFLOAD is Enabled ----", __func__);
+        return 0;
+    }
+
+feature_disabled:
+    if (a2dp_lib_handle) {
+        dlclose(a2dp_lib_handle);
+        a2dp_lib_handle = NULL;
+    }
+
+    a2dp_init = NULL;
+    a2dp_start_playback= NULL;
+    a2dp_stop_playback = NULL;
+    a2dp_set_parameters = NULL;
+    a2dp_get_parameters = NULL;
+    a2dp_is_force_device_switch = NULL;
+    a2dp_set_handoff_mode = NULL;
+    a2dp_get_enc_sample_rate = NULL;
+    a2dp_get_dec_sample_rate = NULL;
+    a2dp_get_encoder_latency = NULL;
+    a2dp_sink_is_ready = NULL;
+    a2dp_source_is_ready = NULL;
+    a2dp_source_is_suspended = NULL;
+    a2dp_start_capture = NULL;
+    a2dp_stop_capture = NULL;
+
+    ALOGW(":: %s: ---- Feature A2DP_OFFLOAD is disabled ----", __func__);
+    return -ENOSYS;
+}
+
+void audio_extn_a2dp_init(void *adev)
+{
+    if (a2dp_init) {
+        a2dp_offload_init_config_t *a2dp_init_config = NULL;
+        a2dp_init_config->fp_platform_get_pcm_device_id = platform_get_pcm_device_id;
+        a2dp_init_config->fp_check_a2dp_restore = check_a2dp_restore;
+
+        a2dp_init(adev, a2dp_init_config);
+    }
+}
+
+int audio_extn_a2dp_start_playback()
+{
+    return (a2dp_start_playback ? a2dp_start_playback() : 0);
+}
+
+int audio_extn_a2dp_stop_playback()
+{
+    return (a2dp_stop_playback ? a2dp_stop_playback() : 0);
+}
+
+int audio_extn_a2dp_set_parameters(struct str_parms *parms,
+                                   bool *reconfig)
+{
+    return (a2dp_set_parameters ?
+                    a2dp_set_parameters(parms, reconfig) : 0);
+}
+
+int audio_extn_a2dp_get_parameters(struct str_parms *query,
+                                   struct str_parms *reply)
+{
+    return (a2dp_get_parameters ?
+                    a2dp_get_parameters(query, reply) : 0);
+}
+
+bool audio_extn_a2dp_is_force_device_switch()
+{
+    return (a2dp_is_force_device_switch ?
+                a2dp_is_force_device_switch() : false);
+}
+
+void audio_extn_a2dp_set_handoff_mode(bool is_on)
+{
+    if (a2dp_set_handoff_mode)
+        a2dp_set_handoff_mode(is_on);
+}
+
+void audio_extn_a2dp_get_enc_sample_rate(int *sample_rate)
+{
+    if (a2dp_get_enc_sample_rate)
+        a2dp_get_enc_sample_rate(sample_rate);
+}
+
+void audio_extn_a2dp_get_dec_sample_rate(int *sample_rate)
+{
+    if (a2dp_get_dec_sample_rate)
+        a2dp_get_dec_sample_rate(sample_rate);
+}
+
+uint32_t audio_extn_a2dp_get_encoder_latency()
+{
+    return (a2dp_get_encoder_latency ?
+                a2dp_get_encoder_latency() : 0);
+}
+
+bool audio_extn_a2dp_sink_is_ready()
+{
+    return (a2dp_sink_is_ready ?
+                a2dp_sink_is_ready() : false);
+}
+
+bool audio_extn_a2dp_source_is_ready()
+{
+    return (a2dp_source_is_ready ?
+                a2dp_source_is_ready() : false);
+}
+
+bool audio_extn_a2dp_source_is_suspended()
+{
+    return (a2dp_source_is_suspended ?
+                a2dp_source_is_suspended() : false);
+}
+
+int audio_extn_a2dp_start_capture()
+{
+    return (a2dp_start_capture ? a2dp_start_capture() : 0);
+}
+
+int audio_extn_a2dp_stop_capture()
+{
+    return (a2dp_stop_capture ? a2dp_stop_capture() : 0);
+}
+
+// END: A2DP_OFFLOAD =====================================================================
+void audio_extn_feature_init()
+{
+    for(int index = 0; index < VOICE_START; index++)
+    {
+        bool enable = audio_feature_manager_is_feature_enabled(index);
+        switch (index) {
+            case SND_MONITOR:
+                snd_mon_feature_init(enable);
+                break;
+            case COMPRESS_CAPTURE:
+                compr_cap_feature_init(enable);
+                break;
+            case DSM_FEEDBACK:
+                dsm_feedback_feature_init(enable);
+                break;
+            case SSREC:
+                ssrec_feature_init(enable);
+                break;
+            case SOURCE_TRACK:
+                src_trkn_feature_init(enable);
+            case HDMI_EDID:
+                hdmi_edid_feature_init(enable);
+                break;
+            case KEEP_ALIVE:
+                keep_alive_feature_init(enable);
+                break;
+            case HIFI_AUDIO:
+                hifi_audio_feature_init(enable);
+                break;
+            case RECEIVER_AIDED_STEREO:
+                ras_feature_init(enable);
+                break;
+            case KPI_OPTIMIZE:
+                kpi_optimize_feature_init(enable);
+            case USB_OFFLOAD:
+                usb_offload_feature_init(enable);
+                break;
+            case USB_OFFLOAD_BURST_MODE:
+                usb_offload_burst_mode_feature_init(enable);
+                break;
+            case USB_OFFLOAD_SIDETONE_VOLM:
+                usb_offload_sidetone_volume_feature_init(enable);
+                break;
+            case A2DP_OFFLOAD:
+                a2dp_offload_feature_init(enable);
+                break;
+            case COMPRESS_METADATA_NEEDED:
+                compress_meta_data_feature_init(enable);
+                break;
+            case VBAT:
+                vbat_feature_init(enable);
+                break;
+            case DISPLAY_PORT:
+                display_port_feature_init(enable);
+                break;
+            case FLUENCE:
+                fluence_feature_init(enable);
+                break;
+             case CUSTOM_STEREO:
+                custom_stereo_feature_init(enable);
+                break;
+            case ANC_HEADSET:
+                anc_headset_feature_init(enable);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+void audio_extn_set_parameters(struct audio_device *adev,
+                               struct str_parms *parms)
+{
+   bool a2dp_reconfig = false;
+
+   audio_extn_set_aanc_noise_level(adev, parms);
+   audio_extn_set_anc_parameters(adev, parms);
+   audio_extn_set_fluence_parameters(adev, parms);
+   audio_extn_set_afe_proxy_parameters(adev, parms);
+   audio_extn_fm_set_parameters(adev, parms);
+   audio_extn_sound_trigger_set_parameters(adev, parms);
+   audio_extn_listen_set_parameters(adev, parms);
+   audio_extn_ssr_set_parameters(adev, parms);
+   audio_extn_hfp_set_parameters(adev, parms);
+   audio_extn_dts_eagle_set_parameters(adev, parms);
+   audio_extn_a2dp_set_parameters(parms, &a2dp_reconfig);
+   audio_extn_ddp_set_parameters(adev, parms);
+   audio_extn_ds2_set_parameters(adev, parms);
+   audio_extn_customstereo_set_parameters(adev, parms);
+   audio_extn_hpx_set_parameters(adev, parms);
+   audio_extn_pm_set_parameters(parms);
+   audio_extn_source_track_set_parameters(adev, parms);
+   audio_extn_fbsp_set_parameters(parms);
+   audio_extn_keep_alive_set_parameters(adev, parms);
+   audio_extn_passthru_set_parameters(adev, parms);
+   audio_extn_ext_disp_set_parameters(adev, parms);
+   audio_extn_qaf_set_parameters(adev, parms);
+   if (adev->offload_effects_set_parameters != NULL)
+       adev->offload_effects_set_parameters(parms);
+   audio_extn_set_aptx_dec_bt_addr(adev, parms);
+   audio_extn_ffv_set_parameters(adev, parms);
+   audio_extn_ext_hw_plugin_set_parameters(adev->ext_hw_plugin, parms);
+}
+
+void audio_extn_get_parameters(const struct audio_device *adev,
+                              struct str_parms *query,
+                              struct str_parms *reply)
+{
+    char *kv_pairs = NULL;
+    audio_extn_get_afe_proxy_parameters(adev, query, reply);
+    audio_extn_get_fluence_parameters(adev, query, reply);
+    audio_extn_ssr_get_parameters(adev, query, reply);
+    get_active_offload_usecases(adev, query, reply);
+    audio_extn_dts_eagle_get_parameters(adev, query, reply);
+    audio_extn_hpx_get_parameters(query, reply);
+    audio_extn_source_track_get_parameters(adev, query, reply);
+    audio_extn_fbsp_get_parameters(query, reply);
+    audio_extn_sound_trigger_get_parameters(adev, query, reply);
+    audio_extn_fm_get_parameters(query, reply);
+    if (adev->offload_effects_get_parameters != NULL)
+        adev->offload_effects_get_parameters(query, reply);
+    audio_extn_ext_hw_plugin_get_parameters(adev->ext_hw_plugin, query, reply);
+
+    kv_pairs = str_parms_to_str(reply);
+    ALOGD_IF(kv_pairs != NULL, "%s: returns %s", __func__, kv_pairs);
+    free(kv_pairs);
 }
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index 92cd4a3..928bd2c 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -42,13 +42,12 @@
 #include "adsp_hdlr.h"
 #include "ip_hdlr_intf.h"
 #include "battery_listener.h"
+#include "platform_api.h"
+#include "edid.h"
+
 
 #define AUDIO_PARAMETER_DUAL_MONO  "dual_mono"
 
-#ifndef AFE_PROXY_ENABLED
-#define AUDIO_DEVICE_OUT_PROXY 0x40000
-#endif
-
 #ifndef AUDIO_DEVICE_IN_PROXY
 #define AUDIO_DEVICE_IN_PROXY (AUDIO_DEVICE_BIT_IN | 0x1000000)
 #endif
@@ -65,6 +64,8 @@
 #define AUDIO_DEVICE_OUT_FM_TX 0x8000000
 #endif
 
+#if 0
+// these formats should have been enabled by default now
 #ifndef FLAC_OFFLOAD_ENABLED
 #define AUDIO_FORMAT_FLAC 0x1B000000UL
 #endif
@@ -91,6 +92,7 @@
 #define AUDIO_FORMAT_AAC_ADTS_HE_V2  (AUDIO_FORMAT_AAC_ADTS |\
                                       AUDIO_FORMAT_AAC_SUB_HE_V2)
 #endif
+#endif
 
 #ifndef AUDIO_FORMAT_AAC_LATM
 #define AUDIO_FORMAT_AAC_LATM 0x80000000UL
@@ -130,12 +132,8 @@
 #define AUDIO_OUTPUT_FLAG_INTERACTIVE 0x4000000
 #endif
 
-#ifndef COMPRESS_METADATA_NEEDED
-#define audio_extn_parse_compress_metadata(out, parms) (0)
-#else
 int audio_extn_parse_compress_metadata(struct stream_out *out,
                                        struct str_parms *parms);
-#endif
 
 #ifdef AUDIO_EXTN_FORMATS_ENABLED
 #define AUDIO_OUTPUT_BIT_WIDTH ((config->offload_info.bit_width == 32) ? 24\
@@ -151,6 +149,107 @@
 #endif
 
 #define MAX_LENGTH_MIXER_CONTROL_IN_INT                  (128)
+#define HW_INFO_ARRAY_MAX_SIZE 32
+
+struct snd_card_split {
+    char device[HW_INFO_ARRAY_MAX_SIZE];
+    char snd_card[HW_INFO_ARRAY_MAX_SIZE];
+    char form_factor[HW_INFO_ARRAY_MAX_SIZE];
+};
+
+struct snd_card_split *audio_extn_get_snd_card_split();
+
+// -- function pointers needed for audio extn
+typedef void (*fp_platform_make_cal_cfg_t)(acdb_audio_cal_cfg_t *, int, int,
+                                         int, int, int, uint32_t, uint16_t,
+                                         uint32_t, bool);
+typedef int (*fp_platform_send_audio_cal_t)(void *, acdb_audio_cal_cfg_t *,
+                                            void *, int, bool);
+typedef int (*fp_platform_get_audio_cal_t)(void *, acdb_audio_cal_cfg_t *,
+                                           void *, int *, bool);
+typedef int (*fp_platform_store_audio_cal_t)(void *, acdb_audio_cal_cfg_t *,
+                                             void *, int);
+typedef int (*fp_platform_retrieve_audio_cal_t)(void *, acdb_audio_cal_cfg_t *,
+                                             void *, int *);
+
+typedef struct gef_init_config {
+    fp_platform_make_cal_cfg_t         fp_platform_make_cal_cfg;
+    fp_platform_send_audio_cal_t       fp_platform_send_audio_cal;
+    fp_platform_get_audio_cal_t        fp_platform_get_audio_cal;
+    fp_platform_store_audio_cal_t      fp_platform_store_audio_cal;
+    fp_platform_retrieve_audio_cal_t   fp_platform_retrieve_audio_cal;
+} gef_init_config_t;
+
+typedef int (*fp_read_line_from_file_t)(const char *, char *, size_t);
+typedef struct audio_usecase *(*fp_get_usecase_from_list_t)(const struct audio_device *,
+                                            audio_usecase_t);
+typedef int (*fp_enable_disable_snd_device_t)(struct audio_device *, snd_device_t);
+typedef int (*fp_enable_disable_audio_route_t)(struct audio_device *, struct audio_usecase *);
+typedef int (*fp_platform_set_snd_device_backend_t)(snd_device_t, const char *,
+                                    const char *);
+typedef int (*fp_platform_get_snd_device_name_extn_t)(void *platform, snd_device_t snd_device,
+                                      char *device_name);
+typedef int (*fp_platform_get_default_app_type_v2_t)(void *, usecase_type_t);
+typedef int (*fp_platform_send_audio_calibration_t)(void *, struct audio_usecase *,
+                                                   int, int);
+typedef int (*fp_platform_get_pcm_device_id_t)(audio_usecase_t, int);
+typedef const char *(*fp_platform_get_snd_device_name_t)(snd_device_t);
+typedef int (*fp_platform_spkr_prot_is_wsa_analog_mode_t)(void *);
+typedef int (*fp_platform_get_snd_device_t)(snd_device_t);
+typedef bool(*fp_platform_check_and_set_codec_backend_cfg_t)(struct audio_device*,
+                                      struct audio_usecase *, snd_device_t);
+
+typedef struct snd_card_split *(*fp_audio_extn_get_snd_card_split_t)();
+typedef bool (*fp_audio_extn_is_vbat_enabled_t)(void);
+
+struct spkr_prot_init_config {
+    fp_read_line_from_file_t                       fp_read_line_from_file;
+    fp_get_usecase_from_list_t                     fp_get_usecase_from_list;
+    fp_enable_disable_snd_device_t                 fp_disable_snd_device;
+    fp_enable_disable_snd_device_t                 fp_enable_snd_device;
+    fp_enable_disable_audio_route_t                fp_disable_audio_route;
+    fp_enable_disable_audio_route_t                fp_enable_audio_route;
+    fp_platform_set_snd_device_backend_t           fp_platform_set_snd_device_backend;
+    fp_platform_get_snd_device_name_extn_t         fp_platform_get_snd_device_name_extn;
+    fp_platform_get_default_app_type_v2_t          fp_platform_get_default_app_type_v2;
+    fp_platform_send_audio_calibration_t           fp_platform_send_audio_calibration;
+    fp_platform_get_pcm_device_id_t                fp_platform_get_pcm_device_id;
+    fp_platform_get_snd_device_name_t              fp_platform_get_snd_device_name;
+    fp_platform_spkr_prot_is_wsa_analog_mode_t     fp_platform_spkr_prot_is_wsa_analog_mode;
+    fp_platform_get_snd_device_t                   fp_platform_get_vi_feedback_snd_device;
+    fp_platform_get_snd_device_t                   fp_platform_get_spkr_prot_snd_device;
+    fp_platform_check_and_set_codec_backend_cfg_t  fp_platform_check_and_set_codec_backend_cfg;
+    fp_audio_extn_get_snd_card_split_t             fp_audio_extn_get_snd_card_split;
+    fp_audio_extn_is_vbat_enabled_t                fp_audio_extn_is_vbat_enabled;
+};
+
+typedef struct spkr_prot_init_config spkr_prot_init_config_t;
+
+// call at adev init
+void audio_extn_init(struct audio_device *adev);
+void audio_extn_feature_init();
+//START: SND_MONITOR_FEATURE ===========================================
+void snd_mon_feature_init (bool is_feature_enabled);
+typedef void (* snd_mon_cb)(void * stream, struct str_parms * parms);
+
+int audio_extn_snd_mon_init();
+int audio_extn_snd_mon_deinit();
+int audio_extn_snd_mon_register_listener(void *stream, snd_mon_cb cb);
+int audio_extn_snd_mon_unregister_listener(void *stream);
+//END: SND_MONITOR_FEATURE   ===========================================
+
+//START: EXTN_QDSP_PLUGIN    ===========================================
+
+void audio_extn_qdsp_init(void *platform);
+void audio_extn_qdsp_deinit();
+bool audio_extn_qdsp_set_state(struct audio_device *adev, int stream_type,
+                             float vol, bool active);
+void audio_extn_qdsp_set_device(struct audio_usecase *usecase);
+void audio_extn_qdsp_set_parameters(struct audio_device *adev,
+                                  struct str_parms *parms);
+bool audio_extn_qdsp_supported_usb();
+
+//END: EXTN_QDSP_PLUGIN      ===========================================
 
 void audio_extn_set_parameters(struct audio_device *adev,
                                struct str_parms *parms);
@@ -159,115 +258,35 @@
                                struct str_parms *query,
                                struct str_parms *reply);
 
-// TODO: remove once maxx audio file is added
-#ifndef MAXXAUDIO_QDSP_ENABLED
-#define audio_extn_ma_init(platform)                                (0)
-#define audio_extn_ma_deinit()                                      (0)
-#define audio_extn_ma_set_device(usecase)                           (0)
-#define audio_extn_ma_set_parameters(adev, param)                   (0)
-#define audio_extn_ma_supported_usb()                               (false)
-#else
-void audio_extn_ma_init(void *platform __unused)
-{
-}
-void audio_extn_ma_deinit()
-{
-}
-void audio_extn_ma_set_device(struct audio_usecase *usecase __unused)
-{
-}
-void audio_extn_ma_set_parameters(struct audio_device *adev __unused,
-                                  struct str_parms *parms __unused)
-{
-}
-bool audio_extn_ma_supported_usb()
-{
-    return false;
-}
-#endif
 
-#ifndef ANC_HEADSET_ENABLED
-#define audio_extn_get_anc_enabled()                     (0)
-#define audio_extn_should_use_fb_anc()                   (0)
-#define audio_extn_should_use_handset_anc(in_channels)   (0)
-#define audio_extn_set_aanc_noise_level(adev, parms)     (0)
-#else
 bool audio_extn_get_anc_enabled(void);
 bool audio_extn_should_use_fb_anc(void);
 bool audio_extn_should_use_handset_anc(int in_channels);
 void audio_extn_set_aanc_noise_level(struct audio_device *adev,
                                      struct str_parms *parms);
-#endif
 
-#ifndef VBAT_MONITOR_ENABLED
-#define audio_extn_is_vbat_enabled()                     (0)
-#define audio_extn_can_use_vbat()                        (0)
-#define audio_extn_is_bcl_enabled()                     (0)
-#define audio_extn_can_use_bcl()                        (0)
-#else
 bool audio_extn_is_vbat_enabled(void);
 bool audio_extn_can_use_vbat(void);
 bool audio_extn_is_bcl_enabled(void);
 bool audio_extn_can_use_bcl(void);
-#endif
 
-#ifndef RAS_ENABLED
-#define audio_extn_is_ras_enabled()                      (0)
-#define audio_extn_can_use_ras()                         (0)
-#else
+void ras_feature_init(bool is_feature_enabled);
 bool audio_extn_is_ras_enabled(void);
 bool audio_extn_can_use_ras(void);
-#endif
 
-#ifndef HIFI_AUDIO_ENABLED
-#define audio_extn_is_hifi_audio_enabled()               (0)
-#define audio_extn_is_hifi_audio_supported()             (0)
-#else
+
+bool audio_extn_is_hifi_audio_enabled(void);
 bool audio_extn_is_hifi_audio_enabled(void);
 bool audio_extn_is_hifi_audio_supported(void);
-#endif
 
-#ifndef FLUENCE_ENABLED
-#define audio_extn_set_fluence_parameters(adev, parms) (0)
-#define audio_extn_get_fluence_parameters(adev, query, reply) (0)
-#else
-void audio_extn_set_fluence_parameters(struct audio_device *adev,
-                                           struct str_parms *parms);
-int audio_extn_get_fluence_parameters(const struct audio_device *adev,
-                  struct str_parms *query, struct str_parms *reply);
-#endif
-
-#ifndef AFE_PROXY_ENABLED
-#define audio_extn_set_afe_proxy_channel_mixer(adev,channel_count)     (0)
-#define audio_extn_read_afe_proxy_channel_masks(out)                   (0)
-#define audio_extn_get_afe_proxy_channel_count()                       (0)
-#else
+//START: AFE_PROXY_FEATURE
 int32_t audio_extn_set_afe_proxy_channel_mixer(struct audio_device *adev,
-                                                    int channel_count);
+                                               int channel_count);
 int32_t audio_extn_read_afe_proxy_channel_masks(struct stream_out *out);
 int32_t audio_extn_get_afe_proxy_channel_count();
+//END: AFE_PROXY_FEATURE
 
-#endif
-
-#ifndef USB_TUNNEL_ENABLED
-#define audio_extn_usb_init(adev)                                      (0)
-#define audio_extn_usb_deinit()                                        (0)
-#define audio_extn_usb_add_device(device, card)                        (0)
-#define audio_extn_usb_remove_device(device, card)                     (0)
-#define audio_extn_usb_is_config_supported(bit_width, sample_rate, ch, pb) \
-                        (*bit_width=0, *sample_rate=0, *ch=0, 0)
-#define audio_extn_usb_enable_sidetone(device, enable)                 (0)
-#define audio_extn_usb_set_sidetone_gain(parms, value, len)            (0)
-#define audio_extn_usb_is_capture_supported()                          (0)
-#define audio_extn_usb_get_max_channels(p)                             (0)
-#define audio_extn_usb_get_max_bit_width(p)                            (0)
-#define audio_extn_usb_get_sup_sample_rates(t, s, l)                   (0)
-#define audio_extn_usb_is_tunnel_supported()                           (0)
-#define audio_extn_usb_alive(adev)                                     (false)
-#define audio_extn_usb_connected(parms)                                (0)
-#undef USB_BURST_MODE_ENABLED
-#undef USB_SIDETONE_VOLUME
-#else
+/// ---- USB feature ---------------------------------------------------------------
 void audio_extn_usb_init(void *adev);
 void audio_extn_usb_deinit();
 void audio_extn_usb_add_device(audio_devices_t device, int card);
@@ -286,17 +305,6 @@
 bool audio_extn_usb_is_tunnel_supported();
 bool audio_extn_usb_alive(int card);
 bool audio_extn_usb_connected(struct str_parms *parms);
-#endif
-
-#ifndef USB_BURST_MODE_ENABLED
-#define audio_extn_usb_find_service_interval(m, p)                     (0)
-#define audio_extn_usb_altset_for_service_interval(p, si, bw, sr, ch)  (-1)
-#define audio_extn_usb_set_service_interval(p, si, recfg)              (-1)
-#define audio_extn_usb_get_service_interval(p, si)                     (-1)
-#define audio_extn_usb_check_and_set_svc_int(uc,ss)                    (0)
-#define audio_extn_usb_is_reconfig_req()                               (0)
-#define audio_extn_usb_set_reconfig(isreq)                             (0)
-#else
 unsigned long audio_extn_usb_find_service_interval(bool min, bool playback);
 int audio_extn_usb_altset_for_service_interval(bool is_playback,
                                                unsigned long service_interval,
@@ -312,35 +320,11 @@
                                          bool starting_output_stream);
 bool audio_extn_usb_is_reconfig_req();
 void audio_extn_usb_set_reconfig(bool is_required);
-#endif
+bool audio_extn_usb_is_sidetone_volume_enabled();
+//------------------------------------------------------------------------------------
 
-#ifndef USB_SIDETONE_VOLUME
-#define audio_extn_usb_get_sidetone_volume(card_info)              (0)
-#define audio_extn_usb_set_sidetone_volume(card_info, en, i)       (0)
-#else
-void audio_extn_usb_get_sidetone_volume(struct usb_card_config *usb_card_info);
-void audio_extn_usb_set_sidetone_volume(struct usb_card_config *usb_card_info,
-                                        bool enable,
-                                        int index);
-#endif
-
-#ifndef A2DP_OFFLOAD_ENABLED
-#define audio_extn_a2dp_init(adev)                       (0)
-#define audio_extn_a2dp_start_playback()                 (0)
-#define audio_extn_a2dp_stop_playback()                  (0)
-#define audio_extn_a2dp_set_parameters(parms, reconfig)  (0)
-#define audio_extn_a2dp_get_parameters(query, reply)     (0)
-#define audio_extn_a2dp_is_force_device_switch()         (0)
-#define audio_extn_a2dp_set_handoff_mode(is_on)          (0)
-#define audio_extn_a2dp_get_enc_sample_rate(sample_rate) (0)
-#define audio_extn_a2dp_get_dec_sample_rate(sample_rate) (0)
-#define audio_extn_a2dp_get_encoder_latency()            (0)
-#define audio_extn_a2dp_sink_is_ready()                  (0)
-#define audio_extn_a2dp_source_is_ready()                (0)
-#define audio_extn_a2dp_source_is_suspended()            (0)
-#define audio_extn_a2dp_start_capture()                  (0)
-#define audio_extn_a2dp_stop_capture()                   (0)
-#else
+// START: A2DP_OFFLOAD FEATURE ==================================================
+int a2dp_offload_feature_init(bool is_feature_enabled);
 void audio_extn_a2dp_init(void *adev);
 int audio_extn_a2dp_start_playback();
 int audio_extn_a2dp_stop_playback();
@@ -357,20 +341,18 @@
 bool audio_extn_a2dp_source_is_suspended();
 int audio_extn_a2dp_start_capture();
 int audio_extn_a2dp_stop_capture();
-#endif
 
-#ifndef SSR_ENABLED
-#define audio_extn_ssr_check_usecase(in)                                  (0)
-#define audio_extn_ssr_set_usecase(in, config, channel_mask_updated)      (0)
-#define audio_extn_ssr_init(in, num_out_chan)                             (0)
-#define audio_extn_ssr_deinit()                                           (0)
-#define audio_extn_ssr_update_enabled()                                   (0)
-#define audio_extn_ssr_get_enabled()                                      (0)
-#define audio_extn_ssr_read(stream, buffer, bytes)                        (0)
-#define audio_extn_ssr_set_parameters(adev, parms)                        (0)
-#define audio_extn_ssr_get_parameters(adev, parms, reply)                 (0)
-#define audio_extn_ssr_get_stream()                                       (0)
-#else
+// --- Function pointers from audio_extn needed by A2DP_OFFLOAD
+typedef int (*fp_check_a2dp_restore_t)(struct audio_device *,
+                                       struct stream_out *, bool);
+struct a2dp_offload_init_config {
+    fp_platform_get_pcm_device_id_t fp_platform_get_pcm_device_id;
+    fp_check_a2dp_restore_t fp_check_a2dp_restore;
+};
+typedef struct a2dp_offload_init_config a2dp_offload_init_config_t;
+// END: A2DP_OFFLOAD FEATURE ====================================================
+
+//START: SSRRC_FEATURE ==========================================================
 bool audio_extn_ssr_check_usecase(struct stream_in *in);
 int audio_extn_ssr_set_usecase(struct stream_in *in,
                                          struct audio_config *config,
@@ -388,7 +370,8 @@
                                    struct str_parms *query,
                                    struct str_parms *reply);
 struct stream_in *audio_extn_ssr_get_stream();
-#endif
+//END: SSREC_FEATURE ============================================================
+
 int audio_extn_check_and_set_multichannel_usecase(struct audio_device *adev,
                                                   struct stream_in *in,
                                                   struct audio_config *config,
@@ -479,13 +462,6 @@
 
 #define HW_INFO_ARRAY_MAX_SIZE 32
 
-struct snd_card_split {
-    char device[HW_INFO_ARRAY_MAX_SIZE];
-    char snd_card[HW_INFO_ARRAY_MAX_SIZE];
-    char form_factor[HW_INFO_ARRAY_MAX_SIZE];
-};
-
-struct snd_card_split *audio_extn_get_snd_card_split();
 void audio_extn_set_snd_card_split(const char* in_snd_card_name);
 void *audio_extn_extspk_init(struct audio_device *adev);
 void audio_extn_extspk_deinit(void *extn);
@@ -500,18 +476,7 @@
                             const char* mixer_xml_path,
                             const char* mixer_xml_path_auxpcm);
 #endif /* AUXPCM_BT_ENABLED */
-#ifndef SPKR_PROT_ENABLED
-#define audio_extn_spkr_prot_init(adev)       (0)
-#define audio_extn_spkr_prot_deinit()         (0)
-#define audio_extn_spkr_prot_start_processing(snd_device)    (-EINVAL)
-#define audio_extn_spkr_prot_calib_cancel(adev) (0)
-#define audio_extn_spkr_prot_stop_processing(snd_device)     (0)
-#define audio_extn_spkr_prot_is_enabled() (false)
-#define audio_extn_spkr_prot_set_parameters(parms, value, len)   (0)
-#define audio_extn_fbsp_set_parameters(parms)   (0)
-#define audio_extn_fbsp_get_parameters(query, reply)   (0)
-#define audio_extn_get_spkr_prot_snd_device(snd_device) (snd_device)
-#else
+
 void audio_extn_spkr_prot_init(void *adev);
 int audio_extn_spkr_prot_deinit();
 int audio_extn_spkr_prot_start_processing(snd_device_t snd_device);
@@ -524,17 +489,10 @@
 int audio_extn_fbsp_get_parameters(struct str_parms *query,
                                    struct str_parms *reply);
 int audio_extn_get_spkr_prot_snd_device(snd_device_t snd_device);
-#endif
 
-#ifndef COMPRESS_CAPTURE_ENABLED
-#define audio_extn_compr_cap_init(in)                     (0)
-#define audio_extn_compr_cap_enabled()                    (0)
-#define audio_extn_compr_cap_format_supported(format)     (0)
-#define audio_extn_compr_cap_usecase_supported(usecase)   (0)
-#define audio_extn_compr_cap_get_buffer_size(format)      (0)
-#define audio_extn_compr_cap_read(in, buffer, bytes)      (0)
-#define audio_extn_compr_cap_deinit()                     (0)
-#else
+
+// START: COMPRESS_CAPTURE FEATURE =========================
+void compr_cap_feature_init(bool is_feature_enabled);
 void audio_extn_compr_cap_init(struct stream_in *in);
 bool audio_extn_compr_cap_enabled();
 bool audio_extn_compr_cap_format_supported(audio_format_t format);
@@ -543,7 +501,7 @@
 size_t audio_extn_compr_cap_read(struct stream_in *in,
                                         void *buffer, size_t bytes);
 void audio_extn_compr_cap_deinit();
-#endif
+// END: COMPRESS_CAPTURE FEATURE =========================
 
 #ifndef DTS_EAGLE
 #define audio_extn_dts_eagle_set_parameters(adev, parms)     (0)
@@ -690,23 +648,20 @@
 int audio_extn_hfp_set_mic_mute(struct audio_device *adev, bool state);
 #endif
 
-#ifndef DSM_FEEDBACK_ENABLED
-#define audio_extn_dsm_feedback_enable(adev, snd_device, benable)  (0)
-#else
+int audio_extn_utils_send_app_type_gain(struct audio_device *adev,
+                                        int app_type,
+                                        int *gain);
+
 void audio_extn_dsm_feedback_enable(struct audio_device *adev,
                          snd_device_t snd_device,
                          bool benable);
-#endif
+void dsm_feedback_feature_init (bool is_feature_enabled);
 
 int audio_extn_utils_send_app_type_gain(struct audio_device *adev,
                                         int app_type,
                                         int *gain);
 
-#ifndef HWDEP_CAL_ENABLED
-#define  audio_extn_hwdep_cal_send(snd_card, acdb_handle) (0)
-#else
 void audio_extn_hwdep_cal_send(int snd_card, void *acdb_handle);
-#endif
 
 #ifndef DEV_ARBI_ENABLED
 #define audio_extn_dev_arbi_init()                  (0)
@@ -838,17 +793,13 @@
 size_t audio_extn_utils_convert_format_24_8_to_8_24(void *buf, size_t bytes);
 int get_snd_codec_id(audio_format_t format);
 
-#ifndef KPI_OPTIMIZE_ENABLED
-#define audio_extn_perf_lock_init() (0)
-#define audio_extn_perf_lock_acquire(handle, duration, opts, size) (0)
-#define audio_extn_perf_lock_release(handle) (0)
-#else
+void kpi_optimize_feature_init(bool is_feature_enabled);
 int audio_extn_perf_lock_init(void);
 void audio_extn_perf_lock_acquire(int *handle, int duration,
                                  int *opts, int size);
 void audio_extn_perf_lock_release(int *handle);
 
-#endif /* KPI_OPTIMIZE_ENABLED */
+
 
 #ifndef AUDIO_EXTERNAL_HDMI_ENABLED
 #define audio_utils_set_hdmi_channel_status(out, buffer, bytes) (0)
@@ -909,14 +860,6 @@
 #define audio_extn_bt_hal_get_device(...)             NULL
 #endif
 
-#ifndef KEEP_ALIVE_ENABLED
-#define audio_extn_keep_alive_init(adev) do {} while(0)
-#define audio_extn_keep_alive_deinit() do {} while(0)
-#define audio_extn_keep_alive_start(ka_mode) do {} while(0)
-#define audio_extn_keep_alive_stop(ka_mode) do {} while(0)
-#define audio_extn_keep_alive_is_active() (false)
-#define audio_extn_keep_alive_set_parameters(adev, parms) (0)
-#else
 void audio_extn_keep_alive_init(struct audio_device *adev);
 void audio_extn_keep_alive_deinit();
 void audio_extn_keep_alive_start(ka_mode_t ka_mode);
@@ -924,7 +867,7 @@
 bool audio_extn_keep_alive_is_active();
 int audio_extn_keep_alive_set_parameters(struct audio_device *adev,
                                          struct str_parms *parms);
-#endif
+
 
 #ifndef AUDIO_GENERIC_EFFECT_FRAMEWORK_ENABLED
 
@@ -993,19 +936,6 @@
 
 #endif /* AUDIO_GENERIC_EFFECT_FRAMEWORK_ENABLED */
 
-typedef void (* snd_mon_cb)(void * stream, struct str_parms * parms);
-#ifndef SND_MONITOR_ENABLED
-#define audio_extn_snd_mon_init()           (0)
-#define audio_extn_snd_mon_deinit()         (0)
-#define audio_extn_snd_mon_register_listener(stream, cb) (0)
-#define audio_extn_snd_mon_unregister_listener(stream) (0)
-#else
-int audio_extn_snd_mon_init();
-int audio_extn_snd_mon_deinit();
-int audio_extn_snd_mon_register_listener(void *stream, snd_mon_cb cb);
-int audio_extn_snd_mon_unregister_listener(void *stream);
-#endif
-
 #ifdef COMPRESS_INPUT_ENABLED
 bool audio_extn_cin_applicable_stream(struct stream_in *in);
 bool audio_extn_cin_attached_usecase(audio_usecase_t uc_id);
@@ -1029,42 +959,23 @@
 #define audio_extn_cin_configure_input_stream(in) (0)
 #endif
 
-#ifndef SOURCE_TRACKING_ENABLED
-static int __unused audio_extn_get_soundfocus_data(
-                                   const struct audio_device *adev __unused,
-                                   struct sound_focus_param *payload __unused)
-{
-    return -ENOSYS;
-}
-static int __unused audio_extn_get_sourcetrack_data(
-                                   const struct audio_device *adev __unused,
-                                   struct source_tracking_param *payload __unused)
-{
-    return -ENOSYS;
-}
-static int __unused audio_extn_set_soundfocus_data(
-                                   struct audio_device *adev __unused,
-                                   struct sound_focus_param *payload __unused)
-{
-    return -ENOSYS;
-}
-#else
+//START: SOURCE_TRACKING_FEATURE ==============================================
 int audio_extn_get_soundfocus_data(const struct audio_device *adev,
                                    struct sound_focus_param *payload);
 int audio_extn_get_sourcetrack_data(const struct audio_device *adev,
                                     struct source_tracking_param *payload);
 int audio_extn_set_soundfocus_data(struct audio_device *adev,
                                    struct sound_focus_param *payload);
-#endif
+void audio_extn_source_track_set_parameters(struct audio_device *adev,
+                                            struct str_parms *parms);
+void audio_extn_source_track_get_parameters(const struct audio_device *adev,
+                                            struct str_parms *query,
+                                            struct str_parms *reply);
+//END: SOURCE_TRACKING_FEATURE ================================================
 
-#ifndef FM_POWER_OPT
-#define audio_extn_fm_set_parameters(adev, parms) (0)
-#define audio_extn_fm_get_parameters(query, reply) (0)
-#else
 void audio_extn_fm_set_parameters(struct audio_device *adev,
                                    struct str_parms *parms);
 void audio_extn_fm_get_parameters(struct str_parms *query, struct str_parms *reply);
-#endif
 
 #ifndef APTX_DECODER_ENABLED
 #define audio_extn_aptx_dec_set_license(adev); (0)
@@ -1228,11 +1139,6 @@
 void audio_extn_ffv_append_ec_ref_dev_name(char *device_name);
 #endif
 
-#ifndef CUSTOM_STEREO_ENABLED
-#define audio_extn_send_dual_mono_mixing_coefficients(out) (0)
-#else
-void audio_extn_send_dual_mono_mixing_coefficients(struct stream_out *out);
-#endif
 int audio_extn_utils_get_license_params(const struct audio_device *adev,  struct audio_license_params *lic_params);
 
 #ifndef EXT_HW_PLUGIN_ENABLED
@@ -1259,4 +1165,20 @@
 int audio_extn_ext_hw_plugin_set_audio_gain(void *plugin,
             struct audio_usecase *usecase, uint32_t gain);
 #endif
+
+bool audio_extn_edid_is_supported_sr(edid_audio_info* info, int sr);
+bool audio_extn_edid_is_supported_bps(edid_audio_info* info, int bps);
+int audio_extn_edid_get_highest_supported_sr(edid_audio_info* info);
+bool audio_extn_edid_get_sink_caps(edid_audio_info* info, char *edid_data);
+
+bool audio_extn_is_display_port_enabled();
+
+bool audio_extn_is_fluence_enabled();
+void audio_extn_set_fluence_parameters(struct audio_device *adev,
+                                           struct str_parms *parms);
+int audio_extn_get_fluence_parameters(const struct audio_device *adev,
+                  struct str_parms *query, struct str_parms *reply);
+
+bool audio_extn_is_custom_stereo_enabled();
+void audio_extn_send_dual_mono_mixing_coefficients(struct stream_out *out);
 #endif /* AUDIO_EXTN_H */
diff --git a/hal/audio_extn/audio_feature_manager.c b/hal/audio_extn/audio_feature_manager.c
new file mode 100644
index 0000000..a399800
--- /dev/null
+++ b/hal/audio_extn/audio_feature_manager.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of The Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define LOG_TAG "audio_feature_manager"
+/*#define LOG_NDEBUG 0*/
+#define LOG_NDDEBUG 0
+
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <cutils/properties.h>
+#include <log/log.h>
+#include <unistd.h>
+#include "audio_feature_manager.h"
+#include <cutils/str_parms.h>
+
+static bool feature_bit_map[MAX_SUPPORTED_FEATURE] = {0};
+
+static void set_default_feature_flags() {
+    ALOGI(":: %s: Enter", __func__);
+    feature_bit_map[SND_MONITOR] = true;
+}
+
+static void set_dynamic_feature_flags() {
+    ALOGI(":: %s: Enter", __func__);
+    // TBD: Dynamically init feature bit
+}
+
+static void set_feature_flags() {
+    ALOGI(":: %s: Enter", __func__);
+    set_default_feature_flags();
+    set_dynamic_feature_flags();
+}
+
+void audio_feature_manager_init() {
+    ALOGI(":: %s: Enter", __func__);
+    set_feature_flags();
+}
+
+bool audio_feature_manager_is_feature_enabled(audio_ext_feature feature) {
+    bool ret_val = false;
+
+    if (feature >= 0 && feature < MAX_SUPPORTED_FEATURE)
+        ret_val = feature_bit_map[feature];
+
+    return ret_val;
+}
diff --git a/hal/audio_extn/audio_feature_manager.h b/hal/audio_extn/audio_feature_manager.h
new file mode 100644
index 0000000..424dc4f
--- /dev/null
+++ b/hal/audio_extn/audio_feature_manager.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of The Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AUDIO_FEATURE_MANAGER_H
+#define AUDIO_FEATURE_MANAGER_H
+
+#include <cutils/str_parms.h>
+
+
+enum audio_ext_feature_t {
+    SND_MONITOR = 0,
+    COMPRESS_CAPTURE,
+    SOURCE_TRACK,
+    SSREC,
+    AUDIOSPHERE,
+    AFE_PROXY,
+    USE_DEEP_AS_PRIMARY_OUTPUT,
+    HDMI_EDID,
+    KEEP_ALIVE,
+    HIFI_AUDIO,
+    RECEIVER_AIDED_STEREO,
+    KPI_OPTIMIZE,
+    DISPLAY_PORT,
+    FLUENCE,
+    CUSTOM_STEREO,
+    ANC_HEADSET,
+    DSM_FEEDBACK,
+    USB_OFFLOAD,
+    USB_OFFLOAD_BURST_MODE,
+    USB_OFFLOAD_SIDETONE_VOLM,
+    A2DP_OFFLOAD,
+    VBAT,
+    COMPRESS_METADATA_NEEDED,
+    VOICE_START = COMPRESS_METADATA_NEEDED,
+    COMPRESS_VOIP,
+    DYNAMIC_ECNS,
+    MAX_SUPPORTED_FEATURE
+};
+
+typedef enum audio_ext_feature_t audio_ext_feature;
+
+void audio_feature_manager_init();
+bool audio_feature_manager_is_feature_enabled(audio_ext_feature feature);
+
+#endif /* AUDIO_FEATURE_MANAGER_H */
diff --git a/hal/audio_extn/cirrus_playback.c b/hal/audio_extn/cirrus_playback.c
index 25fe258..f1b46d9 100644
--- a/hal/audio_extn/cirrus_playback.c
+++ b/hal/audio_extn/cirrus_playback.c
@@ -37,6 +37,16 @@
 #include <cutils/properties.h>
 #include "audio_extn.h"
 
+// - external function dependency -
+static fp_platform_get_snd_device_name_t fp_platform_get_snd_device_name;
+static fp_platform_get_pcm_device_id_t fp_platform_get_pcm_device_id;
+static fp_get_usecase_from_list_t fp_get_usecase_from_list;
+static fp_enable_disable_snd_device_t fp_disable_snd_device;
+static fp_enable_disable_snd_device_t  fp_enable_snd_device;
+static fp_enable_disable_audio_route_t fp_disable_audio_route;
+static fp_enable_disable_audio_route_t fp_enable_audio_route;
+static fp_audio_extn_get_snd_card_split_t fp_audio_extn_get_snd_card_split;
+
 struct cirrus_playback_session {
     void *adev_handle;
     pthread_mutex_t fb_prot_mutex;
@@ -130,19 +140,7 @@
 #define CRUS_SP_IOCTL_SET_CALIB _IOWR(CRUS_SP_IOCTL_MAGIC, 222, void *)
 
 
-
-static struct pcm_config pcm_config_cirrus_tx = {
-    .channels = 2,
-    .rate = 48000,
-    .period_size = 320,
-    .period_count = 4,
-    .format = PCM_FORMAT_S16_LE,
-    .start_threshold = 0,
-    .stop_threshold = INT_MAX,
-    .avail_min = 0,
-};
-
-static struct pcm_config pcm_config_cirrus_rx = {
+struct pcm_config pcm_config_cirrus_rx = {
     .channels = 8,
     .rate = 48000,
     .period_size = 320,
@@ -153,6 +151,17 @@
     .avail_min = 0,
 };
 
+struct pcm_config pcm_config_cirrus_tx = {
+    .channels = 2,
+    .rate = 48000,
+    .period_size = 320,
+    .period_count = 4,
+    .format = PCM_FORMAT_S16_LE,
+    .start_threshold = 0,
+    .stop_threshold = INT_MAX,
+    .avail_min = 0,
+};
+
 static struct cirrus_playback_session handle;
 
 #ifdef CIRRUS_FACTORY_CALIBRATION
@@ -165,7 +174,7 @@
 static void *audio_extn_cirrus_failure_detect_thread();
 #endif
 
-void audio_extn_spkr_prot_init(void *adev) {
+void spkr_prot_init(void *adev, spkr_prot_init_config_t spkr_prot_init_config_val) {
     ALOGI("%s: Initialize Cirrus Logic Playback module", __func__);
 
     memset(&handle, 0, sizeof(handle));
@@ -177,6 +186,16 @@
     handle.adev_handle = adev;
     handle.state = INIT;
 
+    // init function pointers
+    fp_platform_get_snd_device_name = spkr_prot_init_config_val.fp_platform_get_snd_device_name;
+    fp_platform_get_pcm_device_id = spkr_prot_init_config_val.fp_platform_get_pcm_device_id;
+    fp_get_usecase_from_list =  spkr_prot_init_config_val.fp_get_usecase_from_list;
+    fp_disable_snd_device = spkr_prot_init_config_val.fp_disable_snd_device;
+    fp_enable_snd_device = spkr_prot_init_config_val.fp_enable_snd_device;
+    fp_disable_audio_route = spkr_prot_init_config_val.fp_disable_audio_route;
+    fp_enable_audio_route = spkr_prot_init_config_val.fp_enable_audio_route;
+    fp_audio_extn_get_snd_card_split = spkr_prot_init_config_val.fp_audio_extn_get_snd_card_split;
+
     pthread_mutex_init(&handle.fb_prot_mutex, NULL);
 
 #ifdef CIRRUS_FACTORY_CALIBRATION
@@ -190,7 +209,7 @@
 #endif
 }
 
-void audio_extn_spkr_prot_deinit(void *adev __unused) {
+int spkr_prot_deinit() {
     ALOGV("%s: Entry", __func__);
 
 #ifdef ENABLE_CIRRUS_DETECTION
@@ -200,6 +219,7 @@
     pthread_mutex_destroy(&handle.fb_prot_mutex);
 
     ALOGV("%s: Exit", __func__);
+    return 0;
 }
 
 #ifdef CIRRUS_FACTORY_CALIBRATION
@@ -390,7 +410,8 @@
     char *filename = NULL;
     int ret = 0, default_uc = 0;
     struct snd_card_split *snd_split_handle = NULL;
-    snd_split_handle = audio_extn_get_snd_card_split();
+
+    snd_split_handle = fp_audio_extn_get_snd_card_split();
 
     ALOGI("%s: Loading usecase tuning configs", __func__);
 
@@ -487,9 +508,9 @@
     uc_info_rx->out_snd_device = SND_DEVICE_OUT_SPEAKER;
     list_add_tail(&adev->usecase_list, &uc_info_rx->list);
 
-    enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER);
-    enable_audio_route(adev, uc_info_rx);
-    pcm_dev_rx_id = platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
+    fp_enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER);
+    fp_enable_audio_route(adev, uc_info_rx);
+    pcm_dev_rx_id = fp_platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
 
     if (pcm_dev_rx_id < 0) {
         ALOGE("%s: Invalid pcm device for usecase (%d)",
@@ -530,8 +551,9 @@
         pcm_close(handle.pcm_rx);
         handle.pcm_rx = NULL;
     }
-    disable_audio_route(adev, uc_info_rx);
-    disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER);
+
+    fp_disable_audio_route(adev, uc_info_rx);
+    fp_disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER);
     list_remove(&uc_info_rx->list);
     free(uc_info_rx);
     pthread_mutex_unlock(&adev->lock);
@@ -798,7 +820,7 @@
 }
 #endif
 
-int audio_extn_spkr_prot_start_processing(snd_device_t snd_device) {
+int spkr_prot_start_processing(snd_device_t snd_device) {
     struct audio_usecase *uc_info_tx;
     struct audio_device *adev = handle.adev_handle;
     int32_t pcm_dev_tx_id = -1, ret = 0;
@@ -817,7 +839,7 @@
     }
 
     audio_route_apply_and_update_path(adev->audio_route,
-                                      platform_get_snd_device_name(snd_device));
+                                      fp_platform_get_snd_device_name(snd_device));
 
     pthread_mutex_lock(&handle.fb_prot_mutex);
     uc_info_tx->id = USECASE_AUDIO_SPKR_CALIB_TX;
@@ -828,10 +850,10 @@
 
     list_add_tail(&adev->usecase_list, &uc_info_tx->list);
 
-    enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
-    enable_audio_route(adev, uc_info_tx);
+    fp_enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
+    fp_enable_audio_route(adev, uc_info_tx);
 
-    pcm_dev_tx_id = platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
+    pcm_dev_tx_id = fp_platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
 
     if (pcm_dev_tx_id < 0) {
         ALOGE("%s: Invalid pcm device for usecase (%d)",
@@ -875,8 +897,8 @@
             handle.pcm_tx = NULL;
         }
 
-        disable_audio_route(adev, uc_info_tx);
-        disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
+        fp_disable_audio_route(adev, uc_info_tx);
+        fp_disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
         list_remove(&uc_info_tx->list);
         free(uc_info_tx);
     }
@@ -886,7 +908,7 @@
     return ret;
 }
 
-void audio_extn_spkr_prot_stop_processing(snd_device_t snd_device) {
+void spkr_prot_stop_processing(snd_device_t snd_device) {
     struct audio_usecase *uc_info_tx;
     struct audio_device *adev = handle.adev_handle;
 
@@ -895,7 +917,7 @@
     pthread_mutex_lock(&handle.fb_prot_mutex);
 
     handle.state = IDLE;
-    uc_info_tx = get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_TX);
+    uc_info_tx = fp_get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_TX);
 
     if (uc_info_tx) {
         if (handle.pcm_tx) {
@@ -904,13 +926,13 @@
             handle.pcm_tx = NULL;
         }
 
-        disable_audio_route(adev, uc_info_tx);
-        disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
+        fp_disable_audio_route(adev, uc_info_tx);
+        fp_disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
         list_remove(&uc_info_tx->list);
         free(uc_info_tx);
 
         audio_route_reset_path(adev->audio_route,
-                               platform_get_snd_device_name(snd_device));
+                               fp_platform_get_snd_device_name(snd_device));
     }
 
     pthread_mutex_unlock(&handle.fb_prot_mutex);
@@ -918,11 +940,11 @@
     ALOGV("%s: Exit", __func__);
 }
 
-bool audio_extn_spkr_prot_is_enabled() {
+bool spkr_prot_is_enabled() {
     return true;
 }
 
-int audio_extn_get_spkr_prot_snd_device(snd_device_t snd_device) {
+int get_spkr_prot_snd_device(snd_device_t snd_device) {
     switch(snd_device) {
     case SND_DEVICE_OUT_SPEAKER:
     case SND_DEVICE_OUT_SPEAKER_REVERSE:
@@ -936,6 +958,6 @@
     }
 }
 
-void audio_extn_spkr_prot_calib_cancel(__unused void *adev) {
+void spkr_prot_calib_cancel(__unused void *adev) {
     // FIXME: wait or cancel audio_extn_cirrus_run_calibration
 }
diff --git a/hal/audio_extn/compress_capture.c b/hal/audio_extn/compress_capture.c
index 671796c..f0aeec2 100644
--- a/hal/audio_extn/compress_capture.c
+++ b/hal/audio_extn/compress_capture.c
@@ -29,8 +29,8 @@
 #include <cutils/log.h>
 
 #include "audio_hw.h"
-#include "platform.h"
-#include "platform_api.h"
+//#include "platform.h"
+//#include "platform_api.h"
 
 #include "sound/compress_params.h"
 #include "sound/compress_offload.h"
@@ -57,7 +57,7 @@
 };
 
 
-void audio_extn_compr_cap_init(struct stream_in *in)
+void compr_cap_init(struct stream_in *in)
 {
     in->usecase = USECASE_AUDIO_RECORD_COMPRESS;
     in->config.channels = COMPRESS_IN_CONFIG_CHANNELS;
@@ -67,7 +67,7 @@
     c_in_mod.in_buf = (uint8_t*)calloc(1, in->config.period_size*2);
 }
 
-void audio_extn_compr_cap_deinit()
+void compr_cap_deinit()
 {
     if (c_in_mod.in_buf) {
         free(c_in_mod.in_buf);
@@ -75,7 +75,7 @@
     }
 }
 
-bool audio_extn_compr_cap_enabled()
+bool compr_cap_enabled()
 {
     char prop_value[PROPERTY_VALUE_MAX] = {0};
     bool tunnel_encode = false;
@@ -87,7 +87,7 @@
         return false;
 }
 
-bool audio_extn_compr_cap_format_supported(audio_format_t format)
+bool compr_cap_format_supported(audio_format_t format)
 {
     if (format == AUDIO_FORMAT_AMR_WB)
         return true;
@@ -96,7 +96,7 @@
 }
 
 
-bool audio_extn_compr_cap_usecase_supported(audio_usecase_t usecase)
+bool compr_cap_usecase_supported(audio_usecase_t usecase)
 {
     if ((usecase == USECASE_AUDIO_RECORD_COMPRESS) ||
         (usecase == USECASE_INCALL_REC_UPLINK_COMPRESS) ||
@@ -108,7 +108,7 @@
 }
 
 
-size_t audio_extn_compr_cap_get_buffer_size(audio_format_t format)
+size_t compr_cap_get_buffer_size(audio_format_t format)
 {
     if (format == AUDIO_FORMAT_AMR_WB)
         /*One AMR WB frame is 61 bytes. Return that to the caller.
@@ -118,7 +118,7 @@
         return 0;
 }
 
-size_t audio_extn_compr_cap_read(struct stream_in * in,
+size_t compr_cap_read(struct stream_in * in,
     void *buffer, size_t bytes)
 {
     int ret;
diff --git a/hal/edid.c b/hal/audio_extn/edid.c
similarity index 100%
rename from hal/edid.c
rename to hal/audio_extn/edid.c
diff --git a/hal/edid.h b/hal/audio_extn/edid.h
similarity index 92%
rename from hal/edid.h
rename to hal/audio_extn/edid.h
index a7578e6..7c71ab4 100644
--- a/hal/edid.h
+++ b/hal/audio_extn/edid.h
@@ -113,30 +113,8 @@
     unsigned int  channel_mask;
 } edid_audio_info;
 
-#ifdef HDMI_EDID
 bool edid_is_supported_sr(edid_audio_info* info, int sr);
 bool edid_is_supported_bps(edid_audio_info* info, int bps);
 int edid_get_highest_supported_sr(edid_audio_info* info);
 bool edid_get_sink_caps(edid_audio_info* info, char *edid_data);
-#else
-static bool __unused edid_is_supported_sr(edid_audio_info* info __unused, int sr __unused)
-{
-    return false;
-}
-static bool __unused edid_is_supported_bps(edid_audio_info* info __unused, int bps __unused)
-{
-    return false;
-}
-
-static bool __unused edid_get_sink_caps(edid_audio_info* info __unused, char* edid_data __unused)
-{
-    return false;
-}
-
-static int __unused edid_get_highest_supported_sr(edid_audio_info* info __unused)
-{
-    return 0;
-}
-#endif
-
 #endif /* EDID_H */
diff --git a/hal/audio_extn/fm.c b/hal/audio_extn/fm.c
index d08d498..3c1ec68 100644
--- a/hal/audio_extn/fm.c
+++ b/hal/audio_extn/fm.c
@@ -38,7 +38,6 @@
 #include <log_utils.h>
 #endif
 
-#ifdef FM_POWER_OPT
 #define AUDIO_PARAMETER_KEY_HANDLE_FM "handle_fm"
 #define AUDIO_PARAMETER_KEY_FM_VOLUME "fm_volume"
 #define AUDIO_PARAMETER_KEY_REC_PLAY_CONC "rec_play_conc_on"
@@ -251,7 +250,7 @@
     return ret;
 }
 
-void audio_extn_fm_get_parameters(struct str_parms *query, struct str_parms *reply)
+void fm_get_parameters(struct str_parms *query, struct str_parms *reply)
 {
     int ret, val;
     char value[32]={0};
@@ -264,7 +263,7 @@
     }
 }
 
-void audio_extn_fm_set_parameters(struct audio_device *adev,
+void fm_set_parameters(struct audio_device *adev,
                                   struct str_parms *parms)
 {
     int ret, val;
@@ -387,4 +386,3 @@
 exit:
     ALOGV("%s: exit", __func__);
 }
-#endif /* FM_POWER_OPT end */
diff --git a/hal/audio_extn/keep_alive.c b/hal/audio_extn/keep_alive.c
index 90875d9..20214aa 100644
--- a/hal/audio_extn/keep_alive.c
+++ b/hal/audio_extn/keep_alive.c
@@ -37,6 +37,7 @@
 #include "audio_extn.h"
 #include "platform_api.h"
 #include <platform.h>
+#include <pthread.h>
 
 #ifdef DYNAMIC_LOG_ENABLED
 #include <log_xml_parser.h>
@@ -114,7 +115,7 @@
     pthread_cond_signal(&ka.cond);
 }
 
-void audio_extn_keep_alive_init(struct audio_device *adev)
+void keep_alive_init(struct audio_device *adev)
 {
     ka.userdata = adev;
     ka.state = STATE_IDLE;
@@ -146,7 +147,7 @@
     ALOGV("%s init done", __func__);
 }
 
-void audio_extn_keep_alive_deinit()
+void keep_alive_deinit()
 {
     if (ka.state == STATE_DEINIT || ka.state == STATE_DISABLED)
         return;
@@ -191,7 +192,7 @@
     return out_device;
 }
 
-void audio_extn_keep_alive_start(ka_mode_t ka_mode)
+void keep_alive_start(ka_mode_t ka_mode)
 {
     struct audio_device * adev = (struct audio_device *)ka.userdata;
     audio_devices_t out_devices = AUDIO_DEVICE_NONE;
@@ -300,7 +301,7 @@
     return rc;
 }
 
-void audio_extn_keep_alive_stop(ka_mode_t ka_mode)
+void keep_alive_stop(ka_mode_t ka_mode)
 {
     struct audio_device * adev = (struct audio_device *)ka.userdata;
     audio_devices_t out_devices;
@@ -365,7 +366,7 @@
     return 0;
 }
 
-int audio_extn_keep_alive_set_parameters(struct audio_device *adev __unused,
+int keep_alive_set_parameters(struct audio_device *adev __unused,
                                          struct str_parms *parms __unused)
 {
     char value[32];
diff --git a/hal/audio_extn/maxxaudio.c b/hal/audio_extn/maxxaudio.c
index fc65332..5f2a7f0 100644
--- a/hal/audio_extn/maxxaudio.c
+++ b/hal/audio_extn/maxxaudio.c
@@ -41,29 +41,40 @@
 #define CAL_PRESIST_STR "cal_persist"
 #define CAL_SAMPLERATE_STR "cal_samplerate"
 
-#define MA_QDSP_PARAM_INIT "maxxaudio_qdsp_initialize"
-#define MA_QDSP_PARAM_DEINIT "maxxaudio_qdsp_uninitialize"
-#define MA_QDSP_SET_LR_SWAP "maxxaudio_qdsp_set_lr_swap"
-#define MA_QDSP_SET_MODE "maxxaudio_qdsp_set_sound_mode"
-#define MA_QDSP_SET_VOL "maxxaudio_qdsp_set_volume"
-#define MA_QDSP_SET_VOLT "maxxaudio_qdsp_set_volume_table"
+#define MA_QDSP_PARAM_INIT      "maxxaudio_qdsp_initialize"
+#define MA_QDSP_PARAM_DEINIT    "maxxaudio_qdsp_uninitialize"
+#define MA_QDSP_SET_LR_SWAP     "maxxaudio_qdsp_set_lr_swap"
+#define MA_QDSP_SET_MODE        "maxxaudio_qdsp_set_sound_mode"
+#define MA_QDSP_SET_VOL         "maxxaudio_qdsp_set_volume"
+#define MA_QDSP_SET_VOLT        "maxxaudio_qdsp_set_volume_table"
+#define MA_QDSP_SET_PARAM       "maxxaudio_qdsp_set_parameter"
 
-#define SUPPORT_DEV "Blackbird"
+#define SUPPORT_DEV "18d1:5033" // Blackbird usbid
 #define SUPPORTED_USB 0x01
 
-struct ma_audio_cal_settings {
-    int app_type;
-    audio_devices_t device;
-};
+typedef unsigned int effective_scope_flag_t;
+const effective_scope_flag_t EFFECTIVE_SCOPE_RTC = 1 << 0;   /* RTC  */
+const effective_scope_flag_t EFFECTIVE_SCOPE_ACDB = 1 << 1;  /* ACDB */
+const effective_scope_flag_t EFFECTIVE_SCOPE_ALL = EFFECTIVE_SCOPE_RTC | EFFECTIVE_SCOPE_ACDB;
+const effective_scope_flag_t EFFECTIVE_SCOPE_NONE = 0;
+const effective_scope_flag_t EFFECTIVE_SCOPE_DEFAULT = EFFECTIVE_SCOPE_NONE;
 
-struct ma_state {
-    float vol;
-    bool active;
-};
+const unsigned int AUDIO_CAL_SETTINGS_VERSION_MAJOR = 2;
+const unsigned int AUDIO_CAL_SETTINGS_VERSION_MINOR = 0;
+const unsigned int AUDIO_CAL_SETTINGS_VERSION_MAJOR_DEFAULT = AUDIO_CAL_SETTINGS_VERSION_MAJOR;
+const unsigned int AUDIO_CAL_SETTINGS_VERSION_MINOR_DEFAULT = AUDIO_CAL_SETTINGS_VERSION_MINOR;
+
+const unsigned int VALUE_AUTO = 0xFFFFFFFF;
+const unsigned int APP_TYPE_AUTO = VALUE_AUTO;
+const unsigned int APP_TYPE_DEFAULT = APP_TYPE_AUTO;
+const unsigned int DEVICE_AUTO = VALUE_AUTO;
+const unsigned int DEVICE_DEFAULT = DEVICE_AUTO;
+
+const unsigned int MAAP_OUTPUT_GAIN = 27;
 
 typedef enum MA_STREAM_TYPE {
-    STREAM_MIN_STREAM_TYPES,
-    STREAM_VOICE = STREAM_MIN_STREAM_TYPES,
+    STREAM_MIN_TYPES = 0,
+    STREAM_VOICE = STREAM_MIN_TYPES,
     STREAM_SYSTEM,
     STREAM_RING,
     STREAM_MUSIC,
@@ -76,8 +87,31 @@
     MA_CMD_VOL,
     MA_CMD_SWAP_ENABLE,
     MA_CMD_SWAP_DISABLE,
+    MA_CMD_SOFT_MUTE_ENABLE,
+    MA_CMD_SOFT_MUTE_DISABLE,
 } ma_cmd_t;
 
+typedef struct ma_audio_cal_version {
+    unsigned int major;
+    unsigned int minor;
+} ma_audio_cal_version_t;
+
+typedef struct ma_audio_cal_common_settings {
+    unsigned int app_type;
+    unsigned int device;
+} ma_audio_cal_common_settings_t;
+
+struct ma_audio_cal_settings {
+    ma_audio_cal_version_t version;
+    ma_audio_cal_common_settings_t common;
+    effective_scope_flag_t effect_scope_flag;
+};
+
+struct ma_state {
+    float vol;
+    bool active;
+};
+
 typedef void *ma_audio_cal_handle_t;
 typedef int (*set_audio_cal_t)(const char *);
 
@@ -100,6 +134,10 @@
                                       const struct ma_audio_cal_settings *,
                                       size_t, struct ma_state *);
 
+typedef bool (*ma_set_param_t)(ma_audio_cal_handle_t,
+                               const struct ma_audio_cal_settings *,
+                               unsigned int, double);
+
 struct ma_platform_data {
     void *waves_handle;
     void *platform;
@@ -110,6 +148,8 @@
     ma_set_sound_mode_t      ma_set_sound_mode;
     ma_set_volume_t          ma_set_volume;
     ma_set_volume_table_t    ma_set_volume_table;
+    ma_set_param_t           ma_set_param;
+    bool speaker_lr_swap;
 };
 
 ma_audio_cal_handle_t g_ma_audio_cal_handle = NULL;
@@ -132,20 +172,6 @@
                                    audio_cal_settings, swap);
 }
 
-static bool ma_set_sound_mode_l(
-    const struct ma_audio_cal_settings *audio_cal_settings, int sound_mode)
-{
-    return my_data->ma_set_sound_mode(g_ma_audio_cal_handle,
-                                      audio_cal_settings, sound_mode);
-}
-
-static bool ma_set_volume_l(
-    const struct ma_audio_cal_settings *audio_cal_settings, double volume)
-{
-    return my_data->ma_set_volume(g_ma_audio_cal_handle, audio_cal_settings,
-                                  volume);
-}
-
 static bool ma_set_volume_table_l(
     const struct ma_audio_cal_settings *audio_cal_settings,
     size_t num_streams, struct ma_state *volume_table)
@@ -155,6 +181,14 @@
                                         volume_table);
 }
 
+static bool ma_set_param_l(
+    const struct ma_audio_cal_settings *audio_cal_settings,
+    unsigned int index, double value)
+{
+    return my_data->ma_set_param(g_ma_audio_cal_handle,
+                                 audio_cal_settings, index, value);
+}
+
 static inline bool valid_usecase(struct audio_usecase *usecase)
 {
     if ((usecase->type == PCM_PLAYBACK) &&
@@ -165,8 +199,9 @@
         /* support devices */
         ((usecase->devices & AUDIO_DEVICE_OUT_SPEAKER) ||
          (usecase->devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) ||
-         /* TODO: enable A2DP when it is ready */
-         (usecase->devices & AUDIO_DEVICE_OUT_ALL_USB)))
+         (audio_is_usb_out_device(usecase->devices) &&
+          audio_extn_ma_supported_usb())))
+        /* TODO: enable A2DP when it is ready */
 
         return true;
 
@@ -182,46 +217,48 @@
     ma_stream_type_t i = 0;
 
     for (i = 0; i < STREAM_MAX_TYPES; i++)
-        if (ma_cur_state_table[i].active &&
-                (ma_cur_state_table[i].vol != 0))
+        if (ma_cur_state_table[i].active)
             return true;
 
     return false;
 }
 
+static void ma_cal_init(struct ma_audio_cal_settings *ma_cal)
+{
+    ma_cal->version.major = AUDIO_CAL_SETTINGS_VERSION_MAJOR_DEFAULT;
+    ma_cal->version.minor = AUDIO_CAL_SETTINGS_VERSION_MINOR_DEFAULT;
+    ma_cal->common.app_type = APP_TYPE_DEFAULT;
+    ma_cal->common.device = DEVICE_DEFAULT;
+    ma_cal->effect_scope_flag = EFFECTIVE_SCOPE_ALL;
+}
+
 static bool check_and_send_all_audio_cal(struct audio_device *adev, ma_cmd_t cmd)
 {
     int i = 0;
     bool ret = false;
-    float vol = 0;
     struct listnode *node;
     struct audio_usecase *usecase;
-    struct ma_audio_cal_settings *ma_cal = NULL;
+    struct ma_audio_cal_settings ma_cal;
 
-    // alloct
-    ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));
-
-    if (ma_cal == NULL) {
-        ALOGE("%s: ma_cal alloct fail", __func__);
-        return ret;
-    }
+    ma_cal_init(&ma_cal);
 
     list_for_each(node, &adev->usecase_list) {
         usecase = node_to_item(node, struct audio_usecase, list);
         if (valid_usecase(usecase)) {
-            ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;
-            ma_cal->device = usecase->stream.out->devices;
+            ma_cal.common.app_type = usecase->stream.out->app_type_cfg.app_type;
+            ma_cal.common.device = usecase->stream.out->devices;
             ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",
-                      __func__, usecase->id, ma_cal->app_type, ma_cal->device);
+                      __func__, usecase->id, ma_cal.common.app_type,
+                      ma_cal.common.device);
 
             switch (cmd) {
                 case MA_CMD_VOL:
-                    ret = ma_set_volume_table_l(ma_cal, STREAM_MAX_TYPES,
+                    ret = ma_set_volume_table_l(&ma_cal, STREAM_MAX_TYPES,
                                                 ma_cur_state_table);
                     if (ret)
-                        ALOGV("Waves: ma_set_volume_table_l success");
+                        ALOGV("ma_set_volume_table_l success");
                     else
-                        ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);
+                        ALOGE("ma_set_volume_table_l returned with error.");
 
                     ALOGV("%s: send volume table === Start", __func__);
                     for (i = 0; i < STREAM_MAX_TYPES; i++)
@@ -230,26 +267,49 @@
                               ma_cur_state_table[i].active ? "T" : "F");
                     ALOGV("%s: send volume table === End", __func__);
                     break;
+
                 case MA_CMD_SWAP_ENABLE:
-                    ret = ma_set_lr_swap_l(ma_cal, true);
-                    if (ret)
-                        ALOGV("Waves: ma_set_lr_swap_l enable returned with success.");
-                    else
-                        ALOGE("Waves: ma_set_lr_swap_l enable returned with error.");
+                    /* lr swap only enable for speaker path */
+                    if (ma_cal.common.device & AUDIO_DEVICE_OUT_SPEAKER) {
+                        ret = ma_set_lr_swap_l(&ma_cal, true);
+                        if (ret)
+                            ALOGV("ma_set_lr_swap_l enable returned with success.");
+                        else
+                            ALOGE("ma_set_lr_swap_l enable returned with error.");
+                    }
                     break;
+
                 case MA_CMD_SWAP_DISABLE:
-                    ret = ma_set_lr_swap_l(ma_cal, false);
+                    ret = ma_set_lr_swap_l(&ma_cal, false);
                     if (ret)
-                        ALOGV("Waves: ma_set_lr_swap_l disable returned with success.");
+                        ALOGV("ma_set_lr_swap_l disable returned with success.");
                     else
-                        ALOGE("Waves: ma_set_lr_swap_l disable returned with error.");
+                        ALOGE("ma_set_lr_swap_l disable returned with error.");
                     break;
+
+                case MA_CMD_SOFT_MUTE_ENABLE:
+                    if (usecase->id == USECASE_AUDIO_PLAYBACK_LOW_LATENCY) break;
+
+                    ma_cal.effect_scope_flag = EFFECTIVE_SCOPE_RTC;
+                    ret = ma_set_param_l(&ma_cal, MAAP_OUTPUT_GAIN, -96);
+                    if (!ret)
+                        ALOGE("soft mute enable returned with error.");
+                    break;
+
+                case MA_CMD_SOFT_MUTE_DISABLE:
+                    if (usecase->id == USECASE_AUDIO_PLAYBACK_LOW_LATENCY) break;
+
+                    ma_cal.effect_scope_flag = EFFECTIVE_SCOPE_RTC;
+                    ret = ma_set_param_l(&ma_cal, MAAP_OUTPUT_GAIN, 0);
+                    if (!ret)
+                        ALOGE("soft mute disable returned with error.");
+                    break;
+
                 default:
                     ALOGE("%s: unsupported cmd %d", __func__, cmd);
             }
         }
     }
-    free(ma_cal);
 
     return ret;
 }
@@ -282,14 +342,6 @@
 
 static void ma_set_swap_l(struct audio_device *adev, bool enable)
 {
-    // do platform LR swap if it enables on Waves effect
-    // but there is no Waves implementation
-    if (!my_data) {
-        platform_check_and_set_swap_lr_channels(adev, enable);
-        ALOGV("%s: maxxaudio isn't initialized.", __func__);
-        return;
-    }
-
     if (enable)
         check_and_send_all_audio_cal(adev, MA_CMD_SWAP_ENABLE);
     else
@@ -305,7 +357,7 @@
     char *idd;
 
     if (enable) {
-        ret = snprintf(path, sizeof(path), "/proc/asound/card%u/id", card);
+        ret = snprintf(path, sizeof(path), "/proc/asound/card%u/usbid", card);
         if (ret < 0) {
             ALOGE("%s: failed on snprintf (%d) to path %s\n",
                   __func__, ret, path);
@@ -325,10 +377,10 @@
         idd = strtok(id, "\n");
 
         if (find_sup_dev(idd)) {
-            ALOGV("%s: support device name is %s", __func__, id);
+            ALOGV("%s: support usbid is %s", __func__, id);
             g_supported_dev |= SUPPORTED_USB;
         } else
-            ALOGV("%s: device %s isn't found from %s", __func__, id, SUPPORT_DEV);
+            ALOGV("%s: usbid %s isn't found from %s", __func__, id, SUPPORT_DEV);
     } else {
         g_supported_dev &= ~SUPPORTED_USB;
     }
@@ -417,6 +469,13 @@
              ALOGE("%s: dlsym error %s for ma_set_volume_table", __func__, dlerror());
              goto error;
          }
+
+         my_data->ma_set_param = (ma_set_param_t)dlsym(
+                                  my_data->waves_handle, MA_QDSP_SET_PARAM);
+         if (!my_data->ma_set_param) {
+             ALOGE("%s: dlsym error %s for ma_set_param", __func__, dlerror());
+             goto error;
+         }
     }
 
     /* get preset table */
@@ -480,6 +539,8 @@
         ma_cur_state_table[i].active = false;
     }
 
+    my_data->speaker_lr_swap = false;
+
     return;
 
 error:
@@ -509,27 +570,42 @@
                              float vol, bool active)
 {
     bool ret = false;
-    ma_stream_type_t stype = (ma_stream_type_t)stream_type;
+    bool first_enable = false;
+    struct ma_state pr_mstate;
 
-    ALOGV("%s: stream[%d] vol[%f] active[%s]",
-          __func__, stream_type, vol, active ? "true" : "false");
+    if (stream_type >= STREAM_MAX_TYPES ||
+        stream_type < STREAM_MIN_TYPES) {
+        ALOGE("%s: stream_type %d out of range.", __func__, stream_type);
+        return ret;
+    }
 
     if (!my_data) {
         ALOGV("%s: maxxaudio isn't initialized.", __func__);
         return ret;
     }
 
-    // update condition
-    // 1. start track: active and volume isn't zero
-    // 2. stop track: no tracks are active
-    if ((active && vol != 0) ||
-        (!active)) {
-        pthread_mutex_lock(&my_data->lock);
+    ALOGV("%s: stream[%d] vol[%f] active[%s]",
+          __func__, stream_type, vol, active ? "true" : "false");
 
-        ma_cur_state_table[stype].vol = vol;
-        ma_cur_state_table[stype].active = active;
-        if (is_active())
-            ret = check_and_send_all_audio_cal(adev, MA_CMD_VOL);
+    pr_mstate.vol = ma_cur_state_table[(ma_stream_type_t)stream_type].vol;
+    pr_mstate.active = ma_cur_state_table[(ma_stream_type_t)stream_type].active;
+
+    // update condition: vol or active state changes
+    if (pr_mstate.vol != vol || pr_mstate.active != active) {
+
+        pthread_mutex_lock(&my_data->lock);
+        // get active state before updating
+        first_enable = (!is_active()) && active;
+
+        ma_cur_state_table[(ma_stream_type_t)stream_type].vol = vol;
+        ma_cur_state_table[(ma_stream_type_t)stream_type].active = active;
+
+        if (first_enable) //all F -> one of T
+            ret = check_and_send_all_audio_cal(adev, MA_CMD_SOFT_MUTE_DISABLE);
+        else if (!is_active()) // all F
+            ret = check_and_send_all_audio_cal(adev, MA_CMD_SOFT_MUTE_ENABLE);
+
+        ret = check_and_send_all_audio_cal(adev, MA_CMD_VOL);
 
         pthread_mutex_unlock(&my_data->lock);
     }
@@ -540,9 +616,7 @@
 void audio_extn_ma_set_device(struct audio_usecase *usecase)
 {
     int i = 0;
-    int u_index = -1;
-    float vol = 0;
-    struct ma_audio_cal_settings *ma_cal = NULL;
+    struct ma_audio_cal_settings ma_cal;
 
     if (!my_data) {
         ALOGV("%s: maxxaudio isn't initialized.", __func__);
@@ -554,61 +628,67 @@
         return;
     }
 
-    ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));
+    ma_cal_init(&ma_cal);
 
     /* update audio_cal and send it */
-    if (ma_cal != NULL){
-        ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;
-        ma_cal->device = usecase->stream.out->devices;
-        ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",
-                      __func__, usecase->id, ma_cal->app_type, ma_cal->device);
+    ma_cal.common.app_type = usecase->stream.out->app_type_cfg.app_type;
+    ma_cal.common.device = usecase->stream.out->devices;
+    ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",
+              __func__, usecase->id, ma_cal.common.app_type,
+              ma_cal.common.device);
 
-        pthread_mutex_lock(&my_data->lock);
+    pthread_mutex_lock(&my_data->lock);
 
-        if (is_active()) {
-            ALOGV("%s: send volume table === Start", __func__);
-            for (i = 0; i < STREAM_MAX_TYPES; i++)
-                ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,
-                    ma_cur_state_table[i].vol,
-                    ma_cur_state_table[i].active ? "T" : "F");
-            ALOGV("%s: send volume table === End", __func__);
+    if (is_active()) {
+        if (ma_cal.common.device & AUDIO_DEVICE_OUT_SPEAKER)
+            ma_set_swap_l(usecase->stream.out->dev, my_data->speaker_lr_swap);
+        else
+            ma_set_swap_l(usecase->stream.out->dev, false);
 
-            if (!ma_set_volume_table_l(ma_cal,
-                                       STREAM_MAX_TYPES,
-                                       ma_cur_state_table))
-                ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);
-            else
-                ALOGV("Waves: ma_set_volume_table_l success");
+        ALOGV("%s: send volume table === Start", __func__);
+        for (i = 0; i < STREAM_MAX_TYPES; i++)
+            ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,
+                   ma_cur_state_table[i].vol,
+                   ma_cur_state_table[i].active ? "T" : "F");
+        ALOGV("%s: send volume table === End", __func__);
 
-        }
-        pthread_mutex_unlock(&my_data->lock);
-        free(ma_cal);
-    } else {
-        ALOGE("%s: ma_cal alloct fail", __func__);
+        if (!ma_set_volume_table_l(&ma_cal,
+                                   STREAM_MAX_TYPES,
+                                   ma_cur_state_table))
+            ALOGE("ma_set_volume_table_l returned with error.");
+        else
+            ALOGV("ma_set_volume_table_l success");
+
     }
+    pthread_mutex_unlock(&my_data->lock);
 }
 
 void audio_extn_ma_set_parameters(struct audio_device *adev,
                                   struct str_parms *parms)
 {
     int ret;
-    bool ret_b;
     int val;
     char value[128];
 
     // do LR swap and usb recognition
     ret = str_parms_get_int(parms, "rotation", &val);
     if (ret >= 0) {
+        if (!my_data) {
+            ALOGV("%s: maxxaudio isn't initialized.", __func__);
+            return;
+        }
+
         switch (val) {
         case 270:
-            ma_set_swap_l(adev, true);
+            my_data->speaker_lr_swap = true;
             break;
         case 0:
         case 90:
         case 180:
-            ma_set_swap_l(adev, false);
+            my_data->speaker_lr_swap = false;
             break;
         }
+        ma_set_swap_l(adev, my_data->speaker_lr_swap);
     }
 
     // check connect status
diff --git a/hal/audio_extn/sndmonitor.c b/hal/audio_extn/sndmonitor.c
index 3351e6f..b0495ea 100644
--- a/hal/audio_extn/sndmonitor.c
+++ b/hal/audio_extn/sndmonitor.c
@@ -659,7 +659,7 @@
 
 // --- public APIs --- //
 
-int audio_extn_snd_mon_deinit()
+int snd_mon_deinit()
 {
     if (!sndmonitor.initcheck)
         return -1;
@@ -675,7 +675,7 @@
     return 0;
 }
 
-int audio_extn_snd_mon_init()
+int snd_mon_init()
 {
     sndmonitor.notify = snd_mon_update;
     sndmonitor.target = NULL; // unused for now
@@ -717,7 +717,7 @@
     return -ENODEV;
 }
 
-int audio_extn_snd_mon_register_listener(void *stream, snd_mon_cb cb)
+int snd_mon_register_listener(void *stream, snd_mon_cb cb)
 {
     if (!sndmonitor.initcheck) {
         ALOGW("sndmonitor initcheck failed, cannot register");
@@ -727,7 +727,7 @@
     return add_listener(stream, cb);
 }
 
-int audio_extn_snd_mon_unregister_listener(void *stream)
+int snd_mon_unregister_listener(void *stream)
 {
     if (!sndmonitor.initcheck) {
         ALOGW("sndmonitor initcheck failed, cannot deregister");
diff --git a/hal/audio_extn/source_track.c b/hal/audio_extn/source_track.c
index 507aa7e..064fad8 100644
--- a/hal/audio_extn/source_track.c
+++ b/hal/audio_extn/source_track.c
@@ -47,7 +47,6 @@
 #include <log_utils.h>
 #endif
 
-#ifdef SOURCE_TRACKING_ENABLED
 /* Audio Paramater Key to identify the list of start angles.
  * Starting angle (in degrees) defines the boundary starting angle for each sector.
  */
@@ -500,7 +499,7 @@
     }
 }
 
-int audio_extn_get_soundfocus_data(const struct audio_device *adev,
+int get_soundfocus_data(const struct audio_device *adev,
                                    struct sound_focus_param *payload)
 {
     int ret = 0;
@@ -515,7 +514,7 @@
     return ret ;
 }
 
-int audio_extn_get_sourcetrack_data(const struct audio_device *adev,
+int get_sourcetrack_data(const struct audio_device *adev,
                               struct source_tracking_param *payload)
 {
     int ret = 0;
@@ -530,7 +529,7 @@
     return ret ;
 }
 
-void audio_extn_source_track_get_parameters(const struct audio_device *adev,
+void source_track_get_parameters(const struct audio_device *adev,
                                             struct str_parms *query,
                                             struct str_parms *reply)
 {
@@ -605,7 +604,7 @@
     return ret;
 }
 
-int audio_extn_set_soundfocus_data(struct audio_device *adev,
+int set_soundfocus_data(struct audio_device *adev,
                               struct sound_focus_param *payload)
 {
     int ret = 0;
@@ -616,7 +615,7 @@
     return ret ;
 }
 
-void audio_extn_source_track_set_parameters(struct audio_device *adev,
+void source_track_set_parameters(struct audio_device *adev,
                                             struct str_parms *parms)
 {
     int len, ret;
@@ -695,4 +694,3 @@
         free(value);
     return;
 }
-#endif /* SOURCE_TRACKING_ENABLED end */
diff --git a/hal/audio_extn/spkr_protection.c b/hal/audio_extn/spkr_protection.c
index 08ecb7a..d123dd1 100644
--- a/hal/audio_extn/spkr_protection.c
+++ b/hal/audio_extn/spkr_protection.c
@@ -146,6 +146,25 @@
 #define AUDIO_PARAMETER_KEY_FBSP_CFG_FTM_TIME       "fbsp_cfg_ftm_time"
 #define AUDIO_PARAMETER_KEY_FBSP_GET_FTM_PARAM      "get_ftm_param"
 
+// - external function dependency -
+static fp_read_line_from_file_t fp_read_line_from_file;
+static fp_get_usecase_from_list_t fp_get_usecase_from_list;
+static fp_enable_disable_snd_device_t fp_disable_snd_device;
+static fp_enable_disable_snd_device_t  fp_enable_snd_device;
+static fp_enable_disable_audio_route_t fp_disable_audio_route;
+static fp_enable_disable_audio_route_t fp_enable_audio_route;
+static fp_platform_set_snd_device_backend_t fp_platform_set_snd_device_backend;
+static fp_platform_get_snd_device_name_extn_t fp_platform_get_snd_device_name_extn;
+static fp_platform_get_default_app_type_v2_t fp_platform_get_default_app_type_v2;
+static fp_platform_send_audio_calibration_t fp_platform_send_audio_calibration;
+static fp_platform_get_pcm_device_id_t fp_platform_get_pcm_device_id;
+static fp_platform_get_snd_device_name_t fp_platform_get_snd_device_name;
+static fp_platform_spkr_prot_is_wsa_analog_mode_t fp_platform_spkr_prot_is_wsa_analog_mode;
+static fp_platform_get_snd_device_t fp_platform_get_vi_feedback_snd_device;
+static fp_platform_get_snd_device_t fp_platform_get_spkr_prot_snd_device;
+static fp_platform_check_and_set_codec_backend_cfg_t fp_platform_check_and_set_codec_backend_cfg;
+static fp_audio_extn_is_vbat_enabled_t fp_audio_extn_is_vbat_enabled;
+
 /*Modes of Speaker Protection*/
 enum speaker_protection_mode {
     SPKR_PROTECTION_DISABLED = -1,
@@ -296,6 +315,10 @@
 static int vi_feed_no_channels;
 static struct spkr_tz_names tz_names;
 
+int get_spkr_prot_snd_device(snd_device_t snd_device) {
+    return snd_device;
+}
+
 /*===========================================================================
 FUNCTION get_tzn
 
@@ -344,7 +367,7 @@
                 continue;
             snprintf(name, MAX_PATH, TZ_TYPE, tzn);
             ALOGV("Opening %s\n", name);
-            read_line_from_file(name, buf, sizeof(buf));
+            fp_read_line_from_file(name, buf, sizeof(buf));
             if (strlen(buf) > 0)
                 buf[strlen(buf) - 1] = '\0';
             if (!strcmp(buf, sensor_name)) {
@@ -377,7 +400,7 @@
    }
 }
 
-void audio_extn_spkr_prot_calib_cancel(void *adev)
+void spkr_prot_calib_cancel(void *adev)
 {
     pthread_t threadid;
     struct audio_usecase *uc_info;
@@ -387,7 +410,7 @@
         ALOGE("%s: Invalid params", __func__);
         return;
     }
-    uc_info = get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_RX);
+    uc_info = fp_get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_RX);
     if (uc_info) {
             pthread_mutex_lock(&handle.mutex_spkr_prot);
             pthread_mutex_lock(&handle.spkr_calib_cancelack_mutex);
@@ -566,12 +589,12 @@
         pthread_cond_destroy(&handle.spkr_prot_thermalsync);
     }
 }
-static void audio_extn_check_wsa(struct audio_device *adev,
+static void check_wsa(struct audio_device *adev,
                 unsigned int num_of_spkrs, bool *wsa_is_8815)
 {
     unsigned int i = 0;
     if (!handle.wsa_found ||
-        platform_spkr_prot_is_wsa_analog_mode(adev)){
+        fp_platform_spkr_prot_is_wsa_analog_mode(adev)){
         for (i = 0; i < num_of_spkrs; i++)
             wsa_is_8815[i] = false;
 
@@ -587,7 +610,7 @@
         wsa_is_8815[SP_V2_SPKR_2] = true;
 }
 
-int audio_extn_set_wcd_boost_max_state(struct audio_device *adev,
+int set_wcd_boost_max_state(struct audio_device *adev,
                 int boost_max_state, int wsa_num)
 {
     struct mixer_ctl *ctl = NULL;
@@ -613,7 +636,7 @@
     return 0;
 }
 
-int audio_extn_set_wsa_boost_level(struct audio_device *adev,
+int set_wsa_boost_level(struct audio_device *adev,
                 int wsa_num, int boost_table_index)
 {
     struct mixer_ctl *ctl;
@@ -643,7 +666,7 @@
     return 0;
 }
 
-static int audio_extn_spkr_boost_update(struct audio_device *adev,
+static int spkr_boost_update(struct audio_device *adev,
                 unsigned int wsa_num, unsigned int *index, bool spkr2_is_mono)
 {
     float dcr = 0;
@@ -680,14 +703,14 @@
     if (spkr2_is_mono)
         wsa_to_set = SP_V2_SPKR_2;
 
-    ret = audio_extn_set_wcd_boost_max_state(adev, boost_max_state, wsa_to_set);
+    ret = set_wcd_boost_max_state(adev, boost_max_state, wsa_to_set);
     if (ret < 0) {
         ALOGE("%s: failed to set wcd max boost state.",
             __func__);
         return -EINVAL;
     }
 
-    ret = audio_extn_set_wsa_boost_level(adev, wsa_to_set, r0_index);
+    ret = set_wsa_boost_level(adev, wsa_to_set, r0_index);
     if (ret < 0) {
         ALOGE("%s: failed to set wsa boost level.",
             __func__);
@@ -699,7 +722,7 @@
     return 0;
 }
 
-static void audio_extn_set_boost_and_limiter(struct audio_device *adev,
+static void set_boost_and_limiter(struct audio_device *adev,
                 bool spv3_enable, unsigned int afe_api_version)
 {
     int chn = 0;
@@ -715,7 +738,7 @@
      * follow lookup table based on R0 impediance regardless
      * of spv2 or spv3.
      */
-    audio_extn_check_wsa(adev, vi_feed_no_channels, wsa_is_8815);
+    check_wsa(adev, vi_feed_no_channels, wsa_is_8815);
     if (vi_feed_no_channels == 1 && wsa_is_8815[SP_V2_SPKR_2])
         spkr2_is_mono_speaker = true;
     /*
@@ -728,7 +751,7 @@
         if (spkr2_is_mono_speaker)
             chn_in_use = SP_V2_SPKR_2;
         if (wsa_is_8815[chn_in_use] &&
-            !audio_extn_spkr_boost_update(adev, chn,
+            !spkr_boost_update(adev, chn,
                                     &r0_index, spkr2_is_mono_speaker)) {
             handle.limiter_th[chn] = spv3_limiter_th_q27_table[r0_index];
             handle.sp_version = SP_V3;
@@ -793,21 +816,21 @@
     uc_info_rx->type = PCM_PLAYBACK;
     uc_info_rx->in_snd_device = SND_DEVICE_NONE;
     uc_info_rx->stream.out = adev->primary_output;
-    if (audio_extn_is_vbat_enabled())
+    if (fp_audio_extn_is_vbat_enabled())
         uc_info_rx->out_snd_device = SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT;
     else
         uc_info_rx->out_snd_device = SND_DEVICE_OUT_SPEAKER_PROTECTED;
     disable_rx = true;
     list_add_tail(&adev->usecase_list, &uc_info_rx->list);
-    platform_check_and_set_codec_backend_cfg(adev, uc_info_rx,
+    fp_platform_check_and_set_codec_backend_cfg(adev, uc_info_rx,
                                              uc_info_rx->out_snd_device);
-    if (audio_extn_is_vbat_enabled())
-         enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
+    if (fp_audio_extn_is_vbat_enabled())
+         fp_enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
     else
-         enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED);
-    enable_audio_route(adev, uc_info_rx);
+         fp_enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED);
+    fp_enable_audio_route(adev, uc_info_rx);
 
-    pcm_dev_rx_id = platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
+    pcm_dev_rx_id = fp_platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
     ALOGV("%s: pcm device id %d", __func__, pcm_dev_rx_id);
     if (pcm_dev_rx_id < 0) {
         ALOGE("%s: Invalid pcm device for usecase (%d)",
@@ -837,10 +860,10 @@
 
     disable_tx = true;
     list_add_tail(&adev->usecase_list, &uc_info_tx->list);
-    enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
-    enable_audio_route(adev, uc_info_tx);
+    fp_enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
+    fp_enable_audio_route(adev, uc_info_tx);
 
-    pcm_dev_tx_id = platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
+    pcm_dev_tx_id = fp_platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
     ALOGV("%s: pcm device id %d", __func__, pcm_dev_tx_id);
     if (pcm_dev_tx_id < 0) {
         ALOGE("%s: Invalid pcm device for usecase (%d)",
@@ -929,9 +952,9 @@
                   __func__);
             uc_info_tx->in_snd_device = SND_DEVICE_IN_HANDSET_MIC;
             uc_info_tx->out_snd_device = SND_DEVICE_NONE;
-            app_type = platform_get_default_app_type_v2(adev->platform,
+            app_type = fp_platform_get_default_app_type_v2(adev->platform,
                                                 PCM_CAPTURE);
-            platform_send_audio_calibration(adev->platform, uc_info_tx,
+            fp_platform_send_audio_calibration(adev->platform, uc_info_tx,
                                                     app_type, 8000);
         }
         if (!status.status) {
@@ -959,16 +982,16 @@
         }
         if (disable_rx) {
             list_remove(&uc_info_rx->list);
-            if (audio_extn_is_vbat_enabled())
-                disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
+            if (fp_audio_extn_is_vbat_enabled())
+                fp_disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
             else
-                disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED);
-            disable_audio_route(adev, uc_info_rx);
+                fp_disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED);
+            fp_disable_audio_route(adev, uc_info_rx);
         }
         if (disable_tx) {
             list_remove(&uc_info_tx->list);
-            disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
-            disable_audio_route(adev, uc_info_tx);
+            fp_disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK);
+            fp_disable_audio_route(adev, uc_info_tx);
         }
         if (uc_info_rx) free(uc_info_rx);
         if (uc_info_tx) free(uc_info_tx);
@@ -1094,7 +1117,7 @@
                 handle.spkr_prot_mode = MSM_SPKR_PROT_CALIBRATED;
             close(acdb_fd);
 
-            audio_extn_set_boost_and_limiter(adev, spv3_enable, afe_api_version);
+            set_boost_and_limiter(adev, spv3_enable, afe_api_version);
 
             pthread_exit(0);
             return NULL;
@@ -1278,7 +1301,7 @@
         dlclose(handle.thermal_handle);
     handle.thermal_handle = NULL;
 
-    audio_extn_set_boost_and_limiter(adev, spv3_enable, afe_api_version);
+    set_boost_and_limiter(adev, spv3_enable, afe_api_version);
 
     pthread_exit(0);
     return NULL;
@@ -1295,7 +1318,7 @@
     return 0;
 }
 
-void audio_extn_spkr_prot_set_parameters(struct str_parms *parms,
+void spkr_prot_set_parameters(struct str_parms *parms,
                                          char *value, int len)
 {
     int err;
@@ -1534,7 +1557,7 @@
     pthread_mutex_unlock(&handle.cal_wait_cond_mutex);
 }
 
-int audio_extn_fbsp_set_parameters(struct str_parms *parms)
+int fbsp_set_parameters(struct str_parms *parms)
 {
     int ret= 0 , err;
     char *value = NULL;
@@ -1623,7 +1646,7 @@
     return ret;
 }
 
-int audio_extn_fbsp_get_parameters(struct str_parms *query,
+int fbsp_get_parameters(struct str_parms *query,
                                    struct str_parms *reply)
 {
     int err = 0;
@@ -1649,7 +1672,7 @@
     return err;
 }
 
-void audio_extn_spkr_prot_init(void *adev)
+void spkr_prot_init(void *adev, spkr_prot_init_config_t spkr_prot_init_config_val)
 {
     char value[PROPERTY_VALUE_MAX];
     int result = 0;
@@ -1674,6 +1697,24 @@
         ALOGD("%s: Speaker protection disabled", __func__);
         return;
     }
+    // init function pointers
+    fp_read_line_from_file = spkr_prot_init_config_val.fp_read_line_from_file;
+    fp_get_usecase_from_list =  spkr_prot_init_config_val.fp_get_usecase_from_list;
+    fp_disable_snd_device = spkr_prot_init_config_val.fp_disable_snd_device;
+    fp_enable_snd_device = spkr_prot_init_config_val.fp_enable_snd_device;
+    fp_disable_audio_route = spkr_prot_init_config_val.fp_disable_audio_route;
+    fp_enable_audio_route = spkr_prot_init_config_val.fp_enable_audio_route;
+    fp_platform_set_snd_device_backend = spkr_prot_init_config_val.fp_platform_set_snd_device_backend;
+    fp_platform_get_snd_device_name_extn = spkr_prot_init_config_val.fp_platform_get_snd_device_name_extn;
+    fp_platform_get_default_app_type_v2 = spkr_prot_init_config_val.fp_platform_get_default_app_type_v2;
+    fp_platform_send_audio_calibration = spkr_prot_init_config_val.fp_platform_send_audio_calibration;
+    fp_platform_get_pcm_device_id = spkr_prot_init_config_val.fp_platform_get_pcm_device_id;
+    fp_platform_get_snd_device_name = spkr_prot_init_config_val.fp_platform_get_snd_device_name;
+    fp_platform_spkr_prot_is_wsa_analog_mode = spkr_prot_init_config_val.fp_platform_spkr_prot_is_wsa_analog_mode;
+    fp_platform_get_vi_feedback_snd_device = spkr_prot_init_config_val.fp_platform_get_vi_feedback_snd_device;
+    fp_platform_get_spkr_prot_snd_device = spkr_prot_init_config_val.fp_platform_get_spkr_prot_snd_device;
+    fp_platform_check_and_set_codec_backend_cfg = spkr_prot_init_config_val.fp_platform_check_and_set_codec_backend_cfg;
+    fp_audio_extn_is_vbat_enabled = spkr_prot_init_config_val.fp_audio_extn_is_vbat_enabled;
     handle.adev_handle = adev;
     handle.spkr_prot_mode = MSM_SPKR_PROT_DISABLED;
     handle.spkr_processing_state = SPKR_PROCESSING_IN_IDLE;
@@ -1693,7 +1734,7 @@
     pthread_mutex_init(&handle.cal_wait_cond_mutex, NULL);
     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
     if (handle.wsa_found) {
-        if (platform_spkr_prot_is_wsa_analog_mode(adev) == 1) {
+        if (fp_platform_spkr_prot_is_wsa_analog_mode(adev) == 1) {
             ALOGD("%s: WSA analog mode", __func__);
             pcm_config_skr_prot.channels = WSA_ANALOG_MODE_CHANNELS;
         }
@@ -1773,14 +1814,14 @@
         char platform[PROPERTY_VALUE_MAX];
         property_get("ro.board.platform", platform, "");
         if (!strncmp("apq8084", platform, sizeof("apq8084"))) {
-            platform_set_snd_device_backend(SND_DEVICE_OUT_VOICE_SPEAKER,
+            fp_platform_set_snd_device_backend(SND_DEVICE_OUT_VOICE_SPEAKER,
                                             "speaker-protected",
                                             "SLIMBUS_0_RX");
         }
     }
 }
 
-int audio_extn_spkr_prot_deinit()
+int spkr_prot_deinit()
 {
     int result = 0;
 
@@ -1801,7 +1842,7 @@
     return 0;
 }
 
-int audio_extn_select_spkr_prot_cal_data(snd_device_t snd_device)
+int select_spkr_prot_cal_data(snd_device_t snd_device)
 {
     struct audio_cal_info_spk_prot_cfg protCfg;
     int acdb_fd = -1;
@@ -1841,7 +1882,7 @@
     return ret;
 }
 
-int audio_extn_spkr_prot_start_processing(snd_device_t snd_device)
+int spkr_prot_start_processing(snd_device_t snd_device)
 {
     struct audio_usecase *uc_info_tx;
     struct audio_device *adev = handle.adev_handle;
@@ -1856,23 +1897,23 @@
        ALOGE("%s: Invalid params", __func__);
        return -EINVAL;
     }
-    snd_device = platform_get_spkr_prot_snd_device(snd_device);
+    snd_device = fp_platform_get_spkr_prot_snd_device(snd_device);
     if (handle.spkr_prot_mode == MSM_SPKR_PROT_CALIBRATED) {
-        ret = audio_extn_select_spkr_prot_cal_data(snd_device);
+        ret = select_spkr_prot_cal_data(snd_device);
         if (ret) {
             ALOGE("%s: Setting speaker protection cal data failed", __func__);
             return ret;
         }
     }
 
-    in_snd_device = platform_get_vi_feedback_snd_device(snd_device);
+    in_snd_device = fp_platform_get_vi_feedback_snd_device(snd_device);
     spkr_prot_set_spkrstatus(true);
     uc_info_tx = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
     if (!uc_info_tx) {
         return -ENOMEM;
     }
 
-    if (platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
+    if (fp_platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
         ALOGE("%s: Invalid sound device returned", __func__);
         return -EINVAL;
     }
@@ -1889,10 +1930,10 @@
         uc_info_tx->out_snd_device = SND_DEVICE_NONE;
         handle.pcm_tx = NULL;
         list_add_tail(&adev->usecase_list, &uc_info_tx->list);
-        enable_snd_device(adev, in_snd_device);
-        enable_audio_route(adev, uc_info_tx);
+        fp_enable_snd_device(adev, in_snd_device);
+        fp_enable_audio_route(adev, uc_info_tx);
 
-        pcm_dev_tx_id = platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
+        pcm_dev_tx_id = fp_platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
         if (pcm_dev_tx_id < 0) {
             ALOGE("%s: Invalid pcm device for usecase (%d)",
                   __func__, uc_info_tx->id);
@@ -1920,9 +1961,9 @@
               __func__);
         uc_info_tx->in_snd_device = SND_DEVICE_IN_HANDSET_MIC;
         uc_info_tx->out_snd_device = SND_DEVICE_NONE;
-        app_type = platform_get_default_app_type_v2(adev->platform,
+        app_type = fp_platform_get_default_app_type_v2(adev->platform,
                                             PCM_CAPTURE);
-        platform_send_audio_calibration(adev->platform, uc_info_tx,
+        fp_platform_send_audio_calibration(adev->platform, uc_info_tx,
                                                 app_type, 8000);
     }
     if (ret) {
@@ -1934,8 +1975,8 @@
         uc_info_tx->type = PCM_CAPTURE;
         uc_info_tx->in_snd_device = in_snd_device;
         uc_info_tx->out_snd_device = SND_DEVICE_NONE;
-        disable_snd_device(adev, in_snd_device);
-        disable_audio_route(adev, uc_info_tx);
+        fp_disable_snd_device(adev, in_snd_device);
+        fp_disable_audio_route(adev, uc_info_tx);
         free(uc_info_tx);
     } else
         handle.spkr_processing_state = SPKR_PROCESSING_IN_PROGRESS;
@@ -1944,27 +1985,27 @@
     return ret;
 }
 
-void audio_extn_spkr_prot_stop_processing(snd_device_t snd_device)
+void spkr_prot_stop_processing(snd_device_t snd_device)
 {
     struct audio_usecase *uc_info_tx;
     struct audio_device *adev = handle.adev_handle;
     snd_device_t in_snd_device;
 
     ALOGV("%s: Entry", __func__);
-    snd_device = platform_get_spkr_prot_snd_device(snd_device);
+    snd_device = fp_platform_get_spkr_prot_snd_device(snd_device);
     spkr_prot_set_spkrstatus(false);
-    in_snd_device = platform_get_vi_feedback_snd_device(snd_device);
+    in_snd_device = fp_platform_get_vi_feedback_snd_device(snd_device);
 
     pthread_mutex_lock(&handle.mutex_spkr_prot);
     if (adev && handle.spkr_processing_state == SPKR_PROCESSING_IN_PROGRESS) {
-        uc_info_tx = get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_TX);
+        uc_info_tx = fp_get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_TX);
         if (handle.pcm_tx)
             pcm_close(handle.pcm_tx);
         handle.pcm_tx = NULL;
-        disable_snd_device(adev, in_snd_device);
+        fp_disable_snd_device(adev, in_snd_device);
         if (uc_info_tx) {
             list_remove(&uc_info_tx->list);
-            disable_audio_route(adev, uc_info_tx);
+            fp_disable_audio_route(adev, uc_info_tx);
             free(uc_info_tx);
         }
     }
@@ -1972,16 +2013,18 @@
     pthread_mutex_unlock(&handle.mutex_spkr_prot);
     if (adev)
         audio_route_reset_and_update_path(adev->audio_route,
-                                      platform_get_snd_device_name(snd_device));
+                                      fp_platform_get_snd_device_name(snd_device));
     ALOGV("%s: Exit", __func__);
 }
 
-bool audio_extn_spkr_prot_is_enabled()
+bool spkr_prot_is_enabled()
 {
     return handle.spkr_prot_enable;
 }
 
-int audio_extn_get_spkr_prot_snd_device(snd_device_t snd_device) {
-    return snd_device;
+void spkr_prot_is_enabled_init()
+{
+
 }
+
 #endif /*SPKR_PROT_ENABLED*/
diff --git a/hal/audio_extn/ssr.c b/hal/audio_extn/ssr.c
index 15eaaef..d83b508 100644
--- a/hal/audio_extn/ssr.c
+++ b/hal/audio_extn/ssr.c
@@ -26,7 +26,7 @@
 #include <stdlib.h>
 #include <dlfcn.h>
 #include <cutils/str_parms.h>
-#include <cutils/log.h>
+#include <log/log.h>
 #include <pthread.h>
 #include <cutils/sched_policy.h>
 #include <sys/resource.h>
@@ -44,7 +44,6 @@
 #include <log_utils.h>
 #endif
 
-#ifdef SSR_ENABLED
 #define COEFF_ARRAY_SIZE            4
 #define FILT_SIZE                   ((512+1)* 6)  /* # ((FFT bins)/2+1)*numOutputs */
 #define SSR_CHANNEL_OUTPUT_NUM      6
@@ -313,7 +312,7 @@
     return ret;
 }
 
-void audio_extn_ssr_update_enabled()
+void ssr_update_enabled()
 {
     char ssr_enabled[PROPERTY_VALUE_MAX] = "false";
 
@@ -327,7 +326,7 @@
     }
 }
 
-bool audio_extn_ssr_get_enabled()
+bool ssr_get_enabled()
 {
     ALOGV("%s: is_ssr_enabled:%d is_ssr_mode_on:%d ", __func__, ssrmod.is_ssr_enabled, ssrmod.is_ssr_mode_on);
 
@@ -337,13 +336,13 @@
     return false;
 }
 
-bool  audio_extn_ssr_check_usecase(struct stream_in *in) {
+bool  ssr_check_usecase(struct stream_in *in) {
     int ret = false;
     int channel_count = audio_channel_count_from_in_mask(in->channel_mask);
     audio_devices_t devices = in->device;
     audio_source_t source = in->source;
 
-    if ((audio_extn_ssr_get_enabled()) &&
+    if ((ssr_get_enabled()) &&
             ((channel_count == 2) || (channel_count == 6)) &&
             ((AUDIO_SOURCE_MIC == source) || (AUDIO_SOURCE_CAMCORDER == source)) &&
             ((AUDIO_DEVICE_IN_BUILTIN_MIC == devices) || (AUDIO_DEVICE_IN_BACK_MIC == devices)) &&
@@ -355,39 +354,6 @@
     return ret;
 }
 
-int audio_extn_ssr_set_usecase(struct stream_in *in,
-                               struct audio_config *config,
-                               bool *update_params)
-{
-    int ret = -EINVAL;
-    int channel_count = audio_channel_count_from_in_mask(in->channel_mask);
-    audio_channel_representation_t representation =
-                  audio_channel_mask_get_representation(in->channel_mask);
-    *update_params = false;
-
-    if (audio_extn_ssr_check_usecase(in)) {
-
-        if (representation == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
-            /* update params in case channel representation index.
-             * on returning error, flinger will retry with supported representation passed
-             */
-            ALOGD("%s: SSR supports only channel representation position, channel_mask(%#x)"
-                              ,__func__, config->channel_mask);
-            config->channel_mask = AUDIO_CHANNEL_IN_6;
-            ret = 0;
-            *update_params = true;
-        } else {
-            if (!audio_extn_ssr_init(in, channel_count)) {
-                ALOGD("%s: Created SSR session succesfully", __func__);
-                ret = 0;
-            } else {
-                ALOGE("%s: Unable to start SSR record session", __func__);
-            }
-        }
-    }
-    return ret;
-}
-
 static void pcm_buffer_queue_push(struct pcm_buffer_queue **queue,
                                   struct pcm_buffer_queue *node)
 {
@@ -440,12 +406,58 @@
     }
 }
 
-struct stream_in *audio_extn_ssr_get_stream()
+struct stream_in *ssr_get_stream()
 {
     return ssrmod.in;
 }
 
-int32_t audio_extn_ssr_init(struct stream_in *in, int num_out_chan)
+int32_t ssr_deinit()
+{
+    ALOGV("%s: entry", __func__);
+    deinit_ssr_process_thread();
+
+    if (ssrmod.drc_obj) {
+        ssrmod.drc_deinit(ssrmod.drc_obj);
+        ssrmod.drc_obj = NULL;
+    }
+
+    if (ssrmod.surround_obj) {
+
+        if (ssrmod.ssr_3mic) {
+            ssrmod.surround_rec_deinit(ssrmod.surround_obj);
+            ssrmod.surround_obj = NULL;
+        }
+        if (ssrmod.surround_raw_buffer) {
+            free(ssrmod.surround_raw_buffer);
+            ssrmod.surround_raw_buffer = NULL;
+        }
+        if (ssrmod.fp_input)
+            fclose(ssrmod.fp_input);
+        if (ssrmod.fp_output)
+            fclose(ssrmod.fp_output);
+    }
+
+    if(ssrmod.drc_handle) {
+        dlclose(ssrmod.drc_handle);
+        ssrmod.drc_handle = NULL;
+    }
+
+    if(ssrmod.surround_rec_handle) {
+        dlclose(ssrmod.surround_rec_handle);
+        ssrmod.surround_rec_handle = NULL;
+    }
+
+    ssrmod.in = NULL;
+    //SSR session can be closed due to device switch
+    //Do not force reset ssr mode
+
+    //ssrmod.is_ssr_mode_on = false;
+    ALOGV("%s: exit", __func__);
+
+    return 0;
+}
+
+int32_t ssr_init(struct stream_in *in, int num_out_chan)
 {
     uint32_t ret = -1;
     char c_multi_ch_dump[128] = {0};
@@ -455,10 +467,10 @@
 
     if (ssrmod.surround_obj != NULL) {
         ALOGV("%s: reinitializing surround sound library", __func__);
-        audio_extn_ssr_deinit();
+        ssr_deinit();
     }
 
-    if (audio_extn_ssr_get_enabled()) {
+    if (ssr_get_enabled()) {
         ssrmod.ssr_3mic = 1;
     } else {
         ALOGE(" Rejecting SSR -- init is called without enabling SSR");
@@ -577,54 +589,41 @@
     return 0;
 
 fail:
-    (void) audio_extn_ssr_deinit();
+    (void) ssr_deinit();
     return ret;
 }
 
-int32_t audio_extn_ssr_deinit()
+int ssr_set_usecase(struct stream_in *in,
+                               struct audio_config *config,
+                               bool *update_params)
 {
-    ALOGV("%s: entry", __func__);
-    deinit_ssr_process_thread();
+    int ret = -EINVAL;
+    int channel_count = audio_channel_count_from_in_mask(in->channel_mask);
+    audio_channel_representation_t representation =
+                  audio_channel_mask_get_representation(in->channel_mask);
+    *update_params = false;
 
-    if (ssrmod.drc_obj) {
-        ssrmod.drc_deinit(ssrmod.drc_obj);
-        ssrmod.drc_obj = NULL;
-    }
+    if (ssr_check_usecase(in)) {
 
-    if (ssrmod.surround_obj) {
-
-        if (ssrmod.ssr_3mic) {
-            ssrmod.surround_rec_deinit(ssrmod.surround_obj);
-            ssrmod.surround_obj = NULL;
+        if (representation == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
+            /* update params in case channel representation index.
+             * on returning error, flinger will retry with supported representation passed
+             */
+            ALOGD("%s: SSR supports only channel representation position, channel_mask(%#x)"
+                              ,__func__, config->channel_mask);
+            config->channel_mask = AUDIO_CHANNEL_IN_6;
+            ret = 0;
+            *update_params = true;
+        } else {
+            if (!ssr_init(in, channel_count)) {
+                ALOGD("%s: Created SSR session succesfully", __func__);
+                ret = 0;
+            } else {
+                ALOGE("%s: Unable to start SSR record session", __func__);
+            }
         }
-        if (ssrmod.surround_raw_buffer) {
-            free(ssrmod.surround_raw_buffer);
-            ssrmod.surround_raw_buffer = NULL;
-        }
-        if (ssrmod.fp_input)
-            fclose(ssrmod.fp_input);
-        if (ssrmod.fp_output)
-            fclose(ssrmod.fp_output);
     }
-
-    if(ssrmod.drc_handle) {
-        dlclose(ssrmod.drc_handle);
-        ssrmod.drc_handle = NULL;
-    }
-
-    if(ssrmod.surround_rec_handle) {
-        dlclose(ssrmod.surround_rec_handle);
-        ssrmod.surround_rec_handle = NULL;
-    }
-
-    ssrmod.in = NULL;
-    //SSR session can be closed due to device switch
-    //Do not force reset ssr mode
-
-    //ssrmod.is_ssr_mode_on = false;
-    ALOGV("%s: exit", __func__);
-
-    return 0;
+    return ret;
 }
 
 static void *ssr_process_thread(void *context __unused)
@@ -699,7 +698,7 @@
     pthread_exit(NULL);
 }
 
-int32_t audio_extn_ssr_read(struct audio_stream_in *stream,
+int32_t ssr_read(struct audio_stream_in *stream,
                        void *buffer, size_t bytes)
 {
     struct stream_in *in = (struct stream_in *)stream;
@@ -755,7 +754,7 @@
     return ret;
 }
 
-void audio_extn_ssr_set_parameters(struct audio_device *adev __unused,
+void ssr_set_parameters(struct audio_device *adev __unused,
                                    struct str_parms *parms)
 {
     int err;
@@ -791,7 +790,7 @@
     }
 }
 
-void audio_extn_ssr_get_parameters(const struct audio_device *adev __unused,
+void ssr_get_parameters(const struct audio_device *adev __unused,
                                    struct str_parms *parms,
                                    struct str_parms *reply)
 {
@@ -822,4 +821,3 @@
     }
 }
 
-#endif /* SSR_ENABLED */
diff --git a/hal/audio_extn/usb.c b/hal/audio_extn/usb.c
index 3b2f1b3..9981ef0 100644
--- a/hal/audio_extn/usb.c
+++ b/hal/audio_extn/usb.c
@@ -44,7 +44,6 @@
 #include <log_utils.h>
 #endif
 
-#ifdef USB_TUNNEL_ENABLED
 #define USB_BUFF_SIZE           2048
 #define CHANNEL_NUMBER_STR      "Channels: "
 #define PLAYBACK_PROFILE_STR    "Playback:"
@@ -117,6 +116,62 @@
     "Mic Playback Switch",
 };
 
+static const char * const usb_sidetone_volume_str[] = {
+    "Sidetone Playback Volume",
+    "Mic Playback Volume",
+};
+
+static int usb_get_sidetone_gain(struct usb_card_config *card_info)
+{
+    int gain = card_info->usb_sidetone_vol_min + usbmod->sidetone_gain;
+    if (gain > card_info->usb_sidetone_vol_max)
+        gain = card_info->usb_sidetone_vol_max;
+    return gain;
+}
+
+static void usb_get_sidetone_volume(struct usb_card_config *usb_card_info)
+{
+    struct mixer_ctl *ctl;
+    unsigned int index;
+
+    if (!audio_extn_usb_is_sidetone_volume_enabled())
+        return;
+
+    for (index = 0;
+         index < sizeof(usb_sidetone_volume_str)/sizeof(usb_sidetone_volume_str[0]);
+         index++) {
+        ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
+                                    usb_sidetone_volume_str[index]);
+        if (ctl) {
+            usb_card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX] = index;
+            usb_card_info->usb_sidetone_vol_min = mixer_ctl_get_range_min(ctl);
+            usb_card_info->usb_sidetone_vol_max = mixer_ctl_get_range_max(ctl);
+            break;
+        }
+    }
+}
+
+static void usb_set_sidetone_volume(struct usb_card_config *usb_card_info,
+                                        bool enable, int index)
+{
+    struct mixer_ctl *ctl;
+
+    if (!audio_extn_usb_is_sidetone_volume_enabled())
+        return;
+
+    ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
+                                usb_sidetone_volume_str[index]);
+
+    if (ctl == NULL)
+        ALOGV("%s: sidetone gain mixer command is not found",
+              __func__);
+    else if (enable)
+        mixer_ctl_set_value(ctl, 0,
+                            usb_get_sidetone_gain(usb_card_info));
+}
+
+
+
 static void usb_mixer_print_enum(struct mixer_ctl *ctl)
 {
     unsigned int num_enums;
@@ -320,7 +375,7 @@
     return 0;
 }
 
-static int usb_get_service_interval(const char *interval_str_start,
+static int get_usb_service_interval(const char *interval_str_start,
                                     struct usb_device_config *usb_device_info)
 {
     unsigned long interval = 0;
@@ -530,7 +585,7 @@
         interval_str_start = strstr(str_start, DATA_PACKET_INTERVAL_STR);
         if (interval_str_start != NULL) {
             interval_str_start += strlen(DATA_PACKET_INTERVAL_STR);
-            ret = usb_get_service_interval(interval_str_start, usb_device_info);
+            ret = get_usb_service_interval(interval_str_start, usb_device_info);
             if (ret < 0) {
                 ALOGE("%s: error unable to get service interval, assume default",
                       __func__);
@@ -607,7 +662,7 @@
         }
     }
 
-    audio_extn_usb_get_sidetone_volume(usb_card_info);
+    usb_get_sidetone_volume(usb_card_info);
 
     if ((usb_card_info->usb_snd_mixer != NULL) && (usb_audio_debug_enable))
         usb_soundcard_list_controls(usb_card_info->usb_snd_mixer);
@@ -898,7 +953,7 @@
     return is_usb_supported;
 }
 
-void audio_extn_usb_set_sidetone_gain(struct str_parms *parms,
+void usb_set_sidetone_gain(struct str_parms *parms,
                                 char *value, int len)
 {
     int err;
@@ -914,7 +969,7 @@
     return;
 }
 
-int audio_extn_usb_enable_sidetone(int device, bool enable)
+int usb_enable_sidetone(int device, bool enable)
 {
     int ret = -ENODEV;
     struct listnode *node_i;
@@ -938,7 +993,7 @@
                     break;
 
                 if ((i = card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX]) != -1) {
-                    audio_extn_usb_set_sidetone_volume(card_info, enable, i);
+                    usb_set_sidetone_volume(card_info, enable, i);
                 }
 
                 ret = 0;
@@ -949,7 +1004,7 @@
     return ret;
 }
 
-bool audio_extn_usb_is_config_supported(unsigned int *bit_width,
+bool usb_is_config_supported(unsigned int *bit_width,
                                         unsigned int *sample_rate,
                                         unsigned int *ch,
                                         bool is_playback)
@@ -982,7 +1037,7 @@
     return is_usb_supported;
 }
 
-int audio_extn_usb_get_max_channels(bool is_playback)
+int usb_get_max_channels(bool is_playback)
 {
     struct listnode *node_i, *node_j;
     struct usb_device_config *dev_info;
@@ -1004,7 +1059,7 @@
     return max_ch;
 }
 
-int audio_extn_usb_get_max_bit_width(bool is_playback)
+int usb_get_max_bit_width(bool is_playback)
 {
     struct listnode *node_i, *node_j;
     struct usb_device_config *dev_info;
@@ -1026,7 +1081,7 @@
     return max_bw;
 }
 
-int audio_extn_usb_get_sup_sample_rates(bool is_playback,
+int usb_get_sup_sample_rates(bool is_playback,
                                         uint32_t *sample_rates,
                                         uint32_t sample_rate_size)
 {
@@ -1046,7 +1101,7 @@
     return i;
 }
 
-bool audio_extn_usb_is_capture_supported()
+bool usb_is_capture_supported()
 {
     if (usbmod == NULL) {
         ALOGE("%s: USB device object is NULL", __func__);
@@ -1056,12 +1111,12 @@
     return usbmod->is_capture_supported;
 }
 
-bool audio_extn_usb_is_tunnel_supported()
+bool usb_is_tunnel_supported()
 {
     return true;
 }
 
-void audio_extn_usb_add_device(audio_devices_t device, int card)
+void usb_add_device(audio_devices_t device, int card)
 {
     struct usb_card_config *usb_card_info;
     char check_debug_enable[PROPERTY_VALUE_MAX];
@@ -1134,7 +1189,7 @@
     return;
 }
 
-void audio_extn_usb_remove_device(audio_devices_t device, int card)
+void usb_remove_device(audio_devices_t device, int card)
 {
     struct listnode *node_i, *temp_i;
     struct listnode *node_j, *temp_j;
@@ -1187,15 +1242,14 @@
     return;
 }
 
-bool audio_extn_usb_alive(int card) {
+bool usb_alive(int card) {
     char path[PATH_MAX] = {0};
     // snprintf should never fail
     (void) snprintf(path, sizeof(path), "/proc/asound/card%u/stream0", card);
     return access(path, F_OK) == 0;
 }
 
-#ifdef USB_BURST_MODE_ENABLED
-unsigned long audio_extn_usb_find_service_interval(bool min,
+unsigned long usb_find_service_interval(bool min,
                                                    bool playback) {
     struct usb_card_config *card_info = NULL;
     struct usb_device_config *dev_info = NULL;
@@ -1219,7 +1273,7 @@
     return interval_us;
 }
 
-int audio_extn_usb_altset_for_service_interval(bool playback,
+int usb_altset_for_service_interval(bool playback,
                                                unsigned long service_interval,
                                                uint32_t *bit_width,
                                                uint32_t *sample_rate,
@@ -1285,7 +1339,7 @@
 #undef SET_OR_RETURN_ON_ERROR
 }
 
-int audio_extn_usb_get_service_interval(bool playback,
+int usb_get_service_interval(bool playback,
                                         unsigned long *service_interval)
 {
     const char *ctl_name = "USB_AUDIO_RX service_interval";
@@ -1306,7 +1360,7 @@
     return 0;
 }
 
-int audio_extn_usb_set_service_interval(bool playback,
+int usb_set_service_interval(bool playback,
                                         unsigned long service_interval,
                                         bool *reconfig)
 {
@@ -1326,7 +1380,7 @@
         return -1;
     }
 
-    if (audio_extn_usb_get_service_interval(playback,
+    if (usb_get_service_interval(playback,
                                             &current_service_interval) != 0) {
         ALOGE("%s Unable to get current service interval", __func__);
         return -1;
@@ -1341,7 +1395,7 @@
     return 0;
 }
 
-int audio_extn_usb_check_and_set_svc_int(struct audio_usecase *uc_info,
+int usb_check_and_set_svc_int(struct audio_usecase *uc_info,
                                          bool starting_output_stream)
 {
     struct listnode *node = NULL;
@@ -1389,9 +1443,9 @@
     ALOGV("%s: burst mode(%d).", __func__,burst_mode);
 
     service_interval =
-            audio_extn_usb_find_service_interval(!burst_mode, true /*playback*/);
+            usb_find_service_interval(!burst_mode, true /*playback*/);
 
-    audio_extn_usb_set_service_interval(true /*playback*/,
+    usb_set_service_interval(true /*playback*/,
                                         service_interval,
                                         &reconfig);
 
@@ -1401,29 +1455,28 @@
     return 0;
 }
 
-bool audio_extn_usb_is_reconfig_req()
+bool usb_is_reconfig_req()
 {
     return usbmod->usb_reconfig;
 }
 
-void audio_extn_usb_set_reconfig(bool is_required)
+void usb_set_reconfig(bool is_required)
 {
     usbmod->usb_reconfig = is_required;
 }
-#endif /* USB_BURST_MODE_ENABLED end */
 
-bool audio_extn_usb_connected(struct str_parms *parms) {
+bool usb_connected(struct str_parms *parms) {
     int card = -1;
     struct listnode *node_i = NULL;
     struct usb_card_config *usb_card_info = NULL;
     bool usb_connected = false;
 
     if ((parms != NULL) && str_parms_get_int(parms, "card", &card) >= 0) {
-        usb_connected = audio_extn_usb_alive(card);
+        usb_connected = usb_alive(card);
     } else {
         list_for_each(node_i, &usbmod->usb_card_conf_list) {
             usb_card_info = node_to_item(node_i, struct usb_card_config, list);
-            if (audio_extn_usb_alive(usb_card_info->usb_card)) {
+            if (usb_alive(usb_card_info->usb_card)) {
                 usb_connected = true;
                 break;
             }
@@ -1432,7 +1485,7 @@
     return usb_connected;
 }
 
-void audio_extn_usb_init(void *adev)
+void usb_init(void *adev)
 {
     if (usbmod == NULL) {
         usbmod = calloc(1, sizeof(struct usb_module));
@@ -1453,61 +1506,10 @@
     return;
 }
 
-void audio_extn_usb_deinit(void)
+void usb_deinit(void)
 {
     if (NULL != usbmod){
         free(usbmod);
         usbmod = NULL;
     }
 }
-
-#ifdef USB_SIDETONE_VOLUME
-static const char * const usb_sidetone_volume_str[] = {
-    "Sidetone Playback Volume",
-    "Mic Playback Volume",
-};
-
-static int usb_get_sidetone_gain(struct usb_card_config *card_info)
-{
-    int gain = card_info->usb_sidetone_vol_min + usbmod->sidetone_gain;
-    if (gain > card_info->usb_sidetone_vol_max)
-        gain = card_info->usb_sidetone_vol_max;
-    return gain;
-}
-
-void audio_extn_usb_get_sidetone_volume(struct usb_card_config *usb_card_info)
-{
-    struct mixer_ctl *ctl;
-    unsigned int index;
-
-    for (index = 0;
-         index < sizeof(usb_sidetone_volume_str)/sizeof(usb_sidetone_volume_str[0]);
-         index++) {
-        ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
-                                    usb_sidetone_volume_str[index]);
-        if (ctl) {
-            usb_card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX] = index;
-            usb_card_info->usb_sidetone_vol_min = mixer_ctl_get_range_min(ctl);
-            usb_card_info->usb_sidetone_vol_max = mixer_ctl_get_range_max(ctl);
-            break;
-        }
-    }
-}
-
-void audio_extn_usb_set_sidetone_volume(struct usb_card_config *usb_card_info,
-                                        bool enable, int index)
-{
-    struct mixer_ctl *ctl;
-
-    ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
-                                usb_sidetone_volume_str[index]);
-
-    if (ctl == NULL)
-        ALOGV("%s: sidetone gain mixer command is not found",
-              __func__);
-    else if (enable)
-        mixer_ctl_set_value(ctl, 0,
-                            usb_get_sidetone_gain(usb_card_info));
-}
-#endif /* USB_SIDETONE_VOLUME end */
-#endif /* USB_TUNNEL_ENABLED end */
diff --git a/hal/audio_extn/utils.c b/hal/audio_extn/utils.c
index ad4e4b8..0d43e02 100644
--- a/hal/audio_extn/utils.c
+++ b/hal/audio_extn/utils.c
@@ -164,7 +164,6 @@
     STRING_TO_ENUM(AUDIO_FORMAT_DTS_HD),
     STRING_TO_ENUM(AUDIO_FORMAT_DOLBY_TRUEHD),
     STRING_TO_ENUM(AUDIO_FORMAT_IEC61937),
-#ifdef AUDIO_EXTN_FORMATS_ENABLED
     STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),
     STRING_TO_ENUM(AUDIO_FORMAT_WMA),
     STRING_TO_ENUM(AUDIO_FORMAT_WMA_PRO),
@@ -179,7 +178,6 @@
     STRING_TO_ENUM(AUDIO_FORMAT_FLAC),
     STRING_TO_ENUM(AUDIO_FORMAT_ALAC),
     STRING_TO_ENUM(AUDIO_FORMAT_APE),
-    STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),
     STRING_TO_ENUM(AUDIO_FORMAT_AAC_LC),
     STRING_TO_ENUM(AUDIO_FORMAT_AAC_HE_V1),
     STRING_TO_ENUM(AUDIO_FORMAT_AAC_HE_V2),
@@ -193,7 +191,6 @@
     STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM_HE_V1),
     STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM_HE_V2),
     STRING_TO_ENUM(AUDIO_FORMAT_APTX),
-#endif
 };
 
 /* payload structure avt_device drift query */
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index f8c5563..37c749b 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -61,7 +61,6 @@
 #include <cutils/properties.h>
 #include <cutils/atomic.h>
 #include <cutils/sched_policy.h>
-
 #include <hardware/audio_effect.h>
 #include <hardware/audio_alsaops.h>
 #include <system/thread_defs.h>
@@ -75,6 +74,7 @@
 #include "audio_extn.h"
 #include "voice_extn.h"
 #include "ip_hdlr_intf.h"
+#include "audio_feature_manager.h"
 
 #include "sound/compress_params.h"
 #include "sound/asound.h"
@@ -103,13 +103,11 @@
 #define PROXY_OPEN_RETRY_COUNT           100
 #define PROXY_OPEN_WAIT_TIME             20
 
-#ifndef USE_DEEP_AS_PRIMARY_OUTPUT
-#define USECASE_AUDIO_PLAYBACK_PRIMARY USECASE_AUDIO_PLAYBACK_LOW_LATENCY
-#define PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY pcm_config_low_latency
-#else
-#define USECASE_AUDIO_PLAYBACK_PRIMARY USECASE_AUDIO_PLAYBACK_DEEP_BUFFER
-#define PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY pcm_config_deep_buffer
-#endif
+#define GET_USECASE_AUDIO_PLAYBACK_PRIMARY(db) \
+         (db)? USECASE_AUDIO_PLAYBACK_DEEP_BUFFER : \
+               USECASE_AUDIO_PLAYBACK_LOW_LATENCY
+#define GET_PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY(db) \
+         (db)? pcm_config_deep_buffer : pcm_config_low_latency
 
 #define ULL_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
 #define DEFAULT_VOIP_BUF_DURATION_MS 20
@@ -683,8 +681,7 @@
      return ret_val;
 }
 
-#ifdef MAXXAUDIO_QDSP_ENABLED
-bool audio_hw_send_ma_parameter(int stream_type, float vol, bool active)
+bool audio_hw_send_qdsp_parameter(int stream_type, float vol, bool active)
 {
     bool ret = false;
     ALOGV("%s: enter ...", __func__);
@@ -693,7 +690,7 @@
 
     if (adev != NULL && adev->platform != NULL) {
         pthread_mutex_lock(&adev->lock);
-        ret = audio_extn_ma_set_state(adev, stream_type, vol, active);
+        ret = audio_extn_qdsp_set_state(adev, stream_type, vol, active);
         pthread_mutex_unlock(&adev->lock);
     }
 
@@ -702,9 +699,6 @@
     ALOGV("%s: exit with ret %d", __func__, ret);
     return ret;
 }
-#else
-#define audio_hw_send_ma_parameter(stream_type, vol, active) (0)
-#endif
 
 static bool is_supported_format(audio_format_t format)
 {
@@ -880,7 +874,6 @@
     }
 }
 
-#ifdef DYNAMIC_ECNS_ENABLED
 static int send_effect_enable_disable_mixer_ctl(struct audio_device *adev,
                           struct audio_effect_config effect_config,
                           unsigned int param_value)
@@ -941,13 +934,16 @@
 }
 
 static int enable_disable_effect(struct audio_device *adev, int effect_type, bool enable)
-{
+{ 
     struct audio_effect_config effect_config;
     struct audio_usecase *usecase = NULL;
     int ret = 0;
     unsigned int param_value = 0;
     struct stream_in *in = adev->active_input;
 
+    if(!voice_extn_is_dynamic_ecns_enabled())
+        return ENOSYS;
+
     if (!in) {
         ALOGE("%s: Invalid input stream", __func__);
         return -EINVAL;
@@ -989,6 +985,8 @@
 
 static void check_and_enable_effect(struct audio_device *adev)
 {
+    if(!voice_extn_is_dynamic_ecns_enabled())
+        return;
 
     if (adev->active_input->enable_aec) {
         enable_disable_effect(adev, EFFECT_AEC, true);
@@ -999,10 +997,6 @@
         enable_disable_effect(adev, EFFECT_NS, true);
     }
 }
-#else
-#define enable_disable_effect(x, y, z) ENOSYS
-#define check_and_enable_effect(x) ENOSYS
-#endif
 
 int pcm_ioctl(struct pcm *pcm, int request, ...)
 {
@@ -2417,7 +2411,7 @@
     }
     enable_audio_route(adev, usecase);
 
-    audio_extn_ma_set_device(usecase);
+    audio_extn_qdsp_set_device(usecase);
 
     /* If input stream is already running then effect needs to be
        applied on the new input device that's being enabled here.  */
@@ -2892,7 +2886,7 @@
     int ret = 0;
 
     setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
-    set_sched_policy(0, SP_FOREGROUND);
+    //set_sched_policy(0, SP_FOREGROUND);
     prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
 
     ALOGV("%s", __func__);
@@ -4875,7 +4869,7 @@
             out->send_new_metadata = 0;
             if (out->send_next_track_params && out->is_compr_metadata_avail) {
                 ALOGD("copl(%p):send next track params in gapless", out);
-                compress_set_next_track_param(out->compr, &(out->compr_config.codec->options));
+                // compress_set_next_track_param(out->compr, &(out->compr_config.codec->options));
                 out->send_next_track_params = false;
                 out->is_compr_metadata_avail = false;
             }
@@ -4970,9 +4964,8 @@
                      __func__, frames, frame_size, bytes_to_write);
 
             if (out->usecase == USECASE_INCALL_MUSIC_UPLINK ||
-#ifndef COMPRESS_VOIP_ENABLED
-                out->usecase == USECASE_AUDIO_PLAYBACK_VOIP ||
-#endif
+                (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP
+                    && !voice_extn_is_compress_voip_supported()) ||
                 out->usecase == USECASE_INCALL_MUSIC_UPLINK2) {
                 size_t channel_count = audio_channel_count_from_out_mask(out->channel_mask);
                 int16_t *src = (int16_t *)buffer;
@@ -6309,6 +6302,8 @@
     bool is_usb_dev = audio_is_usb_out_device(devices) &&
                       (devices != AUDIO_DEVICE_OUT_USB_ACCESSORY);
     bool direct_dev = is_hdmi || is_usb_dev;
+    bool use_db_as_primary =
+                audio_feature_manager_is_feature_enabled(USE_DEEP_AS_PRIMARY_OUTPUT);
 
     if (is_usb_dev && (!audio_extn_usb_connected(NULL))) {
         is_usb_dev = false;
@@ -6444,31 +6439,32 @@
         out->config.format = pcm_format_from_audio_format(out->format);
     }
 
-    /* Init use case and pcm_config */
-#ifndef COMPRESS_VOIP_ENABLED
-    if (out->flags == (AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP_RX) &&
-        (out->sample_rate == 8000 || out->sample_rate == 16000 ||
-         out->sample_rate == 32000 || out->sample_rate == 48000)) {
-        //FIXME: add support for MONO stream configuration when audioflinger mixer supports it
-        out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
-        out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
-        out->format = AUDIO_FORMAT_PCM_16_BIT;
+    /* Check for VOIP usecase */
+    if(out->flags == (AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP_RX)) {
+        if (!voice_extn_is_compress_voip_supported()) {
+            if (out->sample_rate == 8000 || out->sample_rate == 16000 ||
+             out->sample_rate == 32000 || out->sample_rate == 48000) {
+                //FIXME: add support for MONO stream configuration when audioflinger mixer supports it
+                out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
+                out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
+                out->format = AUDIO_FORMAT_PCM_16_BIT;
 
-        out->config = default_pcm_config_voip_copp;
-        out->config.period_size = VOIP_IO_BUF_SIZE(out->sample_rate, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
-        out->config.rate = out->sample_rate;
-
-#else
-    if ((out->dev->mode == AUDIO_MODE_IN_COMMUNICATION || voice_extn_compress_voip_is_active(out->dev)) &&
-               (out->flags == (AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP_RX)) &&
-               (voice_extn_compress_voip_is_config_supported(config))) {
-        ret = voice_extn_compress_voip_open_output_stream(out);
-        if (ret != 0) {
-            ALOGE("%s: Compress voip output cannot be opened, error:%d",
-                  __func__, ret);
-            goto error_open;
+                out->config = default_pcm_config_voip_copp;
+                out->config.period_size = VOIP_IO_BUF_SIZE(out->sample_rate, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
+                out->config.rate = out->sample_rate;
+            }
+        } else {
+                if ((out->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
+                    voice_extn_compress_voip_is_active(out->dev)) &&
+                       (voice_extn_compress_voip_is_config_supported(config))) {
+                    ret = voice_extn_compress_voip_open_output_stream(out);
+                    if (ret != 0) {
+                        ALOGE("%s: Compress voip output cannot be opened, error:%d",
+                              __func__, ret);
+                        goto error_open;
+                    }
+                }
         }
-#endif
     } else if (audio_is_linear_pcm(out->format) &&
         out->flags == AUDIO_OUTPUT_FLAG_NONE && is_usb_dev) {
         out->channel_mask = config->channel_mask;
@@ -6900,8 +6896,8 @@
             out->config = pcm_config_deep_buffer;
         } else {
             /* primary path is the default path selected if no other outputs are available/suitable */
-            out->usecase = USECASE_AUDIO_PLAYBACK_PRIMARY;
-            out->config = PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY;
+            out->usecase = GET_USECASE_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary);
+            out->config = GET_PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary);
         }
         out->hal_ip_format = format = out->format;
         out->config.format = hal_format_to_pcm(out->hal_ip_format);
@@ -6936,7 +6932,7 @@
                                                 devices, out->flags, out->hal_op_format, out->sample_rate,
                                                 out->bit_width, out->channel_mask, out->profile,
                                                 &out->app_type_cfg);
-    if ((out->usecase == USECASE_AUDIO_PLAYBACK_PRIMARY) ||
+    if ((out->usecase == GET_USECASE_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary)) ||
         (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
         /* Ensure the default output is not selected twice */
         if(adev->primary_output == NULL)
@@ -7271,7 +7267,7 @@
     }
 
     audio_extn_hfp_set_parameters(adev, parms);
-    audio_extn_ma_set_parameters(adev, parms);
+    audio_extn_qdsp_set_parameters(adev, parms);
 
     status = audio_extn_a2dp_set_parameters(parms, &a2dp_reconfig);
     if (ret >= 0 && a2dp_reconfig) {
@@ -7550,36 +7546,36 @@
                        config->sample_rate == 48000);
     bool valid_ch = audio_channel_count_from_in_mask(in->channel_mask) == 1;
 
-#ifndef COMPRESS_VOIP_ENABLED
-    if (valid_rate && valid_ch &&
+    if(!voice_extn_is_compress_voip_supported()) {
+        if (valid_rate && valid_ch &&
         in->dev->mode == AUDIO_MODE_IN_COMMUNICATION) {
         in->usecase = USECASE_AUDIO_RECORD_VOIP;
         in->config = default_pcm_config_voip_copp;
         in->config.period_size = VOIP_IO_BUF_SIZE(in->sample_rate,
                                                   DEFAULT_VOIP_BUF_DURATION_MS,
                                                   DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
-    } else {
-        ALOGW("%s No valid input in voip, use defaults"
-               "sample rate %u, channel mask 0x%X",
-               __func__, config->sample_rate, in->channel_mask);
-    }
-    in->config.rate = config->sample_rate;
-    in->sample_rate = config->sample_rate;
-#else
-    //XXX needed for voice_extn_compress_voip_open_input_stream
-    in->config.rate = config->sample_rate;
-    if ((in->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
-         voice_extn_compress_voip_is_active(in->dev)) &&
-        (voice_extn_compress_voip_is_format_supported(in->format)) &&
-        valid_rate && valid_ch) {
-        voice_extn_compress_voip_open_input_stream(in);
-        // update rate entries to match config from AF
+        } else {
+            ALOGW("%s No valid input in voip, use defaults"
+                   "sample rate %u, channel mask 0x%X",
+                   __func__, config->sample_rate, in->channel_mask);
+        }
         in->config.rate = config->sample_rate;
         in->sample_rate = config->sample_rate;
     } else {
-        ALOGW("%s compress voip not active, use defaults", __func__);
+        //XXX needed for voice_extn_compress_voip_open_input_stream
+        in->config.rate = config->sample_rate;
+        if ((in->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
+             voice_extn_compress_voip_is_active(in->dev)) &&
+            (voice_extn_compress_voip_is_format_supported(in->format)) &&
+            valid_rate && valid_ch) {
+            voice_extn_compress_voip_open_input_stream(in);
+            // update rate entries to match config from AF
+            in->config.rate = config->sample_rate;
+            in->sample_rate = config->sample_rate;
+        } else {
+            ALOGW("%s compress voip not active, use defaults", __func__);
+        }
     }
-#endif
     return 0;
 }
 
@@ -8197,7 +8193,7 @@
         audio_extn_snd_mon_unregister_listener(adev);
         audio_extn_sound_trigger_deinit(adev);
         audio_extn_listen_deinit(adev);
-        audio_extn_ma_deinit();
+        audio_extn_qdsp_deinit();
         audio_extn_extspk_deinit(adev->extspk);
         audio_extn_utils_release_streams_cfg_lists(
                       &adev->streams_output_cfg_list,
@@ -8496,6 +8492,7 @@
         }
     }
     audio_extn_init(adev);
+    voice_extn_init(adev);
     audio_extn_listen_init(adev, adev->snd_card);
     audio_extn_gef_init(adev);
     audio_extn_hw_loopback_init(adev);
@@ -8613,7 +8610,7 @@
         ALOGV("new period_multiplier = %d", af_period_multiplier);
     }
 
-    audio_extn_ma_init(adev->platform);
+    audio_extn_qdsp_init(adev->platform);
 
     adev->multi_offload_enable = property_get_bool("vendor.audio.offload.multiple.enabled", false);
     pthread_mutex_unlock(&adev_init_lock);
diff --git a/hal/msm8916/platform.c b/hal/msm8916/platform.c
index eb2cecc..d5ae0fb 100644
--- a/hal/msm8916/platform.c
+++ b/hal/msm8916/platform.c
@@ -4044,26 +4044,27 @@
          return my_data->ext_disp_type;
     }
 
-#ifdef DISPLAY_PORT_ENABLED
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    char *mixer_ctl_name = "External Display Type";
+    if (audio_extn_is_display_port_enabled()) {
+        struct audio_device *adev = my_data->adev;
+        struct mixer_ctl *ctl;
+        char *mixer_ctl_name = "External Display Type";
 
-    ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-    if (!ctl) {
-        ALOGE("%s: Could not get ctl for mixer cmd - %s",
-              __func__, mixer_ctl_name);
-        return -EINVAL;
+        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+        if (!ctl) {
+            ALOGE("%s: Could not get ctl for mixer cmd - %s",
+                  __func__, mixer_ctl_name);
+            return -EINVAL;
+        }
+
+        disp_type = mixer_ctl_get_value(ctl, 0);
+        if (disp_type == EXT_DISPLAY_TYPE_NONE) {
+             ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
+             return -EINVAL;
+        }
+    }else {
+            disp_type = EXT_DISPLAY_TYPE_HDMI;
     }
 
-    disp_type = mixer_ctl_get_value(ctl, 0);
-    if (disp_type == EXT_DISPLAY_TYPE_NONE) {
-         ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
-         return -EINVAL;
-    }
-#else
-    disp_type = EXT_DISPLAY_TYPE_HDMI;
-#endif
     my_data->ext_disp_type = disp_type;
     ALOGD("%s: ext disp type:%s", __func__, (disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
     return disp_type;
@@ -4395,8 +4396,7 @@
     return snd_device;
 }
 
-#ifdef DYNAMIC_ECNS_ENABLED
-static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+static snd_device_t get_snd_device_for_voice_comm_ecns_enabled(struct platform_data *my_data,
                                                   audio_devices_t out_device,
                                                   audio_devices_t in_device)
 {
@@ -4435,8 +4435,8 @@
 
     return snd_device;
 }
-#else
-static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+
+static snd_device_t get_snd_device_for_voice_comm_ecns_disabled(struct platform_data *my_data,
                                                   audio_devices_t out_device,
                                                   audio_devices_t in_device)
 {
@@ -4543,7 +4543,16 @@
 
     return snd_device;
 }
-#endif //DYNAMIC_ECNS_ENABLED
+
+static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+                                                  audio_devices_t out_device,
+                                                  audio_devices_t in_device)
+{
+    if(voice_extn_is_dynamic_ecns_enabled())
+        return get_snd_device_for_voice_comm_ecns_enabled(my_data, out_device, in_device);
+    else
+        return get_snd_device_for_voice_comm_ecns_disabled(my_data, out_device, in_device);
+}
 
 snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
 {
@@ -6206,17 +6215,17 @@
         max_supported_channels = platform_edid_get_max_channels(my_data);
 
         //Check EDID info for supported samplerate
-        if (!edid_is_supported_sr(edid_info,sample_rate)) {
+        if (!audio_extn_edid_is_supported_sr(edid_info,sample_rate)) {
             //check to see if current BE sample rate is supported by EDID
             //else assign the highest sample rate supported by EDID
-            if (edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
+            if (audio_extn_edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
                 sample_rate = my_data->current_backend_cfg[backend_idx].sample_rate;
             else
-                sample_rate = edid_get_highest_supported_sr(edid_info);
+                sample_rate = audio_extn_edid_get_highest_supported_sr(edid_info);
         }
 
         //Check EDID info for supported bit width
-        if (!edid_is_supported_bps(edid_info,bit_width)) {
+        if (!audio_extn_edid_is_supported_bps(edid_info,bit_width)) {
             //reset to current sample rate
             bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
         }
@@ -7211,7 +7220,7 @@
     edid_data[0] = count;
     memcpy(&edid_data[1], block, count);
 
-    if (!edid_get_sink_caps(info, edid_data)) {
+    if (!audio_extn_edid_get_sink_caps(info, edid_data)) {
         ALOGE("%s: Failed to get extn disp sink capabilities", __func__);
         goto fail;
     }
@@ -7420,7 +7429,7 @@
     ret = platform_get_edid_info(platform);
     info = (edid_audio_info *)my_data->edid_info;
     if (ret == 0 && info != NULL) {
-        return edid_is_supported_sr(info, sample_rate);
+        return audio_extn_edid_is_supported_sr(info, sample_rate);
     }
 
     return false;
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 37eae22..329da7b 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -1477,10 +1477,10 @@
     }
 
     if (enable) {
-#ifndef COMPRESS_VOIP_ENABLED
-        if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
-            strlcat(ec_ref_mixer_path, "-voip", MIXER_PATH_MAX_LENGTH);
-#endif
+        if (!voice_extn_is_compress_voip_supported()) {
+            if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
+                strlcat(ec_ref_mixer_path, "-voip", MIXER_PATH_MAX_LENGTH);    
+        }        
         /*
          * If native audio device reference count > 0, then apply codec EC otherwise
          * fallback to Speakers with VBat if enabled or default
@@ -4473,27 +4473,26 @@
          return my_data->ext_disp_type;
     }
 
-#ifdef DISPLAY_PORT_ENABLED
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    char *mixer_ctl_name = "External Display Type";
+    if (audio_extn_is_display_port_enabled()) {
+        struct audio_device *adev = my_data->adev;
+        struct mixer_ctl *ctl;
+        char *mixer_ctl_name = "External Display Type";
 
-    ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-    if (!ctl) {
-        ALOGE("%s: Could not get ctl for mixer cmd - %s",
-              __func__, mixer_ctl_name);
-        return -EINVAL;
+        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+        if (!ctl) {
+            ALOGE("%s: Could not get ctl for mixer cmd - %s",
+                  __func__, mixer_ctl_name);
+            return -EINVAL;
+        }
+
+        disp_type = mixer_ctl_get_value(ctl, 0);
+        if (disp_type == EXT_DISPLAY_TYPE_NONE) {
+             ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
+             return -EINVAL;
+        }
+    } else {
+        disp_type = EXT_DISPLAY_TYPE_HDMI;
     }
-
-    disp_type = mixer_ctl_get_value(ctl, 0);
-    if (disp_type == EXT_DISPLAY_TYPE_NONE) {
-         ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
-         return -EINVAL;
-    }
-#else
-    disp_type = EXT_DISPLAY_TYPE_HDMI;
-#endif
-
     my_data->ext_disp_type = disp_type;
     ALOGD("%s: ext disp type:%s", __func__, (disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
     return disp_type;
@@ -4835,7 +4834,7 @@
     } else if (devices &
                 (AUDIO_DEVICE_OUT_USB_DEVICE |
                  AUDIO_DEVICE_OUT_USB_HEADSET)) {
-        if (audio_extn_ma_supported_usb())
+        if (audio_extn_qdsp_supported_usb())
             snd_device = SND_DEVICE_OUT_USB_HEADSET_SPEC;
         else if (audio_extn_usb_is_capture_supported())
             snd_device = SND_DEVICE_OUT_USB_HEADSET;
@@ -4862,8 +4861,7 @@
     return snd_device;
 }
 
-#ifdef DYNAMIC_ECNS_ENABLED
-static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+static snd_device_t get_snd_device_for_voice_comm_ecns_enabled(struct platform_data *my_data,
                                                   audio_devices_t out_device,
                                                   audio_devices_t in_device)
 {
@@ -4906,8 +4904,8 @@
 
     return snd_device;
 }
-#else
-static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+
+static snd_device_t get_snd_device_for_voice_comm_ecns_disabled(struct platform_data *my_data,
                                                   audio_devices_t out_device,
                                                   audio_devices_t in_device)
 {
@@ -5032,7 +5030,16 @@
 
     return snd_device;
 }
-#endif //DYNAMIC_ECNS_ENABLED
+
+static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
+                                                  audio_devices_t out_device,
+                                                  audio_devices_t in_device)
+{
+    if(voice_extn_is_dynamic_ecns_enabled())
+        return get_snd_device_for_voice_comm_ecns_enabled(my_data, out_device, in_device);
+    else
+        return get_snd_device_for_voice_comm_ecns_disabled(my_data, out_device, in_device);
+}
 
 snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
 {
@@ -7098,17 +7105,17 @@
         max_supported_channels = platform_edid_get_max_channels(my_data);
 
         //Check EDID info for supported samplerate
-        if (!edid_is_supported_sr(edid_info,sample_rate)) {
+        if (!audio_extn_edid_is_supported_sr(edid_info,sample_rate)) {
             //check to see if current BE sample rate is supported by EDID
             //else assign the highest sample rate supported by EDID
-            if (edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
+            if (audio_extn_edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
                 sample_rate = my_data->current_backend_cfg[backend_idx].sample_rate;
             else
-                sample_rate = edid_get_highest_supported_sr(edid_info);
+                sample_rate = audio_extn_edid_get_highest_supported_sr(edid_info);
         }
 
         //Check EDID info for supported bit width
-        if (!edid_is_supported_bps(edid_info,bit_width)) {
+        if (!audio_extn_edid_is_supported_bps(edid_info,bit_width)) {
             //reset to current sample rate
             bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
         }
@@ -8128,7 +8135,7 @@
     edid_data[0] = count;
     memcpy(&edid_data[1], block, count);
 
-    if (!edid_get_sink_caps(info, edid_data)) {
+    if (!audio_extn_edid_get_sink_caps(info, edid_data)) {
         ALOGE("%s: Failed to get extn disp sink capabilities", __func__);
         goto fail;
     }
@@ -8433,7 +8440,7 @@
     ret = platform_get_edid_info(platform);
     info = (edid_audio_info *)my_data->edid_info;
     if (ret == 0 && info != NULL) {
-        return edid_is_supported_sr(info, sample_rate);
+        return audio_extn_edid_is_supported_sr(info, sample_rate);
     }
 
     return false;
@@ -8448,7 +8455,7 @@
     ret = platform_get_edid_info(platform);
     info = (edid_audio_info *)my_data->edid_info;
     if (ret == 0 && info != NULL) {
-        return edid_get_highest_supported_sr(info);
+        return audio_extn_edid_get_highest_supported_sr(info);
     }
 
     return 0;
@@ -9423,3 +9430,4 @@
 {
     return -ENOSYS;
 }
+
diff --git a/hal/voice.h b/hal/voice.h
index d257e1b..9612edd 100644
--- a/hal/voice.h
+++ b/hal/voice.h
@@ -23,11 +23,7 @@
 #define BASE_SESS_IDX       0
 #define VOICE_SESS_IDX     (BASE_SESS_IDX)
 
-#ifdef MULTI_VOICE_SESSION_ENABLED
 #define MAX_VOICE_SESSIONS 7
-#else
-#define MAX_VOICE_SESSIONS 1
-#endif
 
 #define BASE_CALL_STATE     1
 #define CALL_INACTIVE       (BASE_CALL_STATE)
diff --git a/hal/voice_extn/compress_voip.c b/hal/voice_extn/compress_voip.c
index 890f508..003a3ed 100644
--- a/hal/voice_extn/compress_voip.c
+++ b/hal/voice_extn/compress_voip.c
@@ -250,6 +250,404 @@
     return 0;
 }
 
+int compress_voip_set_parameters(struct audio_device *adev,
+                                             struct str_parms *parms)
+{
+    char value[32]={0};
+    int ret = 0, err, rate;
+    bool flag;
+    char *kv_pairs = str_parms_to_str(parms);
+
+    ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
+
+    err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_RATE,
+                            value, sizeof(value));
+    if (err >= 0) {
+        rate = atoi(value);
+        voip_set_rate(adev, rate);
+    }
+
+    memset(value, 0, sizeof(value));
+    err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_DTX_MODE,
+                            value, sizeof(value));
+    if (err >= 0) {
+        flag = false;
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_VOIP_TRUE) == 0)
+            flag = true;
+        voip_set_dtx(adev, flag);
+    }
+
+    ALOGV("%s: exit", __func__);
+    free(kv_pairs);
+    return ret;
+}
+
+void compress_voip_get_parameters(struct str_parms *query,
+                                             struct str_parms *reply)
+{
+    int ret;
+    char value[32]={0};
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_OUT_STREAM_COUNT,
+                            value, sizeof(value));
+    if (ret >= 0) {
+        str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_OUT_STREAM_COUNT,
+                          voip_data.out_stream_count);
+    }
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_SAMPLE_RATE,
+                            value, sizeof(value));
+    if (ret >= 0) {
+        str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_SAMPLE_RATE,
+                          voip_data.sample_rate);
+    }
+}
+
+void compress_voip_out_get_parameters(struct stream_out *out,
+                                                 struct str_parms *query,
+                                                 struct str_parms *reply)
+{
+    int ret;
+    char value[32]={0};
+
+    ALOGD("%s: enter", __func__);
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_CHECK, value, sizeof(value));
+
+    if (ret >= 0) {
+        if (out->usecase == USECASE_COMPRESS_VOIP_CALL)
+            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, true);
+        else
+            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, false);
+    }
+
+    ALOGV("%s: exit", __func__);
+}
+
+void compress_voip_in_get_parameters(struct stream_in *in,
+                                                struct str_parms *query,
+                                                struct str_parms *reply)
+{
+    int ret;
+    char value[32]={0};
+    char *kv_pairs = NULL;
+
+    ALOGV("%s: enter", __func__);
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_CHECK, value, sizeof(value));
+
+    if (ret >= 0) {
+        if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
+            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, true);
+        else
+            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, false);
+    }
+
+    kv_pairs = str_parms_to_str(reply);
+    ALOGD_IF(kv_pairs != NULL, "%s: exit: return - %s", __func__, kv_pairs);
+    free(kv_pairs);
+}
+
+int compress_voip_out_get_buffer_size(struct stream_out *out)
+{
+    if (out->config.rate == 48000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_FB;
+    else if (out->config.rate== 32000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_SWB;
+    else if (out->config.rate == 16000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_WB;
+    else
+        return COMPRESS_VOIP_IO_BUF_SIZE_NB;
+
+}
+
+int compress_voip_in_get_buffer_size(struct stream_in *in)
+{
+    if (in->config.rate == 48000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_FB;
+    else if (in->config.rate== 32000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_SWB;
+    else if (in->config.rate == 16000)
+        return COMPRESS_VOIP_IO_BUF_SIZE_WB;
+    else
+        return COMPRESS_VOIP_IO_BUF_SIZE_NB;
+}
+
+int compress_voip_open_output_stream(struct stream_out *out)
+{
+    int ret;
+
+    ALOGD("%s: enter", __func__);
+
+    out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_MONO;
+    out->channel_mask = AUDIO_CHANNEL_OUT_MONO;
+    out->usecase = USECASE_COMPRESS_VOIP_CALL;
+    if (out->sample_rate == 48000)
+        out->config = pcm_config_voip_fb;
+    else if (out->sample_rate == 32000)
+        out->config = pcm_config_voip_swb;
+    else if (out->sample_rate == 16000)
+        out->config = pcm_config_voip_wb;
+    else
+        out->config = pcm_config_voip_nb;
+
+    voip_data.out_stream = out;
+    voip_data.out_stream_count++;
+    voip_data.sample_rate = out->sample_rate;
+    ret = voip_set_mode(out->dev, out->format);
+
+    ALOGV("%s: exit", __func__);
+    return ret;
+}
+
+int compress_voip_open_input_stream(struct stream_in *in)
+{
+    int ret;
+
+    ALOGD("%s: enter", __func__);
+
+    if ((voip_data.sample_rate != 0) &&
+        (voip_data.sample_rate != in->config.rate)) {
+        ret = -ENOTSUP;
+        goto done;
+    } else {
+        voip_data.sample_rate = in->config.rate;
+    }
+
+    ret = voip_set_mode(in->dev, in->format);
+    if (ret < 0)
+        goto done;
+
+    in->usecase = USECASE_COMPRESS_VOIP_CALL;
+    if (in->config.rate == 48000)
+        in->config = pcm_config_voip_fb;
+    else if (in->config.rate == 32000)
+        in->config = pcm_config_voip_swb;
+    else if (in->config.rate == 16000)
+        in->config = pcm_config_voip_wb;
+    else
+        in->config = pcm_config_voip_nb;
+
+    voip_data.in_stream_count++;
+
+done:
+    ALOGV("%s: exit, ret=%d", __func__, ret);
+    return ret;
+}
+
+int compress_voip_start_output_stream(struct stream_out *out)
+{
+    int ret = 0;
+    struct audio_device *adev = out->dev;
+    struct audio_usecase *uc_info;
+
+    ALOGD("%s: enter", __func__);
+
+    if (CARD_STATUS_OFFLINE == out->card_status ||
+        CARD_STATUS_OFFLINE == adev->card_status) {
+        ret = -ENETRESET;
+        ALOGE("%s: sound card is not active/SSR returning error %d ", __func__, ret);
+        goto error;
+    }
+
+    if (out->devices & AUDIO_DEVICE_OUT_ALL_SCO) {
+         if (!adev->bt_sco_on) {
+             ALOGE("%s: SCO profile is not ready, return error", __func__);
+             ret = -EAGAIN;
+             goto error;
+         }
+    }
+
+    if (!voip_data.out_stream_count)
+        ret = compress_voip_open_output_stream(out);
+
+    ret = voip_start_call(adev, &out->config);
+    out->pcm = voip_data.pcm_rx;
+    uc_info = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
+    if (uc_info) {
+        uc_info->stream.out = out;
+        uc_info->devices = out->devices;
+    } else {
+        ret = -EINVAL;
+        ALOGE("%s: exit(%d): failed to get use case info", __func__, ret);
+        goto error;
+    }
+
+error:
+    ALOGV("%s: exit: status(%d)", __func__, ret);
+    return ret;
+}
+
+int compress_voip_start_input_stream(struct stream_in *in)
+{
+    int ret = 0;
+    struct audio_device *adev = in->dev;
+
+    ALOGD("%s: enter", __func__);
+
+    if (CARD_STATUS_OFFLINE == in->card_status ||
+        CARD_STATUS_OFFLINE == adev->card_status) {
+        ret = -ENETRESET;
+        ALOGE("%s: sound card is not active/SSR returning error %d ", __func__, ret);
+        goto error;
+    }
+
+    if (audio_is_bluetooth_sco_device(in->device) && !adev->bt_sco_on) {
+        ret = -EIO;
+        ALOGE("%s SCO is not ready return error %d", __func__,ret);
+        goto error;
+    }
+
+    if (!voip_data.in_stream_count)
+        ret = compress_voip_open_input_stream(in);
+
+    adev->active_input = in;
+    ret = voip_start_call(adev, &in->config);
+    in->pcm = voip_data.pcm_tx;
+
+error:
+    ALOGV("%s: exit: status(%d)", __func__, ret);
+    return ret;
+}
+
+int compress_voip_close_output_stream(struct audio_stream *stream)
+{
+    struct stream_out *out = (struct stream_out *)stream;
+    struct audio_device *adev = out->dev;
+    int ret = 0;
+
+    ALOGD("%s: enter", __func__);
+    if (voip_data.out_stream_count > 0) {
+        voip_data.out_stream_count--;
+        ret = voip_stop_call(adev);
+        voip_data.out_stream = NULL;
+        out->pcm = NULL;
+    }
+
+    ALOGV("%s: exit: status(%d)", __func__, ret);
+    return ret;
+}
+
+int compress_voip_close_input_stream(struct audio_stream *stream)
+{
+    struct stream_in *in = (struct stream_in *)stream;
+    struct audio_device *adev = in->dev;
+    int status = 0;
+
+    ALOGD("%s: enter", __func__);
+
+    if(voip_data.in_stream_count > 0) {
+       voip_data.in_stream_count--;
+       status = voip_stop_call(adev);
+       adev->active_input = get_next_active_input(adev);
+       in->pcm = NULL;
+    }
+
+    ALOGV("%s: exit: status(%d)", __func__, status);
+    return status;
+}
+
+
+int compress_voip_set_volume(struct audio_device *adev, float volume)
+{
+    int vol, err = 0;
+
+    ALOGV("%s: enter", __func__);
+
+    if (volume < 0.0) {
+        volume = 0.0;
+    } else if (volume > 1.0) {
+        volume = 1.0;
+    }
+
+    vol = lrint(volume * 100.0);
+
+    /* Voice volume levels from android are mapped to driver volume levels as follows.
+     * 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
+     * So adjust the volume to get the correct volume index in driver
+     */
+    vol = 100 - vol;
+
+    err = voip_set_volume(adev, vol);
+
+    ALOGV("%s: exit: status(%d)", __func__, err);
+
+    return err;
+}
+
+int compress_voip_set_mic_mute(struct audio_device *adev, bool state)
+{
+    int err = 0;
+
+    ALOGV("%s: enter", __func__);
+
+    err = voip_set_mic_mute(adev, state);
+
+    ALOGV("%s: exit: status(%d)", __func__, err);
+    return err;
+}
+
+bool compress_voip_pcm_prop_check()
+{
+    char prop_value[PROPERTY_VALUE_MAX] = {0};
+
+    property_get("vendor.voice.path.for.pcm.voip", prop_value, "0");
+    if (!strncmp("true", prop_value, sizeof("true")))
+    {
+        ALOGD("%s: VoIP PCM property is enabled", __func__);
+        return true;
+    }
+    else
+        return false;
+}
+
+bool compress_voip_is_active(const struct audio_device *adev)
+{
+    struct audio_usecase *voip_usecase = NULL;
+    voip_usecase = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
+
+    if (voip_usecase != NULL)
+        return true;
+    else
+        return false;
+}
+
+bool compress_voip_is_format_supported(audio_format_t format)
+{
+    if (format == AUDIO_FORMAT_PCM_16_BIT &&
+       compress_voip_pcm_prop_check())
+       return true;
+    else
+       return false;
+}
+
+bool compress_voip_is_config_supported(struct audio_config *config)
+{
+    bool ret = false;
+
+    ret = compress_voip_is_format_supported(config->format);
+    if (ret) {
+        if ((popcount(config->channel_mask) == 1) &&
+            (config->sample_rate == 8000 || config->sample_rate == 16000 ||
+             config->sample_rate == 32000 || config->sample_rate == 48000))
+            ret = ((voip_data.sample_rate == 0) ? true:
+                    (voip_data.sample_rate == config->sample_rate));
+        else
+            ret = false;
+    }
+    return ret;
+}
+
+bool compress_voip_is_started(struct audio_device *adev)
+{
+    bool ret = false;
+    if (compress_voip_is_active(adev) &&
+        voip_data.pcm_tx && voip_data.pcm_rx)
+        ret = true;
+
+    return ret;
+}
+
 static int voip_stop_call(struct audio_device *adev)
 {
     int ret = 0;
@@ -401,7 +799,7 @@
         pcm_start(voip_data.pcm_rx);
 
         voice_set_sidetone(adev, uc_info->out_snd_device, true);
-        voice_extn_compress_voip_set_volume(adev, adev->voice.volume);
+        compress_voip_set_volume(adev, adev->voice.volume);
     } else {
         ALOGV("%s: voip usecase is already enabled", __func__);
         if (voip_data.out_stream)
@@ -418,401 +816,4 @@
 
     ALOGV("%s: exit: status(%d)", __func__, ret);
     return ret;
-}
-
-int voice_extn_compress_voip_set_parameters(struct audio_device *adev,
-                                             struct str_parms *parms)
-{
-    char value[32]={0};
-    int ret = 0, err, rate;
-    bool flag;
-    char *kv_pairs = str_parms_to_str(parms);
-
-    ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
-
-    err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_RATE,
-                            value, sizeof(value));
-    if (err >= 0) {
-        rate = atoi(value);
-        voip_set_rate(adev, rate);
-    }
-
-    memset(value, 0, sizeof(value));
-    err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_DTX_MODE,
-                            value, sizeof(value));
-    if (err >= 0) {
-        flag = false;
-        if (strcmp(value, AUDIO_PARAMETER_VALUE_VOIP_TRUE) == 0)
-            flag = true;
-        voip_set_dtx(adev, flag);
-    }
-
-    ALOGV("%s: exit", __func__);
-    free(kv_pairs);
-    return ret;
-}
-
-void voice_extn_compress_voip_get_parameters(struct str_parms *query,
-                                             struct str_parms *reply)
-{
-    int ret;
-    char value[32]={0};
-
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_OUT_STREAM_COUNT,
-                            value, sizeof(value));
-    if (ret >= 0) {
-        str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_OUT_STREAM_COUNT,
-                          voip_data.out_stream_count);
-    }
-
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_SAMPLE_RATE,
-                            value, sizeof(value));
-    if (ret >= 0) {
-        str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_SAMPLE_RATE,
-                          voip_data.sample_rate);
-    }
-}
-
-void voice_extn_compress_voip_out_get_parameters(struct stream_out *out,
-                                                 struct str_parms *query,
-                                                 struct str_parms *reply)
-{
-    int ret;
-    char value[32]={0};
-
-    ALOGD("%s: enter", __func__);
-
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_CHECK, value, sizeof(value));
-
-    if (ret >= 0) {
-        if (out->usecase == USECASE_COMPRESS_VOIP_CALL)
-            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, true);
-        else
-            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, false);
-    }
-
-    ALOGV("%s: exit", __func__);
-}
-
-void voice_extn_compress_voip_in_get_parameters(struct stream_in *in,
-                                                struct str_parms *query,
-                                                struct str_parms *reply)
-{
-    int ret;
-    char value[32]={0};
-    char *kv_pairs = NULL;
-
-    ALOGV("%s: enter", __func__);
-
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOIP_CHECK, value, sizeof(value));
-
-    if (ret >= 0) {
-        if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
-            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, true);
-        else
-            str_parms_add_int(reply, AUDIO_PARAMETER_KEY_VOIP_CHECK, false);
-    }
-
-    kv_pairs = str_parms_to_str(reply);
-    ALOGD_IF(kv_pairs != NULL, "%s: exit: return - %s", __func__, kv_pairs);
-    free(kv_pairs);
-}
-
-int voice_extn_compress_voip_out_get_buffer_size(struct stream_out *out)
-{
-    if (out->config.rate == 48000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_FB;
-    else if (out->config.rate== 32000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_SWB;
-    else if (out->config.rate == 16000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_WB;
-    else
-        return COMPRESS_VOIP_IO_BUF_SIZE_NB;
-
-}
-
-int voice_extn_compress_voip_in_get_buffer_size(struct stream_in *in)
-{
-    if (in->config.rate == 48000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_FB;
-    else if (in->config.rate== 32000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_SWB;
-    else if (in->config.rate == 16000)
-        return COMPRESS_VOIP_IO_BUF_SIZE_WB;
-    else
-        return COMPRESS_VOIP_IO_BUF_SIZE_NB;
-}
-
-int voice_extn_compress_voip_start_output_stream(struct stream_out *out)
-{
-    int ret = 0;
-    struct audio_device *adev = out->dev;
-    struct audio_usecase *uc_info;
-
-    ALOGD("%s: enter", __func__);
-
-    if (CARD_STATUS_OFFLINE == out->card_status ||
-        CARD_STATUS_OFFLINE == adev->card_status) {
-        ret = -ENETRESET;
-        ALOGE("%s: sound card is not active/SSR returning error %d ", __func__, ret);
-        goto error;
-    }
-
-    if (out->devices & AUDIO_DEVICE_OUT_ALL_SCO) {
-         if (!adev->bt_sco_on) {
-             ALOGE("%s: SCO profile is not ready, return error", __func__);
-             ret = -EAGAIN;
-             goto error;
-         }
-    }
-
-    if (!voip_data.out_stream_count)
-        ret = voice_extn_compress_voip_open_output_stream(out);
-
-    ret = voip_start_call(adev, &out->config);
-    out->pcm = voip_data.pcm_rx;
-    uc_info = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
-    if (uc_info) {
-        uc_info->stream.out = out;
-        uc_info->devices = out->devices;
-    } else {
-        ret = -EINVAL;
-        ALOGE("%s: exit(%d): failed to get use case info", __func__, ret);
-        goto error;
-    }
-
-error:
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-int voice_extn_compress_voip_start_input_stream(struct stream_in *in)
-{
-    int ret = 0;
-    struct audio_device *adev = in->dev;
-
-    ALOGD("%s: enter", __func__);
-
-    if (CARD_STATUS_OFFLINE == in->card_status ||
-        CARD_STATUS_OFFLINE == adev->card_status) {
-        ret = -ENETRESET;
-        ALOGE("%s: sound card is not active/SSR returning error %d ", __func__, ret);
-        goto error;
-    }
-
-    if (audio_is_bluetooth_sco_device(in->device) && !adev->bt_sco_on) {
-        ret = -EIO;
-        ALOGE("%s SCO is not ready return error %d", __func__,ret);
-        goto error;
-    }
-
-    if (!voip_data.in_stream_count)
-        ret = voice_extn_compress_voip_open_input_stream(in);
-
-    adev->active_input = in;
-    ret = voip_start_call(adev, &in->config);
-    in->pcm = voip_data.pcm_tx;
-
-error:
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-int voice_extn_compress_voip_close_output_stream(struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    int ret = 0;
-
-    ALOGD("%s: enter", __func__);
-    if (voip_data.out_stream_count > 0) {
-        voip_data.out_stream_count--;
-        ret = voip_stop_call(adev);
-        voip_data.out_stream = NULL;
-        out->pcm = NULL;
-    }
-
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-int voice_extn_compress_voip_open_output_stream(struct stream_out *out)
-{
-    int ret;
-
-    ALOGD("%s: enter", __func__);
-
-    out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_MONO;
-    out->channel_mask = AUDIO_CHANNEL_OUT_MONO;
-    out->usecase = USECASE_COMPRESS_VOIP_CALL;
-    if (out->sample_rate == 48000)
-        out->config = pcm_config_voip_fb;
-    else if (out->sample_rate == 32000)
-        out->config = pcm_config_voip_swb;
-    else if (out->sample_rate == 16000)
-        out->config = pcm_config_voip_wb;
-    else
-        out->config = pcm_config_voip_nb;
-
-    voip_data.out_stream = out;
-    voip_data.out_stream_count++;
-    voip_data.sample_rate = out->sample_rate;
-    ret = voip_set_mode(out->dev, out->format);
-
-    ALOGV("%s: exit", __func__);
-    return ret;
-}
-
-int voice_extn_compress_voip_close_input_stream(struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    struct audio_device *adev = in->dev;
-    int status = 0;
-
-    ALOGD("%s: enter", __func__);
-
-    if(voip_data.in_stream_count > 0) {
-       voip_data.in_stream_count--;
-       status = voip_stop_call(adev);
-       adev->active_input = get_next_active_input(adev);
-       in->pcm = NULL;
-    }
-
-    ALOGV("%s: exit: status(%d)", __func__, status);
-    return status;
-}
-
-int voice_extn_compress_voip_open_input_stream(struct stream_in *in)
-{
-    int ret;
-
-    ALOGD("%s: enter", __func__);
-
-    if ((voip_data.sample_rate != 0) &&
-        (voip_data.sample_rate != in->config.rate)) {
-        ret = -ENOTSUP;
-        goto done;
-    } else {
-        voip_data.sample_rate = in->config.rate;
-    }
-
-    ret = voip_set_mode(in->dev, in->format);
-    if (ret < 0)
-        goto done;
-
-    in->usecase = USECASE_COMPRESS_VOIP_CALL;
-    if (in->config.rate == 48000)
-        in->config = pcm_config_voip_fb;
-    else if (in->config.rate == 32000)
-        in->config = pcm_config_voip_swb;
-    else if (in->config.rate == 16000)
-        in->config = pcm_config_voip_wb;
-    else
-        in->config = pcm_config_voip_nb;
-
-    voip_data.in_stream_count++;
-
-done:
-    ALOGV("%s: exit, ret=%d", __func__, ret);
-    return ret;
-}
-
-int voice_extn_compress_voip_set_volume(struct audio_device *adev, float volume)
-{
-    int vol, err = 0;
-
-    ALOGV("%s: enter", __func__);
-
-    if (volume < 0.0) {
-        volume = 0.0;
-    } else if (volume > 1.0) {
-        volume = 1.0;
-    }
-
-    vol = lrint(volume * 100.0);
-
-    /* Voice volume levels from android are mapped to driver volume levels as follows.
-     * 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
-     * So adjust the volume to get the correct volume index in driver
-     */
-    vol = 100 - vol;
-
-    err = voip_set_volume(adev, vol);
-
-    ALOGV("%s: exit: status(%d)", __func__, err);
-
-    return err;
-}
-
-int voice_extn_compress_voip_set_mic_mute(struct audio_device *adev, bool state)
-{
-    int err = 0;
-
-    ALOGV("%s: enter", __func__);
-
-    err = voip_set_mic_mute(adev, state);
-
-    ALOGV("%s: exit: status(%d)", __func__, err);
-    return err;
-}
-
-bool voice_extn_compress_voip_pcm_prop_check()
-{
-    char prop_value[PROPERTY_VALUE_MAX] = {0};
-
-    property_get("vendor.voice.path.for.pcm.voip", prop_value, "0");
-    if (!strncmp("true", prop_value, sizeof("true")))
-    {
-        ALOGD("%s: VoIP PCM property is enabled", __func__);
-        return true;
-    }
-    else
-        return false;
-}
-
-bool voice_extn_compress_voip_is_active(const struct audio_device *adev)
-{
-    struct audio_usecase *voip_usecase = NULL;
-    voip_usecase = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
-
-    if (voip_usecase != NULL)
-        return true;
-    else
-        return false;
-}
-
-bool voice_extn_compress_voip_is_format_supported(audio_format_t format)
-{
-    if (format == AUDIO_FORMAT_PCM_16_BIT &&
-       voice_extn_compress_voip_pcm_prop_check())
-       return true;
-    else
-       return false;
-}
-
-bool voice_extn_compress_voip_is_config_supported(struct audio_config *config)
-{
-    bool ret = false;
-
-    ret = voice_extn_compress_voip_is_format_supported(config->format);
-    if (ret) {
-        if ((popcount(config->channel_mask) == 1) &&
-            (config->sample_rate == 8000 || config->sample_rate == 16000 ||
-             config->sample_rate == 32000 || config->sample_rate == 48000))
-            ret = ((voip_data.sample_rate == 0) ? true:
-                    (voip_data.sample_rate == config->sample_rate));
-        else
-            ret = false;
-    }
-    return ret;
-}
-
-bool voice_extn_compress_voip_is_started(struct audio_device *adev)
-{
-    bool ret = false;
-    if (voice_extn_compress_voip_is_active(adev) &&
-        voip_data.pcm_tx && voip_data.pcm_rx)
-        ret = true;
-
-    return ret;
-}
+}
\ No newline at end of file
diff --git a/hal/voice_extn/voice_extn.c b/hal/voice_extn/voice_extn.c
index b170608..b6a1879 100644
--- a/hal/voice_extn/voice_extn.c
+++ b/hal/voice_extn/voice_extn.c
@@ -35,6 +35,7 @@
 #include "platform.h"
 #include "platform_api.h"
 #include "voice_extn.h"
+#include "audio_feature_manager.h"
 
 #ifdef DYNAMIC_LOG_ENABLED
 #include <log_xml_parser.h>
@@ -83,8 +84,37 @@
     .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
 };
 
+static bool voice_extn_compress_voip_enabled = false;
+static bool voice_extn_dynamic_ecns_feature_enabled = false;
+
 int voice_extn_is_call_state_active(struct audio_device *adev, bool *is_call_active);
 
+int compress_voip_set_parameters(struct audio_device *adev,
+                                             struct str_parms *parms);
+void compress_voip_get_parameters(struct str_parms *query,
+                                             struct str_parms *reply);
+void compress_voip_out_get_parameters(struct stream_out *out,
+                                                 struct str_parms *query,
+                                                 struct str_parms *reply);
+void compress_voip_in_get_parameters(struct stream_in *in,
+                                                struct str_parms *query,
+                                                struct str_parms *reply);
+int compress_voip_out_get_buffer_size(struct stream_out *out);
+int compress_voip_in_get_buffer_size(struct stream_in *in);
+int compress_voip_start_output_stream(struct stream_out *out);
+int compress_voip_start_input_stream(struct stream_in *in);
+int compress_voip_close_output_stream(struct audio_stream *stream);
+int compress_voip_open_output_stream(struct stream_out *out);
+int compress_voip_close_input_stream(struct audio_stream *stream);
+int compress_voip_open_input_stream(struct stream_in *in);
+int compress_voip_set_volume(struct audio_device *adev, float volume);
+int compress_voip_set_mic_mute(struct audio_device *adev, bool state);
+bool compress_voip_pcm_prop_check();
+bool compress_voip_is_active(const struct audio_device *adev);
+bool compress_voip_is_format_supported(audio_format_t format);
+bool compress_voip_is_config_supported(struct audio_config *config);
+bool compress_voip_is_started(struct audio_device *adev);
+
 static bool is_valid_call_state(int call_state)
 {
     if (call_state < CALL_INACTIVE || call_state > CALL_LOCAL_HOLD)
@@ -360,6 +390,36 @@
     return 0;
 }
 
+void dynamic_ecns_feature_init(bool is_feature_enabled)
+{
+    voice_extn_dynamic_ecns_feature_enabled = is_feature_enabled;
+    ALOGD(":: %s: ---- Feature DYNAMIC_ECNS is %s ----", __func__,
+                            is_feature_enabled? "ENABLED": " NOT ENABLED");
+}
+
+bool voice_extn_is_dynamic_ecns_enabled()
+{
+    return voice_extn_dynamic_ecns_feature_enabled;
+}
+
+void voice_extn_feature_init()
+{
+    for(int index = VOICE_START; index < MAX_SUPPORTED_FEATURE; index++)
+    {
+        bool enable = audio_feature_manager_is_feature_enabled(index);
+        switch (index) {
+            case COMPRESS_VOIP:
+                compr_voip_feature_init(enable);
+                break;
+            case DYNAMIC_ECNS:
+                dynamic_ecns_feature_init(enable);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
 void voice_extn_init(struct audio_device *adev)
 {
     adev->voice.session[VOICE_SESS_IDX].vsid =  VOICE_VSID;
@@ -369,6 +429,18 @@
     adev->voice.session[VOWLAN_SESS_IDX].vsid = VOWLAN_VSID;
     adev->voice.session[MMODE1_SESS_IDX].vsid = VOICEMMODE1_VSID;
     adev->voice.session[MMODE2_SESS_IDX].vsid = VOICEMMODE2_VSID;
+    voice_extn_feature_init();
+}
+
+void compr_voip_feature_init(bool is_feature_enabled)
+{
+    voice_extn_compress_voip_enabled = is_feature_enabled;
+    ALOGD("%s:: ---- Feature COMPRESS_VOIP is %s ----", __func__, is_feature_enabled?"ENABLED":"NOT ENABLED");
+}
+
+bool voice_extn_is_compress_voip_supported()
+{
+    return voice_extn_compress_voip_enabled;
 }
 
 int voice_extn_get_session_from_use_case(struct audio_device *adev,
@@ -576,7 +648,10 @@
         }
         str_parms_add_str(reply, AUDIO_PARAMETER_KEY_ALL_CALL_STATES, value);
     }
-    voice_extn_compress_voip_get_parameters(query, reply);
+    if(voice_extn_compress_voip_enabled)
+        voice_extn_compress_voip_get_parameters(query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
 
     str = str_parms_to_str(reply);
     ALOGV_IF(str != NULL, "%s: exit: returns \"%s\"", __func__, str);
@@ -587,14 +662,21 @@
                                    struct str_parms *query,
                                    struct str_parms *reply)
 {
-    voice_extn_compress_voip_out_get_parameters(out, query, reply);
+    if(voice_extn_compress_voip_enabled)
+        voice_extn_compress_voip_out_get_parameters(out, query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
 }
 
 void voice_extn_in_get_parameters(struct stream_in *in,
                                   struct str_parms *query,
                                   struct str_parms *reply)
 {
-    voice_extn_compress_voip_in_get_parameters(in, query, reply);
+    if(voice_extn_compress_voip_enabled)
+        voice_extn_compress_voip_in_get_parameters(in, query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    
 }
 
 #ifdef INCALL_MUSIC_ENABLED
@@ -612,3 +694,199 @@
     return 0;
 }
 #endif
+
+int voice_extn_compress_voip_set_parameters(struct audio_device *adev,
+                                             struct str_parms *parms) 
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_set_parameters(adev, parms);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+void voice_extn_compress_voip_get_parameters(struct str_parms *query,
+                                             struct str_parms *reply)
+{
+    if(voice_extn_compress_voip_enabled)
+        compress_voip_get_parameters(query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+}
+
+
+void voice_extn_compress_voip_out_get_parameters(struct stream_out *out,
+                                                 struct str_parms *query,
+                                                 struct str_parms *reply)
+{
+    if(voice_extn_compress_voip_enabled)
+        compress_voip_out_get_parameters(out, query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+}
+
+void voice_extn_compress_voip_in_get_parameters(struct stream_in *in,
+                                                struct str_parms *query,
+                                                struct str_parms *reply)
+{
+    if(voice_extn_compress_voip_enabled)
+        compress_voip_in_get_parameters(in, query, reply);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+}
+
+int voice_extn_compress_voip_out_get_buffer_size(struct stream_out *out)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_out_get_buffer_size(out);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+int voice_extn_compress_voip_in_get_buffer_size(struct stream_in *in)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_in_get_buffer_size(in);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+
+int voice_extn_compress_voip_start_output_stream(struct stream_out *out)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_start_output_stream(out);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+
+int voice_extn_compress_voip_start_input_stream(struct stream_in *in)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_start_input_stream(in);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+int voice_extn_compress_voip_close_output_stream(struct audio_stream *stream)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_close_output_stream(stream);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+
+int voice_extn_compress_voip_close_input_stream(struct audio_stream *stream)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_close_input_stream(stream);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+int voice_extn_compress_voip_open_output_stream(struct stream_out *out)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_open_output_stream(out);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+
+int voice_extn_compress_voip_open_input_stream(struct stream_in *in)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_open_input_stream(in);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+int voice_extn_compress_voip_set_volume(struct audio_device *adev, float volume)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_set_volume(adev, volume);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+int voice_extn_compress_voip_set_mic_mute(struct audio_device *adev, bool state)
+{
+    int ret = -1;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_set_mic_mute(adev, state);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+bool voice_extn_compress_voip_pcm_prop_check()
+{
+    bool ret = false;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_pcm_prop_check();
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+bool voice_extn_compress_voip_is_active(const struct audio_device *adev)
+{
+    bool ret = false;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_is_active(adev);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+bool voice_extn_compress_voip_is_format_supported(audio_format_t format)
+{
+    bool ret = false;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_is_format_supported(format);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+bool voice_extn_compress_voip_is_config_supported(struct audio_config *config)
+{
+    bool ret = false;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_is_config_supported(config);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
+bool voice_extn_compress_voip_is_started(struct audio_device *adev)
+{
+    bool ret = false;
+    if(voice_extn_compress_voip_enabled)
+        ret = compress_voip_is_started(adev);
+    else
+        ALOGE("%s: COMPRESS_VOIP feature is not enabled", __func__);
+    return ret;
+}
+
diff --git a/hal/voice_extn/voice_extn.h b/hal/voice_extn/voice_extn.h
index 69ec3b7..51afe47 100644
--- a/hal/voice_extn/voice_extn.h
+++ b/hal/voice_extn/voice_extn.h
@@ -20,13 +20,12 @@
 #ifndef VOICE_EXTN_H
 #define VOICE_EXTN_H
 
-#ifdef MULTI_VOICE_SESSION_ENABLED
+void voice_extn_init(struct audio_device *adev);
 int voice_extn_start_call(struct audio_device *adev);
 int voice_extn_stop_call(struct audio_device *adev);
 int voice_extn_get_session_from_use_case(struct audio_device *adev,
                                          const audio_usecase_t usecase_id,
                                          struct voice_session **session);
-void voice_extn_init(struct audio_device *adev);
 int voice_extn_set_parameters(struct audio_device *adev,
                               struct str_parms *parms);
 void voice_extn_get_parameters(const struct audio_device *adev,
@@ -53,68 +52,9 @@
     return -ENOSYS;
 }
 #endif
-#else
-static int __unused voice_extn_start_call(struct audio_device *adev __unused)
-{
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_stop_call(struct audio_device *adev __unused)
-{
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_get_session_from_use_case(struct audio_device *adev __unused,
-                                                const audio_usecase_t usecase_id __unused,
-                                                struct voice_session **session __unused)
-{
-    return -ENOSYS;
-}
-
-static void __unused voice_extn_init(struct audio_device *adev __unused)
-{
-}
-
-static int __unused voice_extn_set_parameters(struct audio_device *adev __unused,
-                                     struct str_parms *parms __unused)
-{
-    return -ENOSYS;
-}
-
-static void __unused voice_extn_get_parameters(const struct audio_device *adev __unused,
-                                      struct str_parms *query __unused,
-                                      struct str_parms *reply __unused)
-{
-}
-
-static int __unused voice_extn_is_call_state_active(struct audio_device *adev __unused,
-                                           bool *is_call_active __unused)
-{
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_get_active_session_id(struct audio_device *adev __unused,
-                                            uint32_t *session_id __unused)
-{
-    return -ENOSYS;
-}
-
-static void __unused voice_extn_in_get_parameters(struct stream_in *in __unused,
-                                         struct str_parms *query __unused,
-                                         struct str_parms *reply __unused)
-{
-}
-
-static void __unused voice_extn_out_get_parameters(struct stream_out *out __unused,
-                                          struct str_parms *query __unused,
-                                          struct str_parms *reply __unused)
-{
-}
-#endif
 
 int voice_extn_check_and_set_incall_music_usecase(struct audio_device *adev,
                                                   struct stream_out *out);
-#ifdef COMPRESS_VOIP_ENABLED
 int voice_extn_compress_voip_close_output_stream(struct audio_stream *stream);
 int voice_extn_compress_voip_open_output_stream(struct stream_out *out);
 
@@ -148,153 +88,11 @@
 bool voice_extn_compress_voip_is_format_supported(audio_format_t format);
 bool voice_extn_compress_voip_is_config_supported(struct audio_config *config);
 bool voice_extn_compress_voip_is_started(struct audio_device *adev);
-#else
-static int __unused voice_extn_compress_voip_close_output_stream(
-                                     struct audio_stream *stream __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
+void voice_extn_feature_init();
+void compr_voip_feature_init(bool is_feature_enabled);
+bool voice_extn_is_compress_voip_supported();
+void dynamic_ecns_feature_init(bool is_feature_enabled);
+bool voice_extn_is_dynamic_ecns_enabled();
 
-static int __unused voice_extn_compress_voip_open_output_stream(
-                                         struct stream_out *out __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_close_input_stream(
-                                    struct audio_stream *stream __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_open_input_stream(
-                                          struct stream_in *in __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_out_get_buffer_size(
-                                       struct stream_out *stream __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_in_get_buffer_size(
-                                           struct stream_in *in __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_start_input_stream(
-                                           struct stream_in *in __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_start_output_stream(
-                                          struct stream_out *out __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_set_mic_mute(
-                                struct audio_device *adev __unused,
-                                bool state __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return 0;
-}
-
-static int __unused voice_extn_compress_voip_set_volume(
-                              struct audio_device *adev __unused,
-                              float volume __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return 0;
-}
-
-static int __unused voice_extn_compress_voip_select_devices(
-                                  struct audio_device *adev __unused,
-                                  snd_device_t *out_snd_device __unused,
-                                  snd_device_t *in_snd_device __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static int __unused voice_extn_compress_voip_set_parameters(
-                                  struct audio_device *adev __unused,
-                                  struct str_parms *parms __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return -ENOSYS;
-}
-
-static void __unused voice_extn_compress_voip_get_parameters(
-                                     struct str_parms *query __unused,
-                                     struct str_parms *reply __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-}
-
-static void __unused voice_extn_compress_voip_out_get_parameters(
-                                          struct stream_out *out __unused,
-                                          struct str_parms *query __unused,
-                                          struct str_parms *reply __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-}
-
-static void __unused voice_extn_compress_voip_in_get_parameters(
-                                           struct stream_in *in __unused,
-                                           struct str_parms *query __unused,
-                                           struct str_parms *reply __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-}
-
-static bool __unused voice_extn_compress_voip_pcm_prop_check()
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return false;
-}
-
-static bool __unused  voice_extn_compress_voip_is_active(
-                         const struct audio_device *adev __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return false;
-}
-
-static bool __unused voice_extn_compress_voip_is_format_supported(
-                                            audio_format_t format __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return true;
-}
-
-static bool __unused voice_extn_compress_voip_is_config_supported(
-                                      struct audio_config *config __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return true;
-}
-
-static bool __unused voice_extn_compress_voip_is_started(
-                               struct audio_device *adev __unused)
-{
-    ALOGV("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
-    return false;
-}
-
-#endif
 
 #endif //VOICE_EXTN_H
diff --git a/post_proc/Android.mk b/post_proc/Android.mk
index fcaf378..86bbf98 100644
--- a/post_proc/Android.mk
+++ b/post_proc/Android.mk
@@ -3,6 +3,7 @@
 
 include $(CLEAR_VARS)
 
+LOCAL_CFLAGS := -DLIB_AUDIO_HAL="/vendor/lib/hw/audio.primary."$(TARGET_BOARD_PLATFORM)".so"
 LOCAL_CFLAGS += -Wno-unused-variable
 LOCAL_CFLAGS += -Wno-sign-compare
 LOCAL_CFLAGS += -Wno-unused-parameter
@@ -29,17 +30,13 @@
         virtualizer.c \
         reverb.c \
         effect_api.c \
-        effect_util.c
+        effect_util.c \
+        asphere.c
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HW_ACCELERATED_EFFECTS)),true)
-    LOCAL_CFLAGS += -DHW_ACCELERATED_EFFECTS
-    LOCAL_SRC_FILES += hw_accelerator.c
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_AUDIOSPHERE)),true)
-    LOCAL_CFLAGS += -DAUDIOSPHERE_ENABLED
-    LOCAL_SRC_FILES += asphere.c
-endif
+# HW_ACCELERATED has been disabled by default since msm8996. File doesn't
+# compile cleanly on tip so don't want to include it, but keeping this
+# as a reference.
+# LOCAL_SRC_FILES += hw_accelerator.c
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_INSTANCE_ID)), true)
     LOCAL_CFLAGS += -DINSTANCE_ID_ENABLED
@@ -84,7 +81,8 @@
         external/tinyalsa/include \
         $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include \
 	$(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/techpack/audio/include \
-        $(call include-path-for, audio-effects)
+        $(call include-path-for, audio-effects) \
+        vendor/qcom/opensource/audio-hal/primary-hal/hal/audio_extn/
 
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DLKM)),true)
   LOCAL_HEADER_LIBRARIES += audio_kernel_headers
diff --git a/post_proc/Makefile.am b/post_proc/Makefile.am
index 54602a2..bd29473 100644
--- a/post_proc/Makefile.am
+++ b/post_proc/Makefile.am
@@ -20,7 +20,6 @@
 endif
 
 if AUDIOSPHERE
-AM_CFLAGS += -DAUDIOSPHERE_ENABLED
 c_sources += asphere.c
 endif
 
diff --git a/post_proc/asphere.c b/post_proc/asphere.c
index 54555d3..0ff55e5 100644
--- a/post_proc/asphere.c
+++ b/post_proc/asphere.c
@@ -33,6 +33,7 @@
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <dlfcn.h>
 #include <stdbool.h>
 #include <sys/stat.h>
 #include <log/log.h>
@@ -41,6 +42,7 @@
 #include <cutils/properties.h>
 #include <hardware/audio_effect.h>
 #include <pthread.h>
+#include <audio_feature_manager.h>
 #include "bundle.h"
 #include "equalizer.h"
 #include "bass_boost.h"
@@ -56,6 +58,10 @@
 
 #define AUDIO_ASPHERE_EVENT_NODE "/data/misc/audio_pp/event_node"
 
+#define PRIMARY_HAL_PATH XSTR(LIB_AUDIO_HAL)
+#define XSTR(x) STR(x)
+#define STR(x) #x
+
 enum {
     ASPHERE_ACTIVE = 0,
     ASPHERE_SUSPENDED,
@@ -84,6 +90,7 @@
 
 static struct asphere_module asphere;
 pthread_once_t asphere_once = PTHREAD_ONCE_INIT;
+static bool (*is_feature_enabled)(audio_ext_feature);
 
 static int asphere_create_app_notification_node(void)
 {
@@ -162,9 +169,26 @@
 static void asphere_init_once() {
     ALOGD("%s", __func__);
     pthread_mutex_init(&asphere.lock, NULL);
-    asphere.init_status = 1;
-    asphere_get_values_from_mixer();
-    asphere_create_app_notification_node();
+
+    if (access(PRIMARY_HAL_PATH, R_OK) == 0) {
+        void *hal_lib_pointer = dlopen(PRIMARY_HAL_PATH, RTLD_NOW);
+        if (hal_lib_pointer == NULL)
+            ALOGE("%s: DLOPEN failed for %s", __func__, PRIMARY_HAL_PATH);
+        else if ((is_feature_enabled = (bool (*)(audio_ext_feature))dlsym(hal_lib_pointer,
+                                     "audio_feature_manager_is_feature_enable")) != NULL) {
+            if (is_feature_enabled(AUDIOSPHERE)) {
+                asphere.init_status = 1;
+                asphere_get_values_from_mixer();
+                asphere_create_app_notification_node();
+                return;
+            } else
+                ALOGW("%s: asphere feature not enabled", __func__);
+        } else
+            ALOGE("%s: dlsym failed", __func__);
+    } else
+        ALOGE("%s: not able to acces lib %s ", __func__, PRIMARY_HAL_PATH);
+
+    asphere.init_status = 0;
 }
 
 static int asphere_init() {
@@ -179,14 +203,8 @@
     bool enable = false;
     int strength = -1;
     char value[32] = {0};
-    char propValue[PROPERTY_VALUE_MAX] = {0};
     bool set_enable = false, set_strength = false;
 
-    if (!property_get("vendor.audio.pp.asphere.enabled", propValue, "false") ||
-        (strncmp("true", propValue, 4) != 0)) {
-        ALOGV("%s: property not set!!! not doing anything", __func__);
-        return;
-    }
     if (asphere_init() != 1) {
         ALOGW("%s: init check failed!!!", __func__);
         return;
@@ -221,14 +239,8 @@
                                       struct str_parms *reply)
 {
     char value[32] = {0};
-    char propValue[PROPERTY_VALUE_MAX] = {0};
     int ret;
 
-    if (!property_get("vendor.audio.pp.asphere.enabled", propValue, "false") ||
-        (strncmp("true", propValue, 4) != 0)) {
-        ALOGV("%s: property not set!!! not doing anything", __func__);
-        return;
-    }
     if (asphere_init() != 1) {
         ALOGW("%s: init check failed!!!", __func__);
         return;
@@ -278,14 +290,8 @@
                                       struct listnode *created_effects)
 {
     struct listnode *node;
-    char propValue[PROPERTY_VALUE_MAX] = {0};
 
     ALOGV("%s: effect %0x", __func__, context->desc->type.timeLow);
-    if (!property_get("vendor.audio.pp.asphere.enabled", propValue, "false") ||
-        (strncmp("true", propValue, 4) != 0)) {
-        ALOGV("%s: property not set!!! not doing anything", __func__);
-        return;
-    }
     if (asphere_init() != 1) {
         ALOGW("%s: init check failed!!!", __func__);
         return;
diff --git a/post_proc/asphere.h b/post_proc/asphere.h
index d0e6830..3babd1d 100644
--- a/post_proc/asphere.h
+++ b/post_proc/asphere.h
@@ -34,17 +34,11 @@
 #include <cutils/list.h>
 #include "bundle.h"
 
-#ifdef AUDIOSPHERE_ENABLED
 void asphere_get_parameters(struct str_parms *query,
                             struct str_parms *reply);
 void asphere_set_parameters(struct str_parms *reply);
 void handle_asphere_on_effect_enabled(bool enable,
                                       effect_context_t *context,
                                       struct listnode *created_effects);
-#else
-#define asphere_get_parameters(query, reply) (0)
-#define asphere_set_parameters(parms)  (0)
-#define handle_asphere_on_effect_enabled(enable, context, created_effects) (0)
-#endif /* AUDIOSPHERE_ENABLED */
 
 #endif /* OFFLOAD_ASPHERE_H_ */
diff --git a/post_proc/ma_listener.c b/post_proc/ma_listener.c
index 02d45d3..04a9047 100644
--- a/post_proc/ma_listener.c
+++ b/post_proc/ma_listener.c
@@ -42,7 +42,8 @@
                                                             i == AUDIO_STREAM_NOTIFICATION ? "Notification":\
                                                             "--INVALID--"); \
 
-#define MA_SET_STATE "audio_hw_send_ma_parameter"
+
+#define MA_SET_STATE "audio_hw_send_qdsp_parameter"
 #define HAL_VENDOR_PATH "/vendor/lib/hw"
 
 enum {
diff --git a/post_proc/virtualizer.c b/post_proc/virtualizer.c
index 0750052..f8a488f 100644
--- a/post_proc/virtualizer.c
+++ b/post_proc/virtualizer.c
@@ -25,12 +25,21 @@
 #include <tinyalsa/asoundlib.h>
 #include <sound/audio_effects.h>
 #include <audio_effects/effect_virtualizer.h>
+#include <audio_feature_manager.h>
+#include <dlfcn.h>
+#include <unistd.h>
 
 #include "effect_api.h"
 #include "virtualizer.h"
 
 #define VIRUALIZER_MAX_LATENCY 30
 
+#define PRIMARY_HAL_PATH XSTR(LIB_AUDIO_HAL)
+#define XSTR(x) STR(x)
+#define STR(x) #x
+
+static bool (*is_feature_enabled)(audio_ext_feature);
+
 #ifdef AUDIO_FEATURE_ENABLED_GCOV
 extern void  __gcov_flush();
 static void enable_gcov()
@@ -104,13 +113,16 @@
  *  true      device is applicable for effect
  */
 bool virtualizer_is_device_supported(audio_devices_t device) {
+    if (is_feature_enabled != NULL &&
+        is_feature_enabled(AFE_PROXY)) {
+        if (device == AUDIO_DEVICE_OUT_PROXY)
+            return false;
+    }
+
     switch (device) {
     case AUDIO_DEVICE_OUT_SPEAKER:
     case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
     case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER:
-#ifdef AFE_PROXY_ENABLED
-    case AUDIO_DEVICE_OUT_PROXY:
-#endif
     case AUDIO_DEVICE_OUT_AUX_DIGITAL:
     case AUDIO_DEVICE_OUT_USB_ACCESSORY:
     case AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET:
@@ -470,6 +482,20 @@
     ALOGV("%s: ctxt %p", __func__, context);
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
+    if (access(PRIMARY_HAL_PATH, R_OK) == 0) {
+        void *hal_lib_pointer = dlopen(PRIMARY_HAL_PATH, RTLD_NOW);
+        if (hal_lib_pointer == NULL)
+            ALOGE("%s: DLOPEN failed for %s", __func__, PRIMARY_HAL_PATH);
+        else {
+            is_feature_enabled =
+                     (bool (*)(audio_ext_feature))dlsym(hal_lib_pointer,
+                               "audio_feature_manager_is_feature_enable");
+            if (is_feature_enabled == NULL)
+                ALOGE("%s: dlsym failed", __func__);
+        }
+    } else
+        ALOGE("%s: not able to acces lib %s ", __func__, PRIMARY_HAL_PATH);
+
     context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
     context->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
     context->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;