diff --git a/post_proc/Android.mk b/post_proc/Android.mk
index 880838a..be70166 100644
--- a/post_proc/Android.mk
+++ b/post_proc/Android.mk
@@ -26,7 +26,8 @@
 LOCAL_SHARED_LIBRARIES := \
 	libcutils \
 	liblog \
-	libtinyalsa
+	libtinyalsa \
+	libdl
 
 LOCAL_MODULE_TAGS := optional
 
diff --git a/post_proc/bass_boost.c b/post_proc/bass_boost.c
index 57cf8ef..ad1e7c9 100644
--- a/post_proc/bass_boost.c
+++ b/post_proc/bass_boost.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
  * Not a Contribution.
  *
  * Copyright (C) 2013 The Android Open Source Project
@@ -17,14 +17,17 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "offload_effect_bass_boost"
+#define LOG_TAG "offload_effect_bass"
 //#define LOG_NDEBUG 0
 
 #include <cutils/list.h>
 #include <cutils/log.h>
+#include <cutils/properties.h>
 #include <tinyalsa/asoundlib.h>
 #include <sound/audio_effects.h>
 #include <audio_effects/effect_bassboost.h>
+#include <stdlib.h>
+#include <dlfcn.h>
 
 #include "effect_api.h"
 #include "bass_boost.h"
@@ -41,6 +44,243 @@
         "The Android Open Source Project",
 };
 
