Merge "post_proc: Support Headphone:X in offload and non tunnel modes" (b4790443) · Commits · e / os / android_hardware_qcom_audio

post_proc/Android.mk

+4 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,10 @@ LOCAL_MODULE_TAGS := optional

		LOCAL_CFLAGS += -O2 -fvisibility=hidden

		ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DTS_EAGLE)), true)
		LOCAL_CFLAGS += -DHW_ACC_HPX
		endif

		LOCAL_MODULE:= libhwacceffectswrapper

		include $(BUILD_STATIC_LIBRARY)

post_proc/EffectsHwAcc.cpp

+28 −0

Original line number	Diff line number	Diff line
		@@ -343,5 +343,33 @@ void EffectsHwAcc::setBufferProvider(AudioBufferProvider **bufferProvider,
		}
		}

		#ifdef HW_ACC_HPX
		void EffectsHwAcc::updateHPXState(uint32_t state)
		{
		EffectsBufferProvider *pHwAccbp = mBufferProvider;
		if (pHwAccbp) {
		ALOGV("updateHPXState: %d", state);
		int cmdStatus, status;
		uint32_t replySize = sizeof(int);
		uint32_t data = state;
		uint32_t size = (sizeof(effect_param_t) + 2 * sizeof(int32_t));
		uint32_t buf32[size];
		effect_param_t param = (effect_param_t )buf32;

		param->psize = sizeof(int32_t);
		(int32_t )param->data = HW_ACCELERATOR_HPX_STATE;
		param->vsize = sizeof(int32_t);
		memcpy((param->data + param->psize), &data, param->vsize);
		status = (*pHwAccbp->mEffectsHandle)->command(pHwAccbp->mEffectsHandle,
		EFFECT_CMD_SET_PARAM,
		sizeof(effect_param_t) + param->psize +
		param->vsize,
		param, &replySize, &cmdStatus);

		if ((status != 0) \|\| (cmdStatus != 0))
		ALOGE("error %d while updating HW ACC HPX BYPASS state", status);
		}
		}
		#endif
		// ----------------------------------------------------------------------------
		}; // namespace android

