Merge "post_proc: improve logging" (95c864c7) · Commits · e / devices / FP5 / android_hardware_qcom_audio

post_proc/bass_boost.c

+13 −14

Original line number	Diff line number	Diff line
		@@ -47,13 +47,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);
		@@ -74,7 +75,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;

		@@ -100,12 +101,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;

		@@ -127,13 +126,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;
		@@ -149,7 +147,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) \|\|
		@@ -166,6 +164,7 @@ int bassboost_set_device(effect_context_t *context, uint32_t device)
		offload_bassboost_send_params(bass_ctxt->ctl,
		bass_ctxt->offload_bass,
		OFFLOAD_SEND_BASSBOOST_ENABLE_FLAG);
		ALOGI("%s: ctxt %p, disabled based on device", __func__, bass_ctxt);
		}
		} else {
		if (!offload_bassboost_get_enable_flag(&(bass_ctxt->offload_bass)) &&
		@@ -193,7 +192,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;
		@@ -223,7 +222,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)) {
		@@ -241,7 +240,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)
		@@ -256,9 +255,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,
		@@ -271,7 +270,7 @@ int bassboost_stop(effect_context_t context, output_context_t output)
		{
		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,
		@@ -512,7 +514,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)) {
		@@ -545,6 +547,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 = -EINVAL;
		goto exit;
		@@ -598,7 +601,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:
		@@ -613,7 +615,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: {
		@@ -623,7 +624,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;
		}
		@@ -643,7 +644,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;
		}
		@@ -659,7 +660,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;
		@@ -675,7 +676,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
		@@ -29,6 +29,12 @@

		#define LOG_TAG "offload_effect_api"
		#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 <stdbool.h>
		#include <cutils/log.h>
		@@ -99,34 +105,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;
		}

		@@ -137,7 +143,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*/
		@@ -175,41 +181,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;
		}

		@@ -220,7 +226,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*/
		@@ -265,25 +271,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;
		}
		@@ -293,7 +299,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;
		@@ -311,7 +317,7 @@ int offload_eq_send_params(struct mixer_ctl *ctl, struct eq_params eq,
		int *p_param_values = param_values;
		uint32_t i;

		ALOGV("%s", __func__);
		ALOGV("%s: flags 0x%x", __func__, param_send_flags);
		if (eq.config.preset_id < -1 ) {
		ALOGV("No Valid preset to set");
		return 0;
		@@ -365,110 +371,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;
		}

		@@ -479,7 +485,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
		@@ -87,7 +87,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;
		}
		@@ -95,7 +95,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 {
		@@ -118,7 +118,7 @@ int equalizer_set_band_level(equalizer_context_t *context, int32_t band,

		int equalizer_get_center_frequency(equalizer_context_t *context, 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;
		}
		@@ -126,7 +126,7 @@ int equalizer_get_center_frequency(equalizer_context_t *context, int32_t band)
		int equalizer_get_band_freq_range(equalizer_context_t *context, 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;
		@@ -136,7 +136,7 @@ int equalizer_get_band(equalizer_context_t *context, 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;
		@@ -147,7 +147,7 @@ int equalizer_get_band(equalizer_context_t *context, 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;
		}

		@@ -155,7 +155,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] =
		@@ -176,7 +176,8 @@ int equalizer_set_preset(equalizer_context_t *context, int preset)
		const char * equalizer_get_preset_name(equalizer_context_t *context,
		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 {
		@@ -186,7 +187,7 @@ const char * equalizer_get_preset_name(equalizer_context_t *context,

		int equalizer_get_num_presets(equalizer_context_t *context)
		{
		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 *);
		}
		@@ -203,7 +204,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;

		@@ -255,18 +256,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;
		@@ -276,7 +274,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;
		@@ -286,7 +283,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;
		@@ -297,25 +293,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;
		@@ -327,7 +319,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;
		@@ -357,13 +348,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)) {
		@@ -373,7 +363,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) {
		@@ -383,7 +372,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;
		@@ -411,7 +399,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);
		@@ -427,7 +415,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;
		@@ -459,7 +447,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);
		@@ -475,7 +463,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)
		@@ -489,7 +477,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)
		@@ -503,7 +491,7 @@ int equalizer_stop(effect_context_t context, output_context_t output)
		{
		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

+28 −42

File changed.

Preview size limit exceeded, changes collapsed.