+#define LIB_ACDB_LOADER "libacdbloader.so"
+#define PBE_CONF_APP_ID 0x00011134
+
+enum {
+        AUDIO_DEVICE_CAL_TYPE = 0,
+        AUDIO_STREAM_CAL_TYPE,
+};
+
+typedef struct acdb_audio_cal_cfg {
+        uint32_t persist;
+        uint32_t snd_dev_id;
+        uint32_t dev_id;
+        int32_t acdb_dev_id;
+        uint32_t app_type;
+        uint32_t topo_id;
+        uint32_t sampling_rate;
+        uint32_t cal_type;
+        uint32_t module_id;
+        uint32_t param_id;
+} acdb_audio_cal_cfg_t;
+
+typedef int (*acdb_get_audio_cal_t) (void *, void *, uint32_t*);
+static int pbe_load_config(struct pbe_params *params);
+
+/*
+ * Bass operations
+ */
+int bass_get_parameter(effect_context_t *context, effect_param_t *p,
+                       uint32_t *size)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+    int32_t *param_tmp = (int32_t *)p->data;
+    int32_t param = *param_tmp++;
+    void *value = p->data + voffset;
+    int i;
+
+    ALOGV("%s", __func__);
+
+    p->status = 0;
+
+    switch (param) {
+    case BASSBOOST_PARAM_STRENGTH_SUPPORTED:
+        if (p->vsize < sizeof(uint32_t))
+           p->status = -EINVAL;
+        p->vsize = sizeof(uint32_t);
+        break;
+    case BASSBOOST_PARAM_STRENGTH:
+        if (p->vsize < sizeof(int16_t))
+           p->status = -EINVAL;
+        p->vsize = sizeof(int16_t);
+        break;
+    default:
+        p->status = -EINVAL;
+    }
+
+    *size = sizeof(effect_param_t) + voffset + p->vsize;
+
+    if (p->status != 0)
+        return 0;
+
+    switch (param) {
+    case BASSBOOST_PARAM_STRENGTH_SUPPORTED:
+        ALOGV("%s: BASSBOOST_PARAM_STRENGTH_SUPPORTED", __func__);
+        if (bass_ctxt->active_index == BASS_BOOST)
+            *(uint32_t *)value = 1;
+        else
+            *(uint32_t *)value = 0;
+        break;
+
+    case BASSBOOST_PARAM_STRENGTH:
+        ALOGV("%s: BASSBOOST_PARAM_STRENGTH", __func__);
+        if (bass_ctxt->active_index == BASS_BOOST)
+            *(int16_t *)value = bassboost_get_strength(&(bass_ctxt->bassboost_ctxt));
+        else
+            *(int16_t *)value = 0;
+        break;
+
+    default:
+        p->status = -EINVAL;
+        break;
+    }
+
+    return 0;
+}
+
+int bass_set_parameter(effect_context_t *context, effect_param_t *p,
+                       uint32_t size __unused)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+    void *value = p->data + voffset;
+    int32_t *param_tmp = (int32_t *)p->data;
+    int32_t param = *param_tmp++;
+    uint32_t strength;
+
+    ALOGV("%s", __func__);
+
+    p->status = 0;
+
+    switch (param) {
+    case BASSBOOST_PARAM_STRENGTH:
+        ALOGV("%s BASSBOOST_PARAM_STRENGTH", __func__);
+        if (bass_ctxt->active_index == BASS_BOOST) {
+            strength = (uint32_t)(*(int16_t *)value);
+            bassboost_set_strength(&(bass_ctxt->bassboost_ctxt), strength);
+        } else {
+            /* stength supported only for BB and not for PBE, but do not
+             * return error for unsupported case, as it fails cts test
+             */
+            ALOGD("%s ignore set strength, index %d",
+                  __func__, bass_ctxt->active_index);
+            break;
+        }
+        break;
+    default:
+        p->status = -EINVAL;
+        break;
+    }
+
+    return 0;
+}
+
+int bass_set_device(effect_context_t *context, uint32_t device)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    if (device == AUDIO_DEVICE_OUT_SPEAKER) {
+        bass_ctxt->active_index = BASS_PBE;
+        ALOGV("%s: set PBE mode, device: %x", __func__, device);
+    } else if (device == AUDIO_DEVICE_OUT_WIRED_HEADSET ||
+        device == AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
+        device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES) {
+        ALOGV("%s: set BB mode, device: %x", __func__, device);
+        bass_ctxt->active_index = BASS_BOOST;
+    } else {
+        ALOGI("%s: disabled by device: %x", __func__, device);
+        bass_ctxt->active_index = BASS_INVALID;
+    }
+
+    bassboost_set_device((effect_context_t *)&(bass_ctxt->bassboost_ctxt), device);
+    pbe_set_device((effect_context_t *)&(bass_ctxt->pbe_ctxt), device);
+
+    return 0;
+}
+
+int bass_reset(effect_context_t *context)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    bassboost_reset((effect_context_t *)&(bass_ctxt->bassboost_ctxt));
+    pbe_reset((effect_context_t *)&(bass_ctxt->pbe_ctxt));
+
+    return 0;
+}
+
+int bass_init(effect_context_t *context)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    // convery i/o channel config to sub effects
+    bass_ctxt->bassboost_ctxt.common.config = context->config;
+    bass_ctxt->pbe_ctxt.common.config = context->config;
+
+    ALOGV("%s", __func__);
+
+    bass_ctxt->active_index = BASS_BOOST;
+
+
+    bassboost_init((effect_context_t *)&(bass_ctxt->bassboost_ctxt));
+    pbe_init((effect_context_t *)&(bass_ctxt->pbe_ctxt));
+
+    return 0;
+}
+
+int bass_enable(effect_context_t *context)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    bassboost_enable((effect_context_t *)&(bass_ctxt->bassboost_ctxt));
+    pbe_enable((effect_context_t *)&(bass_ctxt->pbe_ctxt));
+
+    return 0;
+}
+
+int bass_disable(effect_context_t *context)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    bassboost_disable((effect_context_t *)&(bass_ctxt->bassboost_ctxt));
+    pbe_disable((effect_context_t *)&(bass_ctxt->pbe_ctxt));
+
+    return 0;
+}
+
+int bass_start(effect_context_t *context, output_context_t *output)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    bassboost_start((effect_context_t *)&(bass_ctxt->bassboost_ctxt), output);
+    pbe_start((effect_context_t *)&(bass_ctxt->pbe_ctxt), output);
+
+    return 0;
+}
+
+int bass_stop(effect_context_t *context, output_context_t *output)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    bassboost_stop((effect_context_t *)&(bass_ctxt->bassboost_ctxt), output);
+    pbe_stop((effect_context_t *)&(bass_ctxt->pbe_ctxt), output);
+
+    return 0;
+}
+
+int bass_set_mode(effect_context_t *context,  int32_t hw_acc_fd)
+{
+    bass_context_t *bass_ctxt = (bass_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    bassboost_set_mode((effect_context_t *)&(bass_ctxt->bassboost_ctxt), hw_acc_fd);
+    pbe_set_mode((effect_context_t *)&(bass_ctxt->pbe_ctxt), hw_acc_fd);
+
+    return 0;
+}
+
+#undef LOG_TAG
+#define LOG_TAG "offload_effect_bb"
 /*
  * Bassboost operations
  */
@@ -70,99 +310,30 @@
     return 0;
 }
 
