post_proc: improve logging

Make logs more meaningful and remove
ones not necessary.

Change-Id: I9562cf34a5dee406b1c0347a9004db08de9cd5df

6 files changed, 118 insertions, 142 deletions

diff --git a/post_proc/bass_boost.c b/post_proc/bass_boost.c
index ac65dcc3..36946dca 100644
--- a/post_proc/bass_boost.c
+++ b/post_proc/bass_boost.c
@@ -44,13 +44,14 @@ const effect_descriptor_t bassboost_descriptor = {
 
 int bassboost_get_strength(bassboost_context_t *context)
 {
-    ALOGV("%s: strength: %d", __func__, context->strength);
+    ALOGV("%s: ctxt %p, strength: %d", __func__,
+                      context,  context->strength);
     return context->strength;
 }
 
 int bassboost_set_strength(bassboost_context_t *context, uint32_t strength)
 {
-    ALOGV("%s: strength: %d", __func__, strength);
+    ALOGV("%s: ctxt %p, strength: %d", __func__, context, strength);
     context->strength = strength;
 
     offload_bassboost_set_strength(&(context->offload_bass), strength);
@@ -71,7 +72,7 @@ int bassboost_get_parameter(effect_context_t *context, effect_param_t *p,
     void *value = p->data + voffset;
     int i;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, bass_ctxt, param);
 
     p->status = 0;
 
@@ -97,12 +98,10 @@ int bassboost_get_parameter(effect_context_t *context, effect_param_t *p,
 
     switch (param) {
     case BASSBOOST_PARAM_STRENGTH_SUPPORTED:
-        ALOGV("%s: BASSBOOST_PARAM_STRENGTH_SUPPORTED", __func__);
         *(uint32_t *)value = 1;
         break;
 
     case BASSBOOST_PARAM_STRENGTH:
-        ALOGV("%s: BASSBOOST_PARAM_STRENGTH", __func__);
         *(int16_t *)value = bassboost_get_strength(bass_ctxt);
         break;
 
@@ -124,13 +123,12 @@ int bassboost_set_parameter(effect_context_t *context, effect_param_t *p,
     int32_t param = *param_tmp++;
     uint32_t strength;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, bass_ctxt, param);
 
     p->status = 0;
 
     switch (param) {
     case BASSBOOST_PARAM_STRENGTH:
-        ALOGV("%s BASSBOOST_PARAM_STRENGTH", __func__);
         strength = (uint32_t)(*(int16_t *)value);
         bassboost_set_strength(bass_ctxt, strength);
         break;
@@ -146,7 +144,7 @@ int bassboost_set_device(effect_context_t *context, uint32_t device)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s: device: %d", __func__, device);
+    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) ||
@@ -192,7 +190,7 @@ int bassboost_init(effect_context_t *context)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, bass_ctxt);
     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;
@@ -222,7 +220,7 @@ int bassboost_enable(effect_context_t *context)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, strength %d", __func__, bass_ctxt, bass_ctxt->strength);
 
     if (!offload_bassboost_get_enable_flag(&(bass_ctxt->offload_bass)) &&
         !(bass_ctxt->temp_disabled)) {
@@ -240,7 +238,7 @@ int bassboost_disable(effect_context_t *context)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, bass_ctxt);
     if (offload_bassboost_get_enable_flag(&(bass_ctxt->offload_bass))) {
         offload_bassboost_set_enable_flag(&(bass_ctxt->offload_bass), false);
         if (bass_ctxt->ctl)
@@ -255,9 +253,9 @@ int bassboost_start(effect_context_t *context, output_context_t *output)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, ctl %p, strength %d", __func__, bass_ctxt,
+                                   output->ctl, bass_ctxt->strength);
     bass_ctxt->ctl = output->ctl;
-    ALOGV("output->ctl: %p", output->ctl);
     if (offload_bassboost_get_enable_flag(&(bass_ctxt->offload_bass)))
         if (bass_ctxt->ctl)
             offload_bassboost_send_params(bass_ctxt->ctl, &bass_ctxt->offload_bass,
@@ -270,7 +268,7 @@ int bassboost_stop(effect_context_t *context, output_context_t *output __unused)
 {
     bassboost_context_t *bass_ctxt = (bassboost_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, bass_ctxt);
     bass_ctxt->ctl = NULL;
     return 0;
 }
diff --git a/post_proc/bundle.c b/post_proc/bundle.c
index c728115c..6fdbef69 100644
--- a/post_proc/bundle.c
+++ b/post_proc/bundle.c
@@ -121,6 +121,7 @@ void add_effect_to_output(output_context_t * output, effect_context_t *context)
 {
     struct listnode *fx_node;
 
+    ALOGV("%s: e_ctxt %p, o_ctxt %p", __func__, context, output);
     list_for_each(fx_node, &output->effects_list) {
         effect_context_t *fx_ctxt = node_to_item(fx_node,
                                                  effect_context_t,
@@ -139,6 +140,7 @@ void remove_effect_from_output(output_context_t * output,
 {
     struct listnode *fx_node;
 
+    ALOGV("%s: e_ctxt %p, o_ctxt %p", __func__, context, output);
     list_for_each(fx_node, &output->effects_list) {
         effect_context_t *fx_ctxt = node_to_item(fx_node,
                                                  effect_context_t,
@@ -532,7 +534,7 @@ int effect_process(effect_handle_t self,
     effect_context_t * context = (effect_context_t *)self;
     int status = 0;
 
-    ALOGW("%s Called ?????", __func__);
+    ALOGW("%s: ctxt %p, Called ?????", __func__, context);
 
     pthread_mutex_lock(&lock);
     if (!effect_exists(context)) {
@@ -565,6 +567,7 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
         goto exit;
     }
 
+    ALOGV("%s: ctxt %p, cmd %d", __func__, context, cmdCode);
     if (context == NULL || context->state == EFFECT_STATE_UNINITIALIZED) {
         status = -ENOSYS;
         goto exit;
@@ -618,7 +621,6 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
         context->state = EFFECT_STATE_ACTIVE;
         if (context->ops.enable)
             context->ops.enable(context);
-        ALOGV("%s EFFECT_CMD_ENABLE", __func__);
         *(int *)pReplyData = 0;
         break;
     case EFFECT_CMD_DISABLE:
@@ -633,7 +635,6 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
         context->state = EFFECT_STATE_INITIALIZED;
         if (context->ops.disable)
             context->ops.disable(context);
-        ALOGV("%s EFFECT_CMD_DISABLE", __func__);
         *(int *)pReplyData = 0;
         break;
     case EFFECT_CMD_GET_PARAM: {
@@ -643,7 +644,7 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
             *replySize < (int)(sizeof(effect_param_t) + sizeof(uint32_t) +
                                sizeof(uint16_t))) {
             status = -EINVAL;
-            ALOGV("EFFECT_CMD_GET_PARAM invalid command cmdSize %d *replySize %d",
+            ALOGW("EFFECT_CMD_GET_PARAM invalid command cmdSize %d *replySize %d",
                   cmdSize, *replySize);
             goto exit;
         }
@@ -663,7 +664,7 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
                             sizeof(uint16_t)) ||
             pReplyData == NULL || *replySize != sizeof(int32_t)) {
             status = -EINVAL;
-            ALOGV("EFFECT_CMD_SET_PARAM invalid command cmdSize %d *replySize %d",
+            ALOGW("EFFECT_CMD_SET_PARAM invalid command cmdSize %d *replySize %d",
                   cmdSize, *replySize);
             goto exit;
         }
@@ -679,7 +680,7 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
         ALOGV("\t EFFECT_CMD_SET_DEVICE start");
         if (pCmdData == NULL || cmdSize < sizeof(uint32_t)) {
             status = -EINVAL;
-            ALOGV("EFFECT_CMD_SET_DEVICE invalid command cmdSize %d", cmdSize);
+            ALOGW("EFFECT_CMD_SET_DEVICE invalid command cmdSize %d", cmdSize);
             goto exit;
         }
         device = *(uint32_t *)pCmdData;
@@ -695,7 +696,7 @@ int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
 
         if (cmdSize != sizeof(effect_offload_param_t) || pCmdData == NULL
                 || pReplyData == NULL || *replySize != sizeof(int)) {
-            ALOGV("%s EFFECT_CMD_OFFLOAD bad format", __func__);
+            ALOGW("%s EFFECT_CMD_OFFLOAD bad format", __func__);
             status = -EINVAL;
             break;
         }
diff --git a/post_proc/effect_api.c b/post_proc/effect_api.c
index f2daadca..0df064f7 100644
--- a/post_proc/effect_api.c
+++ b/post_proc/effect_api.c
@@ -15,7 +15,13 @@
  */
 
 #define LOG_TAG "offload_effect_api"
-//#define LOG_NDEBUG 0
+#define LOG_NDEBUG 0
+//#define VERY_VERY_VERBOSE_LOGGING
+#ifdef VERY_VERY_VERBOSE_LOGGING
+#define ALOGVV ALOGV
+#else
+#define ALOGVV(a...) do { } while(0)
+#endif
 
 #include <errno.h>
 #include <stdbool.h>
@@ -87,34 +93,34 @@ void offload_close_mixer(struct mixer *mixer)
 void offload_bassboost_set_device(struct bass_boost_params *bassboost,
                                   uint32_t device)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: device 0x%x", __func__, device);
     bassboost->device = device;
 }
 
 void offload_bassboost_set_enable_flag(struct bass_boost_params *bassboost,
                                        bool enable)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enable=%d", __func__, (int)enable);
     bassboost->enable_flag = enable;
 }
 
 int offload_bassboost_get_enable_flag(struct bass_boost_params *bassboost)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enable=%d", __func__, (int)bassboost->enable_flag);
     return bassboost->enable_flag;
 }
 
 void offload_bassboost_set_strength(struct bass_boost_params *bassboost,
                                     int strength)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: strength %d", __func__, strength);
     bassboost->strength = strength;
 }
 
 void offload_bassboost_set_mode(struct bass_boost_params *bassboost,
                                 int mode)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: mode %d", __func__, mode);
     bassboost->mode = mode;
 }
 
@@ -125,7 +131,7 @@ int offload_bassboost_send_params(struct mixer_ctl *ctl,
     int param_values[128] = {0};
     int *p_param_values = param_values;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: flags 0x%x", __func__, param_send_flags);
     *p_param_values++ = BASS_BOOST_MODULE;
     *p_param_values++ = bassboost->device;
     *p_param_values++ = 0; /* num of commands*/
@@ -163,41 +169,41 @@ int offload_bassboost_send_params(struct mixer_ctl *ctl,
 void offload_virtualizer_set_device(struct virtualizer_params *virtualizer,
                                     uint32_t device)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: device=0x%x", __func__, device);
     virtualizer->device = device;
 }
 
 void offload_virtualizer_set_enable_flag(struct virtualizer_params *virtualizer,
                                          bool enable)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enable=%d", __func__, (int)enable);
     virtualizer->enable_flag = enable;
 }
 
 int offload_virtualizer_get_enable_flag(struct virtualizer_params *virtualizer)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enabled %d", __func__, (int)virtualizer->enable_flag);
     return virtualizer->enable_flag;
 }
 
 void offload_virtualizer_set_strength(struct virtualizer_params *virtualizer,
                                       int strength)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: strength %d", __func__, strength);
     virtualizer->strength = strength;
 }
 
 void offload_virtualizer_set_out_type(struct virtualizer_params *virtualizer,
                                       int out_type)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: out_type %d", __func__, out_type);
     virtualizer->out_type = out_type;
 }
 
 void offload_virtualizer_set_gain_adjust(struct virtualizer_params *virtualizer,
                                          int gain_adjust)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: gain %d", __func__, gain_adjust);
     virtualizer->gain_adjust = gain_adjust;
 }
 
@@ -208,7 +214,7 @@ int offload_virtualizer_send_params(struct mixer_ctl *ctl,
     int param_values[128] = {0};
     int *p_param_values = param_values;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: flags 0x%x", __func__, param_send_flags);
     *p_param_values++ = VIRTUALIZER_MODULE;
     *p_param_values++ = virtualizer->device;
     *p_param_values++ = 0; /* num of commands*/
@@ -253,25 +259,25 @@ int offload_virtualizer_send_params(struct mixer_ctl *ctl,
 
 void offload_eq_set_device(struct eq_params *eq, uint32_t device)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: device 0x%x", __func__, device);
     eq->device = device;
 }
 
 void offload_eq_set_enable_flag(struct eq_params *eq, bool enable)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enable=%d", __func__, (int)enable);
     eq->enable_flag = enable;
 }
 
 int offload_eq_get_enable_flag(struct eq_params *eq)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enabled=%d", __func__, (int)eq->enable_flag);
     return eq->enable_flag;
 }
 
 void offload_eq_set_preset(struct eq_params *eq, int preset)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: preset %d", __func__, preset);
     eq->config.preset_id = preset;
     eq->config.eq_pregain = Q27_UNITY;
 }
@@ -281,7 +287,7 @@ void offload_eq_set_bands_level(struct eq_params *eq, int num_bands,
                                 int *band_gain_list)
 {
     int i;
-    ALOGV("%s", __func__);
+    ALOGVV("%s", __func__);
     eq->config.num_bands = num_bands;
     for (i=0; i<num_bands; i++) {
         eq->per_band_cfg[i].band_idx = i;
@@ -354,110 +360,110 @@ int offload_eq_send_params(struct mixer_ctl *ctl, struct eq_params *eq,
 
 void offload_reverb_set_device(struct reverb_params *reverb, uint32_t device)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: device 0x%x", __func__, device);
     reverb->device = device;
 }
 
 void offload_reverb_set_enable_flag(struct reverb_params *reverb, bool enable)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enable=%d", __func__, (int)enable);
     reverb->enable_flag = enable;
 }
 
 int offload_reverb_get_enable_flag(struct reverb_params *reverb)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: enabled=%d", __func__, reverb->enable_flag);
     return reverb->enable_flag;
 }
 
 void offload_reverb_set_mode(struct reverb_params *reverb, int mode)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s", __func__);
     reverb->mode = mode;
 }
 
 void offload_reverb_set_preset(struct reverb_params *reverb, int preset)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: preset %d", __func__, preset);
     if (preset && (preset <= NUM_OSL_REVERB_PRESETS_SUPPORTED))
         reverb->preset = map_reverb_opensl_preset_2_offload_preset[preset-1][1];
 }
 
 void offload_reverb_set_wet_mix(struct reverb_params *reverb, int wet_mix)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: wet_mix %d", __func__, wet_mix);
     reverb->wet_mix = wet_mix;
 }
 
 void offload_reverb_set_gain_adjust(struct reverb_params *reverb,
                                     int gain_adjust)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: gain %d", __func__, gain_adjust);
     reverb->gain_adjust = gain_adjust;
 }
 
 void offload_reverb_set_room_level(struct reverb_params *reverb, int room_level)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: level %d", __func__, room_level);
     reverb->room_level = room_level;
 }
 
 void offload_reverb_set_room_hf_level(struct reverb_params *reverb,
                                       int room_hf_level)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: level %d", __func__, room_hf_level);
     reverb->room_hf_level = room_hf_level;
 }
 
 void offload_reverb_set_decay_time(struct reverb_params *reverb, int decay_time)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: decay time %d", __func__, decay_time);
     reverb->decay_time = decay_time;
 }
 
 void offload_reverb_set_decay_hf_ratio(struct reverb_params *reverb,
                                        int decay_hf_ratio)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: decay_hf_ratio %d", __func__, decay_hf_ratio);
     reverb->decay_hf_ratio = decay_hf_ratio;
 }
 
 void offload_reverb_set_reflections_level(struct reverb_params *reverb,
                                           int reflections_level)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: ref level %d", __func__, reflections_level);
     reverb->reflections_level = reflections_level;
 }
 
 void offload_reverb_set_reflections_delay(struct reverb_params *reverb,
                                           int reflections_delay)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: ref delay", __func__, reflections_delay);
     reverb->reflections_delay = reflections_delay;
 }
 
 void offload_reverb_set_reverb_level(struct reverb_params *reverb,
                                      int reverb_level)
 {
-    ALOGV("%s", __func__);
+    ALOGD("%s: reverb level %d", __func__, reverb_level);
     reverb->level = reverb_level;
 }
 
 void offload_reverb_set_delay(struct reverb_params *reverb, int delay)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: delay %d", __func__, delay);
     reverb->delay = delay;
 }
 
 void offload_reverb_set_diffusion(struct reverb_params *reverb, int diffusion)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: diffusion %d", __func__, diffusion);
     reverb->diffusion = diffusion;
 }
 
 void offload_reverb_set_density(struct reverb_params *reverb, int density)
 {
-    ALOGV("%s", __func__);
+    ALOGVV("%s: density %d", __func__, density);
     reverb->density = density;
 }
 