post_proc/EffectsHwAcc.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,10 @@ public:
		int frameCount);
		virtual void setBufferProvider(AudioBufferProvider **bufferProvider,
		AudioBufferProvider **trackBufferProvider);
		#ifdef HW_ACC_HPX
		virtual void updateHPXState(uint32_t state);
		#endif

		/* AudioBufferProvider that wraps a track AudioBufferProvider by a call to
		h/w accelerated effect */
		class EffectsBufferProvider : public AudioBufferProvider {

post_proc/bundle.c

+126 −0

Original line number	Diff line number	Diff line
		@@ -326,6 +326,132 @@ exit:
		return ret;
		}

		__attribute__ ((visibility ("default")))
		int offload_effects_bundle_set_hpx_state(bool hpx_state)
		{
		int ret = 0;
		struct listnode *node;

		ALOGV("%s hpx state: %d", __func__, hpx_state);

		if (lib_init() != 0)
		return init_status;

		pthread_mutex_lock(&lock);

		if (hpx_state) {
		/* set ramp down */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		struct soft_volume_params vol;
		vol.master_gain = 0x0;
		offload_transition_soft_volume_send_params(out_ctxt->ref_ctl, vol,
		OFFLOAD_SEND_TRANSITION_SOFT_VOLUME_GAIN_MASTER);
		}
		/* wait for ramp down duration - 30msec */
		usleep(30000);
		/* disable effects modules */
		list_for_each(node, &active_outputs_list) {
		struct listnode *fx_node;
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		list_for_each(fx_node, &out_ctxt->effects_list) {
		effect_context_t *fx_ctxt = node_to_item(fx_node,
		effect_context_t,
		output_node);
		if ((fx_ctxt->state == EFFECT_STATE_ACTIVE) &&
		(fx_ctxt->ops.stop != NULL))
		fx_ctxt->ops.stop(fx_ctxt, out_ctxt);
		}
		out_ctxt->ctl = NULL;
		}
		/* set the channel mixer */
		list_for_each(node, &active_outputs_list) {
		/* send command to set channel mixer */
		}
		/* enable hpx modules */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		offload_hpx_send_params(out_ctxt->ref_ctl,
		OFFLOAD_SEND_HPX_STATE_ON);
		}
		/* wait for transition state - 50msec */
		usleep(50000);
		/* set ramp up */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		struct soft_volume_params vol;
		vol.master_gain = 0x2000;
		offload_transition_soft_volume_send_params(out_ctxt->ref_ctl, vol,
		OFFLOAD_SEND_TRANSITION_SOFT_VOLUME_GAIN_MASTER);
		}
		} else {
		/* set ramp down */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		struct soft_volume_params vol;
		vol.master_gain = 0x0;
		offload_transition_soft_volume_send_params(out_ctxt->ref_ctl, vol,
		OFFLOAD_SEND_TRANSITION_SOFT_VOLUME_GAIN_MASTER);
		}
		/* wait for ramp down duration - 30msec */
		usleep(30000);
		/* disable effects modules */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		offload_hpx_send_params(out_ctxt->ref_ctl,
		OFFLOAD_SEND_HPX_STATE_OFF);
		}
		/* set the channel mixer */
		list_for_each(node, &active_outputs_list) {
		/* send command to set channel mixer */
		}
		/* enable effects modules */
		list_for_each(node, &active_outputs_list) {
		struct listnode *fx_node;
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		out_ctxt->ctl = out_ctxt->ref_ctl;
		list_for_each(fx_node, &out_ctxt->effects_list) {
		effect_context_t *fx_ctxt = node_to_item(fx_node,
		effect_context_t,
		output_node);
		if ((fx_ctxt->state == EFFECT_STATE_ACTIVE) &&
		(fx_ctxt->ops.start != NULL))
		fx_ctxt->ops.start(fx_ctxt, out_ctxt);
		}
		}
		/* wait for transition state - 50msec */
		usleep(50000);
		/* set ramp up */
		list_for_each(node, &active_outputs_list) {
		output_context_t *out_ctxt = node_to_item(node,
		output_context_t,
		outputs_list_node);
		struct soft_volume_params vol;
		vol.master_gain = 0x2000;
		offload_transition_soft_volume_send_params(out_ctxt->ref_ctl, vol,
		OFFLOAD_SEND_TRANSITION_SOFT_VOLUME_GAIN_MASTER);
		}
		}

		exit:
		pthread_mutex_unlock(&lock);
		return ret;
		}

		/*
		* Effect operations
		*/

post_proc/effect_api.c

+35 −0

Original line number	Diff line number	Diff line
		@@ -882,3 +882,38 @@ int offload_transition_soft_volume_send_params(struct mixer_ctl *ctl,

		return 0;
		}

		static int hpx_send_params(eff_mode_t mode, void *ctl,
		unsigned param_send_flags)
		{
		int param_values[128] = {0};
		int *p_param_values = param_values;
		uint32_t i;

		ALOGV("%s", __func__);
		if (param_send_flags & OFFLOAD_SEND_HPX_STATE_OFF) {
		*p_param_values++ = DTS_EAGLE_MODULE_ENABLE;
		p_param_values++ = 0; / hpx off*/
		} else if (param_send_flags & OFFLOAD_SEND_HPX_STATE_ON) {
		*p_param_values++ = DTS_EAGLE_MODULE_ENABLE;
		p_param_values++ = 1; / hpx on*/
		}

		if ((mode == OFFLOAD) && ctl)
		mixer_ctl_set_array(ctl, param_values, ARRAY_SIZE(param_values));
		else {
		if (ioctl((int )ctl, AUDIO_EFFECTS_SET_PP_PARAMS, param_values) < 0)
		ALOGE("%s: sending h/w acc hpx state params fail[%d]", __func__, errno);
		}
		return 0;
		}

		int offload_hpx_send_params(struct mixer_ctl *ctl, unsigned param_send_flags)
		{
		return hpx_send_params(OFFLOAD, (void *)ctl, param_send_flags);
		}

		int hw_acc_hpx_send_params(int fd, unsigned param_send_flags)
		{
		return hpx_send_params(HW_ACCELERATOR, (void *)&fd, param_send_flags);
		}