-int bassboost_get_parameter(effect_context_t *context, effect_param_t *p,
-                            uint32_t *size)
-{
-    bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
-    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
-    int32_t *param_tmp = (int32_t *)p->data;
-    int32_t param = *param_tmp++;
-    void *value = p->data + voffset;
-    int i;
-
-    ALOGV("%s: ctxt %p, param %d", __func__, bass_ctxt, param);
-
-    p->status = 0;
-
-    switch (param) {
-    case BASSBOOST_PARAM_STRENGTH_SUPPORTED:
-        if (p->vsize < sizeof(uint32_t))
-           p->status = -EINVAL;
-        p->vsize = sizeof(uint32_t);
-        break;
-    case BASSBOOST_PARAM_STRENGTH:
-        if (p->vsize < sizeof(int16_t))
-           p->status = -EINVAL;
-        p->vsize = sizeof(int16_t);
-        break;
-    default:
-        p->status = -EINVAL;
-    }
-
-    *size = sizeof(effect_param_t) + voffset + p->vsize;
-
-    if (p->status != 0)
-        return 0;
-
-    switch (param) {
-    case BASSBOOST_PARAM_STRENGTH_SUPPORTED:
-        *(uint32_t *)value = 1;
-        break;
-
-    case BASSBOOST_PARAM_STRENGTH:
-        *(int16_t *)value = bassboost_get_strength(bass_ctxt);
-        break;
-
-    default:
-        p->status = -EINVAL;
-        break;
-    }
-
-    return 0;
-}
-
-int bassboost_set_parameter(effect_context_t *context, effect_param_t *p,
-                            uint32_t size __unused)
-{
-    bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
-    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
-    void *value = p->data + voffset;
-    int32_t *param_tmp = (int32_t *)p->data;
-    int32_t param = *param_tmp++;
-    uint32_t strength;
-
-    ALOGV("%s: ctxt %p, param %d", __func__, bass_ctxt, param);
-
-    p->status = 0;
-
-    switch (param) {
-    case BASSBOOST_PARAM_STRENGTH:
-        strength = (uint32_t)(*(int16_t *)value);
-        bassboost_set_strength(bass_ctxt, strength);
-        break;
-    default:
-        p->status = -EINVAL;
-        break;
-    }
-
-    return 0;
-}
-
 int bassboost_set_device(effect_context_t *context, uint32_t device)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
     ALOGV("%s: ctxt %p, device 0x%x", __func__, bass_ctxt, device);
     bass_ctxt->device = device;
