Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6131d955 authored by Dhananjay Kumar's avatar Dhananjay Kumar Committed by Steve Kondik
Browse files

post_proc: improve logging 

Make logs more meaningful and remove
ones not necessary.

Change-Id: I9562cf34a5dee406b1c0347a9004db08de9cd5df
parent 410cbfb7

post_proc/bass_boost.c

+12 −14
Original line number Diff line number Diff line
@@ -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;

}

post_proc/bundle.c

+8 −7
Original line number Diff line number Diff line
@@ -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;

        }

post_proc/effect_api.c

+43 −37
Original line number Diff line number Diff line
@@ -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*/

post_proc/equalizer.c

+19 −31
Original line number Diff line number Diff line
@@ -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;

}

post_proc/reverb.c

+27 −41

File changed.

Preview size limit exceeded, changes collapsed.