@@ -468,7 +474,7 @@ int offload_reverb_send_params(struct mixer_ctl *ctl,
     int param_values[128] = {0};
     int *p_param_values = param_values;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: flags 0x%x", __func__, param_send_flags);
     *p_param_values++ = REVERB_MODULE;
     *p_param_values++ = reverb->device;
     *p_param_values++ = 0; /* num of commands*/
diff --git a/post_proc/equalizer.c b/post_proc/equalizer.c
index dfb40d8f..fe2b282f 100644
--- a/post_proc/equalizer.c
+++ b/post_proc/equalizer.c
@@ -84,7 +84,7 @@ const uint16_t equalizer_band_presets_freq[NUM_EQ_BANDS] = {
 
 int equalizer_get_band_level(equalizer_context_t *context, int32_t band)
 {
-    ALOGV("%s: band: %d level: %d", __func__, band,
+    ALOGV("%s: ctxt %p, band: %d level: %d", __func__, context, band,
            context->band_levels[band] * 100);
     return context->band_levels[band] * 100;
 }
@@ -92,7 +92,7 @@ int equalizer_get_band_level(equalizer_context_t *context, int32_t band)
 int equalizer_set_band_level(equalizer_context_t *context, int32_t band,
                              int32_t level)
 {
-    ALOGV("%s: band: %d, level: %d", __func__, band, level);
+    ALOGV("%s: ctxt %p, band: %d, level: %d", __func__, context, band, level);
     if (level > 0) {
         level = (int)((level+50)/100);
     } else {
@@ -115,7 +115,7 @@ int equalizer_set_band_level(equalizer_context_t *context, int32_t band,
 
 int equalizer_get_center_frequency(equalizer_context_t *context __unused, int32_t band)
 {
-    ALOGV("%s: band: %d", __func__, band);
+    ALOGV("%s: ctxt %p, band: %d", __func__, context, band);
     return (equalizer_band_freq_range[band][0] +
             equalizer_band_freq_range[band][1]) / 2;
 }
@@ -123,7 +123,7 @@ int equalizer_get_center_frequency(equalizer_context_t *context __unused, int32_
 int equalizer_get_band_freq_range(equalizer_context_t *context __unused, int32_t band,
                                   uint32_t *low, uint32_t *high)
 {
-    ALOGV("%s: band: %d", __func__, band);
+    ALOGV("%s: ctxt %p, band: %d", __func__, context, band);
     *low = equalizer_band_freq_range[band][0];
     *high = equalizer_band_freq_range[band][1];
    return 0;
@@ -133,7 +133,7 @@ int equalizer_get_band(equalizer_context_t *context __unused, uint32_t freq)
 {
     int i;
 
-    ALOGV("%s: freq: %d", __func__, freq);
+    ALOGV("%s: ctxt %p, freq: %d", __func__, context, freq);
     for (i = 0; i < NUM_EQ_BANDS; i++) {
         if (freq <= equalizer_band_freq_range[i][1]) {
             return i;
@@ -144,7 +144,7 @@ int equalizer_get_band(equalizer_context_t *context __unused, uint32_t freq)
 
 int equalizer_get_preset(equalizer_context_t *context)
 {
-    ALOGV("%s: preset: %d", __func__, context->preset);
+    ALOGV("%s: ctxt %p, preset: %d", __func__, context, context->preset);
     return context->preset;
 }
 
@@ -152,7 +152,7 @@ int equalizer_set_preset(equalizer_context_t *context, int preset)
 {
     int i;
 
-    ALOGV("%s: preset: %d", __func__, preset);
+    ALOGV("%s: ctxt %p, preset: %d", __func__, context, preset);
     context->preset = preset;
     for (i=0; i<NUM_EQ_BANDS; i++)
         context->band_levels[i] =
@@ -173,7 +173,8 @@ int equalizer_set_preset(equalizer_context_t *context, int preset)
 const char * equalizer_get_preset_name(equalizer_context_t *context __unused,
                                        int32_t preset)
 {
-    ALOGV("%s: preset: %s", __func__, equalizer_preset_names[preset]);
+    ALOGV("%s: ctxt %p, preset: %s", __func__, context,
+                        equalizer_preset_names[preset]);
     if (preset == PRESET_CUSTOM) {
         return "Custom";
     } else {
@@ -183,7 +184,7 @@ const char * equalizer_get_preset_name(equalizer_context_t *context __unused,
 
 int equalizer_get_num_presets(equalizer_context_t *context __unused)
 {
-    ALOGV("%s: presets_num: %d", __func__,
+    ALOGV("%s: ctxt %p, presets_num: %d", __func__, context,
            sizeof(equalizer_preset_names)/sizeof(char *));
     return sizeof(equalizer_preset_names)/sizeof(char *);
 }
@@ -200,7 +201,7 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
     void *value = p->data + voffset;
     int i;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, eq_ctxt, param);
 
     p->status = 0;
 
@@ -252,18 +253,15 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
 
     switch (param) {
     case EQ_PARAM_NUM_BANDS:
-	ALOGV("%s: EQ_PARAM_NUM_BANDS", __func__);
         *(uint16_t *)value = (uint16_t)NUM_EQ_BANDS;
         break;
 
     case EQ_PARAM_LEVEL_RANGE:
-	ALOGV("%s: EQ_PARAM_LEVEL_RANGE", __func__);
         *(int16_t *)value = -1500;
         *((int16_t *)value + 1) = 1500;
         break;
 
     case EQ_PARAM_BAND_LEVEL:
-	ALOGV("%s: EQ_PARAM_BAND_LEVEL", __func__);
         param2 = *param_tmp;
         if (param2 >= NUM_EQ_BANDS) {
             p->status = -EINVAL;
@@ -273,7 +271,6 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
         break;
 
     case EQ_PARAM_CENTER_FREQ:
-	ALOGV("%s: EQ_PARAM_CENTER_FREQ", __func__);
         param2 = *param_tmp;
         if (param2 >= NUM_EQ_BANDS) {
            p->status = -EINVAL;
@@ -283,7 +280,6 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
         break;
 
     case EQ_PARAM_BAND_FREQ_RANGE:
-	ALOGV("%s: EQ_PARAM_BAND_FREQ_RANGE", __func__);
         param2 = *param_tmp;
         if (param2 >= NUM_EQ_BANDS) {
             p->status = -EINVAL;
@@ -294,25 +290,21 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
         break;
 
     case EQ_PARAM_GET_BAND:
-	ALOGV("%s: EQ_PARAM_GET_BAND", __func__);
         param2 = *param_tmp;
         *(uint16_t *)value = (uint16_t)equalizer_get_band(eq_ctxt, param2);
         break;
 
     case EQ_PARAM_CUR_PRESET:
-	ALOGV("%s: EQ_PARAM_CUR_PRESET", __func__);
         *(uint16_t *)value = (uint16_t)equalizer_get_preset(eq_ctxt);
         break;
 
     case EQ_PARAM_GET_NUM_OF_PRESETS:
-	ALOGV("%s: EQ_PARAM_GET_NUM_OF_PRESETS", __func__);
         *(uint16_t *)value = (uint16_t)equalizer_get_num_presets(eq_ctxt);
         break;
 
     case EQ_PARAM_GET_PRESET_NAME:
-	ALOGV("%s: EQ_PARAM_GET_PRESET_NAME", __func__);
         param2 = *param_tmp;
-	ALOGV("param2: %d", param2);
+        ALOGV("%s: EQ_PARAM_GET_PRESET_NAME: param2: %d", __func__, param2);
         if (param2 >= equalizer_get_num_presets(eq_ctxt)) {
             p->status = -EINVAL;
             break;
@@ -324,7 +316,6 @@ int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
         break;
 
     case EQ_PARAM_PROPERTIES: {
-	ALOGV("%s: EQ_PARAM_PROPERTIES", __func__);
         int16_t *prop = (int16_t *)value;
         prop[0] = (int16_t)equalizer_get_preset(eq_ctxt);
         prop[1] = (int16_t)NUM_EQ_BANDS;
@@ -354,13 +345,12 @@ int equalizer_set_parameter(effect_context_t *context, effect_param_t *p,
     int32_t level;
     int i;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, eq_ctxt, param);
 
     p->status = 0;
 
     switch (param) {
     case EQ_PARAM_CUR_PRESET:
-	ALOGV("EQ_PARAM_CUR_PRESET");
         preset = (int32_t)(*(uint16_t *)value);
 
         if ((preset >= equalizer_get_num_presets(eq_ctxt)) || (preset < 0)) {
@@ -370,7 +360,6 @@ int equalizer_set_parameter(effect_context_t *context, effect_param_t *p,
         equalizer_set_preset(eq_ctxt, preset);
         break;
     case EQ_PARAM_BAND_LEVEL:
-	ALOGV("EQ_PARAM_BAND_LEVEL");
         band =  *param_tmp;
         level = (int32_t)(*(int16_t *)value);
         if (band >= NUM_EQ_BANDS) {
@@ -380,7 +369,6 @@ int equalizer_set_parameter(effect_context_t *context, effect_param_t *p,
         equalizer_set_band_level(eq_ctxt, band, level);
         break;
     case EQ_PARAM_PROPERTIES: {
-	ALOGV("EQ_PARAM_PROPERTIES");
         int16_t *prop = (int16_t *)value;
         if ((int)prop[0] >= equalizer_get_num_presets(eq_ctxt)) {
             p->status = -EINVAL;
@@ -408,7 +396,7 @@ int equalizer_set_parameter(effect_context_t *context, effect_param_t *p,
 
 int equalizer_set_device(effect_context_t *context,  uint32_t device)
 {
-    ALOGV("%s: device: %d", __func__, device);
+    ALOGV("%s: ctxt %p, device: 0x%x", __func__, context, device);
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
     eq_ctxt->device = device;
     offload_eq_set_device(&(eq_ctxt->offload_eq), device);
@@ -424,7 +412,7 @@ int equalizer_reset(effect_context_t *context)
 
 int equalizer_init(effect_context_t *context)
 {
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, context);
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
 
     context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
@@ -456,7 +444,7 @@ int equalizer_enable(effect_context_t *context)
 {
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, context);
 
     if (!offload_eq_get_enable_flag(&(eq_ctxt->offload_eq))) {
         offload_eq_set_enable_flag(&(eq_ctxt->offload_eq), true);
@@ -472,7 +460,7 @@ int equalizer_disable(effect_context_t *context)
 {
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s:ctxt %p", __func__, eq_ctxt);
     if (offload_eq_get_enable_flag(&(eq_ctxt->offload_eq))) {
         offload_eq_set_enable_flag(&(eq_ctxt->offload_eq), false);
         if (eq_ctxt->ctl)
@@ -486,7 +474,7 @@ int equalizer_start(effect_context_t *context, output_context_t *output)
 {
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
 
-    ALOGV("%s: %p", __func__, output->ctl);
+    ALOGV("%s: ctxt %p, ctl %p", __func__, eq_ctxt, output->ctl);
     eq_ctxt->ctl = output->ctl;
     if (offload_eq_get_enable_flag(&(eq_ctxt->offload_eq)))
         if (eq_ctxt->ctl)
@@ -500,7 +488,7 @@ int equalizer_stop(effect_context_t *context, output_context_t *output __unused)
 {
     equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, eq_ctxt);
     eq_ctxt->ctl = NULL;
     return 0;
 }
diff --git a/post_proc/reverb.c b/post_proc/reverb.c
index 2e5769a8..9b6af9a1 100644
--- a/post_proc/reverb.c
+++ b/post_proc/reverb.c
@@ -120,13 +120,13 @@ void reverb_preset_init(reverb_context_t *context)
  */
 int16_t reverb_get_room_level(reverb_context_t *context)
 {
-    ALOGV("%s: room level: %d", __func__, context->reverb_settings.roomLevel);
+    ALOGV("%s: ctxt %p, room level: %d", __func__, context, context->reverb_settings.roomLevel);
     return context->reverb_settings.roomLevel;
 }
 
 void reverb_set_room_level(reverb_context_t *context, int16_t room_level)
 {
-    ALOGV("%s: room level: %d", __func__, room_level);
+    ALOGV("%s: ctxt %p, room level: %d", __func__, context, room_level);
     context->reverb_settings.roomLevel = room_level;
     offload_reverb_set_room_level(&(context->offload_reverb), room_level);
     if (context->ctl)
@@ -137,14 +137,14 @@ void reverb_set_room_level(reverb_context_t *context, int16_t room_level)
 
 int16_t reverb_get_room_hf_level(reverb_context_t *context)
 {
-    ALOGV("%s: room hf level: %d", __func__,
+    ALOGV("%s: ctxt %p, room hf level: %d", __func__, context,
           context->reverb_settings.roomHFLevel);
     return context->reverb_settings.roomHFLevel;
 }
 
 void reverb_set_room_hf_level(reverb_context_t *context, int16_t room_hf_level)
 {
-    ALOGV("%s: room hf level: %d", __func__, room_hf_level);
+    ALOGV("%s: ctxt %p, room hf level: %d", __func__, context, room_hf_level);
     context->reverb_settings.roomHFLevel = room_hf_level;
     offload_reverb_set_room_hf_level(&(context->offload_reverb), room_hf_level);
     if (context->ctl)
@@ -155,13 +155,14 @@ void reverb_set_room_hf_level(reverb_context_t *context, int16_t room_hf_level)
 
 uint32_t reverb_get_decay_time(reverb_context_t *context)
 {
-    ALOGV("%s: decay time: %d", __func__, context->reverb_settings.decayTime);
+    ALOGV("%s: ctxt %p, decay time: %d", __func__, context,
+                         context->reverb_settings.decayTime);
     return context->reverb_settings.decayTime;
 }
 
 void reverb_set_decay_time(reverb_context_t *context, uint32_t decay_time)
 {
-    ALOGV("%s: decay_time: %d", __func__, decay_time);
+    ALOGV("%s: ctxt %p, decay_time: %d", __func__, context, decay_time);
     context->reverb_settings.decayTime = decay_time;
     offload_reverb_set_decay_time(&(context->offload_reverb), decay_time);
     if (context->ctl)
@@ -172,14 +173,14 @@ void reverb_set_decay_time(reverb_context_t *context, uint32_t decay_time)
 
 int16_t reverb_get_decay_hf_ratio(reverb_context_t *context)
 {
-    ALOGV("%s: decay hf ratio: %d", __func__,
+    ALOGV("%s: ctxt %p, decay hf ratio: %d", __func__, context,
           context->reverb_settings.decayHFRatio);
     return context->reverb_settings.decayHFRatio;
 }
 
 void reverb_set_decay_hf_ratio(reverb_context_t *context, int16_t decay_hf_ratio)
 {
-    ALOGV("%s: decay_hf_ratio: %d", __func__, decay_hf_ratio);
+    ALOGV("%s: ctxt %p, decay_hf_ratio: %d", __func__, context, decay_hf_ratio);
     context->reverb_settings.decayHFRatio = decay_hf_ratio;
     offload_reverb_set_decay_hf_ratio(&(context->offload_reverb), decay_hf_ratio);
     if (context->ctl)
@@ -190,13 +191,14 @@ void reverb_set_decay_hf_ratio(reverb_context_t *context, int16_t decay_hf_ratio
 
 int16_t reverb_get_reverb_level(reverb_context_t *context)
 {
-    ALOGV("%s: reverb level: %d", __func__, context->reverb_settings.reverbLevel);
+    ALOGV("%s: ctxt %p, reverb level: %d", __func__, context,
+                         context->reverb_settings.reverbLevel);
     return context->reverb_settings.reverbLevel;
 }
 
 void reverb_set_reverb_level(reverb_context_t *context, int16_t reverb_level)
 {
-    ALOGV("%s: reverb level: %d", __func__, reverb_level);
+    ALOGV("%s: ctxt %p, reverb level: %d", __func__, context, reverb_level);
     context->reverb_settings.reverbLevel = reverb_level;
     offload_reverb_set_reverb_level(&(context->offload_reverb), reverb_level);
     if (context->ctl)
@@ -207,13 +209,14 @@ void reverb_set_reverb_level(reverb_context_t *context, int16_t reverb_level)
 
 int16_t reverb_get_diffusion(reverb_context_t *context)
 {
-    ALOGV("%s: diffusion: %d", __func__, context->reverb_settings.diffusion);
+    ALOGV("%s: ctxt %p, diffusion: %d", __func__, context,
+                        context->reverb_settings.diffusion);
     return context->reverb_settings.diffusion;
 }
 
 void reverb_set_diffusion(reverb_context_t *context, int16_t diffusion)
 {
-    ALOGV("%s: diffusion: %d", __func__, diffusion);
+    ALOGV("%s: ctxt %p, diffusion: %d", __func__, context, diffusion);
     context->reverb_settings.diffusion = diffusion;
     offload_reverb_set_diffusion(&(context->offload_reverb), diffusion);
     if (context->ctl)
@@ -224,7 +227,8 @@ void reverb_set_diffusion(reverb_context_t *context, int16_t diffusion)
 
 int16_t reverb_get_density(reverb_context_t *context)
 {
-    ALOGV("%s: density: %d", __func__, context->reverb_settings.density);
+    ALOGV("%s: ctxt %p, density: %d", __func__, context,
+                          context->reverb_settings.density);
     return context->reverb_settings.density;
 }
 
@@ -242,7 +246,7 @@ void reverb_set_density(reverb_context_t *context, int16_t density)
 void reverb_set_preset(reverb_context_t *context, int16_t preset)
 {
     bool enable;
-    ALOGV("%s: preset: %d", __func__, preset);
+    ALOGV("%s: ctxt %p, preset: %d", __func__, context, preset);
     context->next_preset = preset;
     offload_reverb_set_preset(&(context->offload_reverb), preset);
 
@@ -260,7 +264,7 @@ void reverb_set_preset(reverb_context_t *context, int16_t preset)
 void reverb_set_all_properties(reverb_context_t *context,
                                reverb_settings_t *reverb_settings)
 {
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, context);
     context->reverb_settings.roomLevel = reverb_settings->roomLevel;
     context->reverb_settings.roomHFLevel = reverb_settings->roomHFLevel;
     context->reverb_settings.decayTime = reverb_settings->decayTime;
@@ -307,7 +311,7 @@ int reverb_get_parameter(effect_context_t *context, effect_param_t *p,
     reverb_settings_t *reverb_settings;
     int i;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, reverb_ctxt, param);
 
     p->status = 0;
 
@@ -385,7 +389,6 @@ int reverb_get_parameter(effect_context_t *context, effect_param_t *p,
 
     switch (param) {
     case REVERB_PARAM_PROPERTIES:
-	ALOGV("%s: REVERB_PARAM_PROPERTIES", __func__);
         reverb_settings = (reverb_settings_t *)value;
         reverb_settings->roomLevel = reverb_get_room_level(reverb_ctxt);
         reverb_settings->roomHFLevel = reverb_get_room_hf_level(reverb_ctxt);
@@ -399,43 +402,33 @@ int reverb_get_parameter(effect_context_t *context, effect_param_t *p,
         reverb_settings->density = reverb_get_density(reverb_ctxt);
         break;
     case REVERB_PARAM_ROOM_LEVEL:
-	ALOGV("%s: REVERB_PARAM_ROOM_LEVEL", __func__);
         *(int16_t *)value = reverb_get_room_level(reverb_ctxt);
         break;
     case REVERB_PARAM_ROOM_HF_LEVEL:
-	ALOGV("%s: REVERB_PARAM_ROOM_HF_LEVEL", __func__);
         *(int16_t *)value = reverb_get_room_hf_level(reverb_ctxt);
         break;
     case REVERB_PARAM_DECAY_TIME:
-	ALOGV("%s: REVERB_PARAM_DECAY_TIME", __func__);
         *(uint32_t *)value = reverb_get_decay_time(reverb_ctxt);
         break;
     case REVERB_PARAM_DECAY_HF_RATIO:
-	ALOGV("%s: REVERB_PARAM_DECAY_HF_RATIO", __func__);
         *(int16_t *)value = reverb_get_decay_hf_ratio(reverb_ctxt);
         break;
     case REVERB_PARAM_REVERB_LEVEL:
-	ALOGV("%s: REVERB_PARAM_REVERB_LEVEL", __func__);
         *(int16_t *)value = reverb_get_reverb_level(reverb_ctxt);
         break;
     case REVERB_PARAM_DIFFUSION:
-	ALOGV("%s: REVERB_PARAM_DIFFUSION", __func__);
         *(int16_t *)value = reverb_get_diffusion(reverb_ctxt);
         break;
     case REVERB_PARAM_DENSITY:
-	ALOGV("%s: REVERB_PARAM_DENSITY", __func__);
         *(int16_t *)value = reverb_get_density(reverb_ctxt);
         break;
     case REVERB_PARAM_REFLECTIONS_LEVEL:
-	ALOGV("%s: REVERB_PARAM_REFLECTIONS_LEVEL", __func__);
         *(uint16_t *)value = 0;
         break;
     case REVERB_PARAM_REFLECTIONS_DELAY:
-	ALOGV("%s: REVERB_PARAM_REFLECTIONS_DELAY", __func__);
         *(uint32_t *)value = 0;
         break;
     case REVERB_PARAM_REVERB_DELAY:
-	ALOGV("%s: REVERB_PARAM_REVERB_DELAY", __func__);
         *(uint32_t *)value = 0;
         break;
     default:
@@ -459,7 +452,7 @@ int reverb_set_parameter(effect_context_t *context, effect_param_t *p,
     int16_t ratio;
     uint32_t time;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, reverb_ctxt, param);
 
     p->status = 0;
 
@@ -476,41 +469,33 @@ int reverb_set_parameter(effect_context_t *context, effect_param_t *p,
     }
     switch (param) {
     case REVERB_PARAM_PROPERTIES:
-	ALOGV("%s: REVERB_PARAM_PROPERTIES", __func__);
         reverb_settings = (reverb_settings_t *)value;
         break;
     case REVERB_PARAM_ROOM_LEVEL:
-	ALOGV("%s: REVERB_PARAM_ROOM_LEVEL", __func__);
         level = *(int16_t *)value;
         reverb_set_room_level(reverb_ctxt, level);
         break;
     case REVERB_PARAM_ROOM_HF_LEVEL:
-	ALOGV("%s: REVERB_PARAM_ROOM_HF_LEVEL", __func__);
         level = *(int16_t *)value;
         reverb_set_room_hf_level(reverb_ctxt, level);
         break;
     case REVERB_PARAM_DECAY_TIME:
-	ALOGV("%s: REVERB_PARAM_DECAY_TIME", __func__);
         time = *(uint32_t *)value;
         reverb_set_decay_time(reverb_ctxt, time);
         break;
     case REVERB_PARAM_DECAY_HF_RATIO:
-	ALOGV("%s: REVERB_PARAM_DECAY_HF_RATIO", __func__);
         ratio = *(int16_t *)value;
         reverb_set_decay_hf_ratio(reverb_ctxt, ratio);
         break;
     case REVERB_PARAM_REVERB_LEVEL:
-	ALOGV("%s: REVERB_PARAM_REVERB_LEVEL", __func__);
         level = *(int16_t *)value;
         reverb_set_reverb_level(reverb_ctxt, level);
         break;
     case REVERB_PARAM_DIFFUSION:
-	ALOGV("%s: REVERB_PARAM_DIFFUSION", __func__);
         ratio = *(int16_t *)value;
         reverb_set_diffusion(reverb_ctxt, ratio);
         break;
     case REVERB_PARAM_DENSITY:
-	ALOGV("%s: REVERB_PARAM_DENSITY", __func__);
         ratio = *(int16_t *)value;
         reverb_set_density(reverb_ctxt, ratio);
         break;
@@ -530,7 +515,7 @@ int reverb_set_device(effect_context_t *context, uint32_t device)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
-    ALOGV("%s: device: %d", __func__, device);
+    ALOGV("%s: ctxt %p, device: 0x%x", __func__, reverb_ctxt, device);
     reverb_ctxt->device = device;
     offload_reverb_set_device(&(reverb_ctxt->offload_reverb), device);
     return 0;
@@ -547,6 +532,7 @@ int reverb_init(effect_context_t *context)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
+    ALOGV("%s: ctxt %p", __func__, reverb_ctxt);
     context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
     /*
        FIXME: channel mode is mono for auxiliary. is it needed for offload ?
@@ -585,7 +571,7 @@ int reverb_enable(effect_context_t *context)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, reverb_ctxt);
     reverb_ctxt->enabled_by_client = true;
 
     /* REVERB_PRESET_NONE is equivalent to disabled state,
@@ -606,7 +592,7 @@ int reverb_disable(effect_context_t *context)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, reverb_ctxt);
     reverb_ctxt->enabled_by_client = false;
     if (offload_reverb_get_enable_flag(&(reverb_ctxt->offload_reverb))) {
         offload_reverb_set_enable_flag(&(reverb_ctxt->offload_reverb), false);
@@ -622,7 +608,7 @@ int reverb_start(effect_context_t *context, output_context_t *output)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, ctl %p", __func__, reverb_ctxt, output->ctl);
     reverb_ctxt->ctl = output->ctl;
     if (offload_reverb_get_enable_flag(&(reverb_ctxt->offload_reverb))) {
         if (reverb_ctxt->ctl && reverb_ctxt->preset) {
@@ -639,7 +625,7 @@ int reverb_stop(effect_context_t *context, output_context_t *output __unused)
 {
     reverb_context_t *reverb_ctxt = (reverb_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, reverb_ctxt);
     reverb_ctxt->ctl = NULL;
     return 0;
 }
diff --git a/post_proc/virtualizer.c b/post_proc/virtualizer.c
index 576d6cbf..7201fd90 100644
--- a/post_proc/virtualizer.c
+++ b/post_proc/virtualizer.c
@@ -46,13 +46,13 @@ const effect_descriptor_t virtualizer_descriptor = {
 
 int virtualizer_get_strength(virtualizer_context_t *context)
 {
-    ALOGV("%s: strength: %d", __func__, context->strength);
+    ALOGV("%s: ctxt %p, strength: %d", __func__, context, context->strength);
     return context->strength;
 }
 
 int virtualizer_set_strength(virtualizer_context_t *context, uint32_t strength)
 {
-    ALOGV("%s: strength: %d", __func__, strength);
+    ALOGV("%s: ctxt %p, strength: %d", __func__, context, strength);
     context->strength = strength;
 
     /*
@@ -265,7 +265,7 @@ int virtualizer_get_parameter(effect_context_t *context, effect_param_t *p,
     void *value = p->data + voffset;
     int i;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, virt_ctxt, param);
 
     p->status = 0;
 
@@ -300,12 +300,10 @@ int virtualizer_get_parameter(effect_context_t *context, effect_param_t *p,
 
     switch (param) {
     case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED:
-	ALOGV("%s: VIRTUALIZER_PARAM_STRENGTH_SUPPORTED", __func__);
         *(uint32_t *)value = 1;
         break;
 
     case VIRTUALIZER_PARAM_STRENGTH:
-	ALOGV("%s: VIRTUALIZER_PARAM_STRENGTH", __func__);
         *(int16_t *)value = virtualizer_get_strength(virt_ctxt);
         break;
 
@@ -352,13 +350,12 @@ int virtualizer_set_parameter(effect_context_t *context, effect_param_t *p,
     int32_t param = *param_tmp++;
     uint32_t strength;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, param %d", __func__, virt_ctxt, param);
 
     p->status = 0;
 
     switch (param) {
     case VIRTUALIZER_PARAM_STRENGTH:
-	ALOGV("%s VIRTUALIZER_PARAM_STRENGTH", __func__);
         strength = (uint32_t)(*(int16_t *)value);
         virtualizer_set_strength(virt_ctxt, strength);
         break;
@@ -382,7 +379,7 @@ int virtualizer_set_device(effect_context_t *context, uint32_t device)
 {
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
-    ALOGV("%s: device: %d", __func__, device);
+    ALOGV("%s: ctxt %p, device: 0x%x", __func__, virt_ctxt, device);
     virt_ctxt->device = device;
 
     if (virt_ctxt->forced_device == AUDIO_DEVICE_NONE) {
@@ -427,7 +424,7 @@ int virtualizer_reset(effect_context_t *context)
 
 int virtualizer_init(effect_context_t *context)
 {
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, context);
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
     context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
@@ -462,7 +459,7 @@ int virtualizer_enable(effect_context_t *context)
 {
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, strength %d", __func__, virt_ctxt, virt_ctxt->strength);
 
     virt_ctxt->enabled_by_client = true;
     if (!offload_virtualizer_get_enable_flag(&(virt_ctxt->offload_virt)) &&
@@ -498,7 +495,7 @@ int virtualizer_start(effect_context_t *context, output_context_t *output)
 {
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p, ctl %p", __func__, virt_ctxt, output->ctl);
     virt_ctxt->ctl = output->ctl;
     if (offload_virtualizer_get_enable_flag(&(virt_ctxt->offload_virt)))
         if (virt_ctxt->ctl)
@@ -512,7 +509,7 @@ int virtualizer_stop(effect_context_t *context, output_context_t *output __unuse
 {
     virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
 
-    ALOGV("%s", __func__);
+    ALOGV("%s: ctxt %p", __func__, virt_ctxt);
     virt_ctxt->ctl = NULL;
     return 0;
 }