-    if((device == AUDIO_DEVICE_OUT_SPEAKER) ||
-       (device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT) ||
-       (device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER) ||
-#ifdef AFE_PROXY_ENABLED
-       (device == AUDIO_DEVICE_OUT_PROXY) ||
-#endif
-       (device == AUDIO_DEVICE_OUT_AUX_DIGITAL) ||
-       (device == AUDIO_DEVICE_OUT_USB_ACCESSORY) ||
-       (device == AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET)) {
+    if (device == AUDIO_DEVICE_OUT_WIRED_HEADSET ||
+        device == AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
+        device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES) {
+        if (bass_ctxt->temp_disabled) {
+            if (effect_is_active(&bass_ctxt->common)) {
+                offload_bassboost_set_enable_flag(&(bass_ctxt->offload_bass), true);
+                if (bass_ctxt->ctl)
+                    offload_bassboost_send_params(bass_ctxt->ctl,
+                                                  &bass_ctxt->offload_bass,
+                                                  OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG);
+                if (bass_ctxt->hw_acc_fd > 0)
+                    hw_acc_bassboost_send_params(bass_ctxt->hw_acc_fd,
+                                                 &bass_ctxt->offload_bass,
+                                                 OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG);
+            }
+            bass_ctxt->temp_disabled = false;
+        }
+    } else {
         if (!bass_ctxt->temp_disabled) {
             if (effect_is_active(&bass_ctxt->common)) {
                 offload_bassboost_set_enable_flag(&(bass_ctxt->offload_bass), false);
@@ -178,21 +349,6 @@
             bass_ctxt->temp_disabled = true;
         }
         ALOGI("%s: ctxt %p, disabled based on device", __func__, bass_ctxt);
-    } else {
-        if (bass_ctxt->temp_disabled) {
-            if (effect_is_active(&bass_ctxt->common)) {
-                offload_bassboost_set_enable_flag(&(bass_ctxt->offload_bass), true);
-                if (bass_ctxt->ctl)
-                    offload_bassboost_send_params(bass_ctxt->ctl,
-                                                  &bass_ctxt->offload_bass,
-                                                  OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG);
-                if (bass_ctxt->hw_acc_fd > 0)
-                    hw_acc_bassboost_send_params(bass_ctxt->hw_acc_fd,
-                                                 &bass_ctxt->offload_bass,
-                                                 OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG);
-            }
-            bass_ctxt->temp_disabled = false;
-        }
     }
     offload_bassboost_set_device(&(bass_ctxt->offload_bass), device);
     return 0;
@@ -329,3 +485,234 @@
                                      OFFLOAD_SEND_BASSBOOST_STRENGTH);
     return 0;
 }
+
+#undef LOG_TAG
+#define LOG_TAG "offload_effect_pbe"
+/*
+ * PBE operations
+ */
+
+int pbe_set_device(effect_context_t *context, uint32_t device)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+    char          propValue[PROPERTY_VALUE_MAX];
+    bool          pbe_enabled_by_prop = false;
+
+    ALOGV("%s: device: %d", __func__, device);
+    pbe_ctxt->device = device;
+
+    if (property_get("audio.safx.pbe.enabled", propValue, NULL)) {
+        pbe_enabled_by_prop = atoi(propValue) ||
+                              !strncmp("true", propValue, 4);
+    }
+
+    if (device == AUDIO_DEVICE_OUT_SPEAKER && pbe_enabled_by_prop == true) {
+        if (pbe_ctxt->temp_disabled) {
+            if (effect_is_active(&pbe_ctxt->common)) {
+                offload_pbe_set_enable_flag(&(pbe_ctxt->offload_pbe), true);
+                if (pbe_ctxt->ctl)
+                    offload_pbe_send_params(pbe_ctxt->ctl,
+                                        &pbe_ctxt->offload_pbe,
+                                        OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                        OFFLOAD_SEND_PBE_CONFIG);
+                if (pbe_ctxt->hw_acc_fd > 0)
+                    hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                                        &pbe_ctxt->offload_pbe,
+                                        OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                        OFFLOAD_SEND_PBE_CONFIG);
+            }
+            pbe_ctxt->temp_disabled = false;
+        }
+    } else {
+        if (!pbe_ctxt->temp_disabled) {
+            if (effect_is_active(&pbe_ctxt->common)) {
+                offload_pbe_set_enable_flag(&(pbe_ctxt->offload_pbe), false);
+                if (pbe_ctxt->ctl)
+                    offload_pbe_send_params(pbe_ctxt->ctl,
+                                        &pbe_ctxt->offload_pbe,
+                                        OFFLOAD_SEND_PBE_ENABLE_FLAG);
+                if (pbe_ctxt->hw_acc_fd > 0)
+                    hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                                        &pbe_ctxt->offload_pbe,
+                                        OFFLOAD_SEND_PBE_ENABLE_FLAG);
+            }
+            pbe_ctxt->temp_disabled = true;
+        }
+    }
+    offload_pbe_set_device(&(pbe_ctxt->offload_pbe), device);
+    return 0;
+}
+
+int pbe_reset(effect_context_t *context)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    return 0;
+}
+
+int pbe_init(effect_context_t *context)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s", __func__);
+    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;
+    context->config.inputCfg.samplingRate = 44100;
+    context->config.inputCfg.bufferProvider.getBuffer = NULL;
+    context->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+    context->config.inputCfg.bufferProvider.cookie = NULL;
+    context->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+    context->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+    context->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
+    context->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+    context->config.outputCfg.samplingRate = 44100;
+    context->config.outputCfg.bufferProvider.getBuffer = NULL;
+    context->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+    context->config.outputCfg.bufferProvider.cookie = NULL;
+    context->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+    set_config(context, &context->config);
+
+    pbe_ctxt->hw_acc_fd = -1;
+    pbe_ctxt->temp_disabled = false;
+    memset(&(pbe_ctxt->offload_pbe), 0, sizeof(struct pbe_params));
+    pbe_load_config(&(pbe_ctxt->offload_pbe));
+
+    return 0;
+}
+
+int pbe_enable(effect_context_t *context)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s", __func__);
+
+    if (!offload_pbe_get_enable_flag(&(pbe_ctxt->offload_pbe)) &&
+        !(pbe_ctxt->temp_disabled)) {
+        offload_pbe_set_enable_flag(&(pbe_ctxt->offload_pbe), true);
+        if (pbe_ctxt->ctl)
+            offload_pbe_send_params(pbe_ctxt->ctl,
+                                    &pbe_ctxt->offload_pbe,
+                                    OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                    OFFLOAD_SEND_PBE_CONFIG);
+        if (pbe_ctxt->hw_acc_fd > 0)
+            hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                                   &pbe_ctxt->offload_pbe,
+                                   OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                   OFFLOAD_SEND_PBE_CONFIG);
+    }
+    return 0;
+}
+
+int pbe_disable(effect_context_t *context)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s", __func__);
+    if (offload_pbe_get_enable_flag(&(pbe_ctxt->offload_pbe))) {
+        offload_pbe_set_enable_flag(&(pbe_ctxt->offload_pbe), false);
+        if (pbe_ctxt->ctl)
+            offload_pbe_send_params(pbe_ctxt->ctl,
+                                    &pbe_ctxt->offload_pbe,
+                                    OFFLOAD_SEND_PBE_ENABLE_FLAG);
+        if (pbe_ctxt->hw_acc_fd > 0)
+            hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                                   &pbe_ctxt->offload_pbe,
+                                   OFFLOAD_SEND_PBE_ENABLE_FLAG);
+    }
+    return 0;
+}
+
+int pbe_start(effect_context_t *context, output_context_t *output)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s", __func__);
+    pbe_ctxt->ctl = output->ctl;
+    ALOGV("output->ctl: %p", output->ctl);
+    if (offload_pbe_get_enable_flag(&(pbe_ctxt->offload_pbe))) {
+        if (pbe_ctxt->ctl)
+            offload_pbe_send_params(pbe_ctxt->ctl, &pbe_ctxt->offload_pbe,
+                                    OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                    OFFLOAD_SEND_PBE_CONFIG);
+        if (pbe_ctxt->hw_acc_fd > 0)
+            hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                                   &pbe_ctxt->offload_pbe,
+                                   OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                                   OFFLOAD_SEND_PBE_CONFIG);
+    }
+    return 0;
+}
+
+int pbe_stop(effect_context_t *context, output_context_t *output  __unused)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s", __func__);
+    pbe_ctxt->ctl = NULL;
+    return 0;
+}
+
+int pbe_set_mode(effect_context_t *context, int32_t hw_acc_fd)
+{
+    pbe_context_t *pbe_ctxt = (pbe_context_t *)context;
+
+    ALOGV("%s: ctxt %p", __func__, pbe_ctxt);
+    pbe_ctxt->hw_acc_fd = hw_acc_fd;
+    if ((pbe_ctxt->hw_acc_fd > 0) &&
+        (offload_pbe_get_enable_flag(&(pbe_ctxt->offload_pbe))))
+        hw_acc_pbe_send_params(pbe_ctxt->hw_acc_fd,
+                               &pbe_ctxt->offload_pbe,
+                               OFFLOAD_SEND_PBE_ENABLE_FLAG |
+                               OFFLOAD_SEND_PBE_CONFIG);
+    return 0;
+}
+
+static int pbe_load_config(struct pbe_params *params)
+{
+    int                  ret = 0;
+    uint32_t             len = 0;
+    uint32_t             propValue = 0;
+    uint32_t             pbe_app_type = PBE_CONF_APP_ID;
+    char                 propValueStr[PROPERTY_VALUE_MAX];
+    void                 *acdb_handle = NULL;
+    acdb_get_audio_cal_t acdb_get_audio_cal = NULL;
+    acdb_audio_cal_cfg_t cal_cfg = {0};
+
+    acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
+    if (acdb_handle == NULL) {
+        ALOGE("%s error opening library %s", __func__, LIB_ACDB_LOADER);
+        return -EFAULT;
+    }
+
+    acdb_get_audio_cal = (acdb_get_audio_cal_t)dlsym(acdb_handle,
+                                  "acdb_loader_get_audio_cal_v2");
+    if (acdb_get_audio_cal == NULL) {
+        dlclose(acdb_handle);
+        ALOGE("%s error resolving acdb func symbols", __func__);
+        return -EFAULT;
+    }
+    if (property_get("audio.safx.pbe.app.type", propValueStr, "0")) {
+        propValue = atoll(propValueStr);
+        if (propValue != 0) {
+            pbe_app_type = propValue;
+        }
+    }
+    ALOGD("%s pbe_app_type = 0x%.8x", __func__, pbe_app_type);
+
+    cal_cfg.persist              = 1;
+    cal_cfg.cal_type             = AUDIO_STREAM_CAL_TYPE;
+    cal_cfg.app_type             = pbe_app_type;
+    cal_cfg.module_id            = PBE_CONF_MODULE_ID;
+    cal_cfg.param_id             = PBE_CONF_PARAM_ID;
+
+    len = sizeof(params->config);
+    ret = acdb_get_audio_cal((void *)&cal_cfg, (void*)&(params->config), &len);
+    ALOGD("%s ret = %d, len = %u", __func__, ret, len);
+    if (ret == 0)
+        params->cfg_len = len;
+
+    dlclose(acdb_handle);
+    return ret;
+}
diff --git a/post_proc/bass_boost.h b/post_proc/bass_boost.h
index 6f0e61b..14d6c97 100644
--- a/post_proc/bass_boost.h
+++ b/post_proc/bass_boost.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015, The Linux Foundation. All rights reserved.
  * Not a Contribution.
  *
  * Copyright (C) 2013 The Android Open Source Project
@@ -22,6 +22,13 @@
 
 #include "bundle.h"
 
+enum {
+    BASS_INVALID = -1,
+    BASS_BOOST = 0,      // index of bassboost
+    BASS_PBE,        // index of PBE
+    BASS_COUNT       // totol number of bass type
+};
+
 extern const effect_descriptor_t bassboost_descriptor;
 
 typedef struct bassboost_context_s {
@@ -37,11 +44,50 @@
     struct bass_boost_params offload_bass;
 } bassboost_context_t;
 
-int bassboost_get_parameter(effect_context_t *context, effect_param_t *p,
-                            uint32_t *size);
+typedef struct pbe_context_s {
+    effect_context_t common;
 
-int bassboost_set_parameter(effect_context_t *context, effect_param_t *p,
-                            uint32_t size);
+    // Offload vars
+    struct mixer_ctl *ctl;
+    int hw_acc_fd;
+    bool temp_disabled;
+    uint32_t device;
+    struct pbe_params offload_pbe;
+} pbe_context_t;
+
+typedef struct bass_context_s {
+    effect_context_t    common;
+    bassboost_context_t bassboost_ctxt;
+    pbe_context_t       pbe_ctxt;
+    int                 active_index;
+} bass_context_t;
+
+int bass_get_parameter(effect_context_t *context, effect_param_t *p,
+                       uint32_t *size);
+
+int bass_set_parameter(effect_context_t *context, effect_param_t *p,
+                       uint32_t size);
+
+int bass_set_device(effect_context_t *context,  uint32_t device);
+
+int bass_set_mode(effect_context_t *context,  int32_t hw_acc_fd);
+
+int bass_reset(effect_context_t *context);
+
+int bass_init(effect_context_t *context);
+
+int bass_enable(effect_context_t *context);
+
+int bass_disable(effect_context_t *context);
+
+int bass_start(effect_context_t *context, output_context_t *output);
+
+int bass_stop(effect_context_t *context, output_context_t *output);
+
+
+int bassboost_get_strength(bassboost_context_t *context);
+
+int bassboost_set_strength(bassboost_context_t *context, uint32_t strength);
 
 int bassboost_set_device(effect_context_t *context,  uint32_t device);
 
@@ -59,4 +105,20 @@
 
 int bassboost_stop(effect_context_t *context, output_context_t *output);
 
+int pbe_set_device(effect_context_t *context,  uint32_t device);
+
+int pbe_set_mode(effect_context_t *context,  int32_t hw_acc_fd);
+
+int pbe_reset(effect_context_t *context);
+
+int pbe_init(effect_context_t *context);
+
+int pbe_enable(effect_context_t *context);
+
+int pbe_disable(effect_context_t *context);
+
+int pbe_start(effect_context_t *context, output_context_t *output);
+
+int pbe_stop(effect_context_t *context, output_context_t *output);
+
 #endif /* OFFLOAD_EFFECT_BASS_BOOST_H_ */
diff --git a/post_proc/bundle.c b/post_proc/bundle.c
index 606c66b..a89b02b 100644
--- a/post_proc/bundle.c
+++ b/post_proc/bundle.c
@@ -520,25 +520,26 @@
         eq_ctxt->ctl = NULL;
     } else if (memcmp(uuid, &bassboost_descriptor.uuid,
                sizeof(effect_uuid_t)) == 0) {
-        bassboost_context_t *bass_ctxt = (bassboost_context_t *)
-                                         calloc(1, sizeof(bassboost_context_t));
+        bass_context_t *bass_ctxt = (bass_context_t *)
+                                         calloc(1, sizeof(bass_context_t));
         if (bass_ctxt == NULL) {
             return -ENOMEM;
         }
         context = (effect_context_t *)bass_ctxt;
-        context->ops.init = bassboost_init;
-        context->ops.reset = bassboost_reset;
-        context->ops.set_parameter = bassboost_set_parameter;
-        context->ops.get_parameter = bassboost_get_parameter;
-        context->ops.set_device = bassboost_set_device;
-        context->ops.set_hw_acc_mode = bassboost_set_mode;
-        context->ops.enable = bassboost_enable;
-        context->ops.disable = bassboost_disable;
-        context->ops.start = bassboost_start;
-        context->ops.stop = bassboost_stop;
+        context->ops.init = bass_init;
+        context->ops.reset = bass_reset;
+        context->ops.set_parameter = bass_set_parameter;
+        context->ops.get_parameter = bass_get_parameter;
+        context->ops.set_device = bass_set_device;
+        context->ops.set_hw_acc_mode = bass_set_mode;
+        context->ops.enable = bass_enable;
+        context->ops.disable = bass_disable;
+        context->ops.start = bass_start;
+        context->ops.stop = bass_stop;
 
         context->desc = &bassboost_descriptor;
-        bass_ctxt->ctl = NULL;
+        bass_ctxt->bassboost_ctxt.ctl = NULL;
+        bass_ctxt->pbe_ctxt.ctl = NULL;
     } else if (memcmp(uuid, &virtualizer_descriptor.uuid,
                sizeof(effect_uuid_t)) == 0) {
         virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)
diff --git a/post_proc/effect_api.c b/post_proc/effect_api.c
index 7c1968e..c850fa5 100644
--- a/post_proc/effect_api.c
+++ b/post_proc/effect_api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2015, 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
@@ -235,6 +235,83 @@
                                  bassboost, param_send_flags);
 }
 
+void offload_pbe_set_device(struct pbe_params *pbe,
+                            uint32_t device)
+{
+    ALOGV("%s: device=%d", __func__, device);
+    pbe->device = device;
+}
+
+void offload_pbe_set_enable_flag(struct pbe_params *pbe,
+                                 bool enable)
+{
+    ALOGV("%s: enable=%d", __func__, enable);
+    pbe->enable_flag = enable;
+}
+
+int offload_pbe_get_enable_flag(struct pbe_params *pbe)
+{
+    ALOGV("%s: enabled=%d", __func__, pbe->enable_flag);
+    return pbe->enable_flag;
+}
+
+static int pbe_send_params(eff_mode_t mode, void *ctl,
+                            struct pbe_params *pbe,
+                            unsigned param_send_flags)
+{
+    int param_values[128] = {0};
+    int i, *p_param_values = param_values, *cfg = NULL;
+
+    ALOGV("%s: enabled=%d", __func__, pbe->enable_flag);
+    *p_param_values++ = PBE_MODULE;
+    *p_param_values++ = pbe->device;
+    *p_param_values++ = 0; /* num of commands*/
+    if (param_send_flags & OFFLOAD_SEND_PBE_ENABLE_FLAG) {
+        *p_param_values++ = PBE_ENABLE;
+        *p_param_values++ = CONFIG_SET;
+        *p_param_values++ = 0; /* start offset if param size if greater than 128  */
+        *p_param_values++ = PBE_ENABLE_PARAM_LEN;
+        *p_param_values++ = pbe->enable_flag;
+        param_values[2] += 1;
+    }
+    if (param_send_flags & OFFLOAD_SEND_PBE_CONFIG) {
+        *p_param_values++ = PBE_CONFIG;
+        *p_param_values++ = CONFIG_SET;
+        *p_param_values++ = 0; /* start offset if param size if greater than 128  */
+        *p_param_values++ = pbe->cfg_len;
+        cfg = (int *)&pbe->config;
+        for (i = 0; i < (int)pbe->cfg_len ; i+= sizeof(*p_param_values))
+            *p_param_values++ = *cfg++;
+        param_values[2] += 1;
+    }
+
+    if ((mode == OFFLOAD) && param_values[2] && ctl) {
+        mixer_ctl_set_array((struct mixer_ctl *)ctl, param_values,
+                            ARRAY_SIZE(param_values));
+    } else if ((mode == HW_ACCELERATOR) && param_values[2] &&
+               ctl && *(int *)ctl) {
+        if (ioctl(*(int *)ctl, AUDIO_EFFECTS_SET_PP_PARAMS, param_values) < 0)
+            ALOGE("%s: sending h/w acc effects params fail[%d]", __func__, errno);
+    }
+
+    return 0;
+}
+
+int offload_pbe_send_params(struct mixer_ctl *ctl,
+                                  struct pbe_params *pbe,
+                                  unsigned param_send_flags)
+{
+    return pbe_send_params(OFFLOAD, (void *)ctl, pbe,
+                                 param_send_flags);
+}
+
+int hw_acc_pbe_send_params(int fd, struct pbe_params *pbe,
+                                 unsigned param_send_flags)
+{
+    return pbe_send_params(HW_ACCELERATOR, (void *)&fd,
+                                 pbe, param_send_flags);
+}
+
 void offload_virtualizer_set_device(struct virtualizer_params *virtualizer,
                                     uint32_t device)
 {
diff --git a/post_proc/effect_api.h b/post_proc/effect_api.h
index e05924a..ce0503a 100644
--- a/post_proc/effect_api.h
+++ b/post_proc/effect_api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2015, 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
@@ -39,6 +39,21 @@
                                          struct mixer_ctl **ctl);
 void offload_close_mixer(struct mixer **mixer);
 
+
+#define OFFLOAD_SEND_PBE_ENABLE_FLAG      (1 << 0)
+#define OFFLOAD_SEND_PBE_CONFIG           (OFFLOAD_SEND_PBE_ENABLE_FLAG << 1)
+void offload_pbe_set_device(struct pbe_params *pbe,
+                            uint32_t device);
+void offload_pbe_set_enable_flag(struct pbe_params *pbe,
+                                 bool enable);
+int offload_pbe_get_enable_flag(struct pbe_params *pbe);
+
+int offload_pbe_send_params(struct mixer_ctl *ctl,
+                            struct pbe_params *pbe,
+                            unsigned param_send_flags);
+int hw_acc_pbe_send_params(int fd,
+                           struct pbe_params *pbe,
+                           unsigned param_send_flags);
 #define OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG      (1 << 0)
 #define OFFLOAD_SEND_BASSBOOST_STRENGTH         \
                                           (OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG << 1)