Revert^2 "LoudnessEnhancer: Fix gain precision and glitching" (b7e5a253) · Commits · e / os / android_frameworks_av

media/libeffects/loudness/EffectLoudnessEnhancer.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -403,7 +403,7 @@ int LE_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
	case LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB:		case LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB:
	pContext->mTargetGainmB = ((int32_t )p->data + 1);		pContext->mTargetGainmB = ((int32_t )p->data + 1);
	ALOGV("set target gain(mB) = %d", pContext->mTargetGainmB);		ALOGV("set target gain(mB) = %d", pContext->mTargetGainmB);
	LE_reset(pContext); // apply parameter update		pContext->mCompressor->set_target_gain(pow(10, pContext->mTargetGainmB / 2000.f));
	break;		break;
	default:		default:
	(int32_t )pReplyData = -EINVAL;		(int32_t )pReplyData = -EINVAL;

media/libeffects/loudness/aidl/LoudnessEnhancerContext.cpp

+9 −3

Original line number	Original line	Diff line number	Diff line
	@@ -43,11 +43,17 @@ RetCode LoudnessEnhancerContext::disable() {
	return RetCode::SUCCESS;		return RetCode::SUCCESS;
	}		}

			RetCode LoudnessEnhancerContext::reset() {
			const float targetAmp = pow(10, mGain / 2000.0f); // mB to linear amplification
			LOG(VERBOSE) << __func__ << "Target gain = " << mGain << "mB <=> factor = " << targetAmp;
			mCompressor->Initialize(targetAmp, mCommon.input.base.sampleRate);
			return RetCode::SUCCESS;
			}

	RetCode LoudnessEnhancerContext::setLeGain(int gainMb) {		RetCode LoudnessEnhancerContext::setLeGain(int gainMb) {
	float targetAmp = pow(10, gainMb / 2000.0f); // mB to linear amplification
	if (mCompressor != nullptr) {		if (mCompressor != nullptr) {
	// Get samplingRate from input		const float targetAmp = pow(10, gainMb / 2000.f); // mB to linear amplification
	mCompressor->Initialize(targetAmp, mCommon.input.base.sampleRate);		mCompressor->set_target_gain(targetAmp);
	}		}
	mGain = gainMb;		mGain = gainMb;
	return RetCode::SUCCESS;		return RetCode::SUCCESS;

media/libeffects/loudness/aidl/LoudnessEnhancerContext.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -36,7 +36,7 @@ class LoudnessEnhancerContext final : public EffectContext {

	RetCode enable() override;		RetCode enable() override;
	RetCode disable() override;		RetCode disable() override;
			RetCode reset() override;
	RetCode setLeGain(int gainMb);		RetCode setLeGain(int gainMb);
	int getLeGain() const { return mGain; }		int getLeGain() const { return mGain; }

media/libeffects/loudness/common/core/basic_types.h

deleted100644 → 0

+0 −114

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef LE_FX_ENGINE_COMMON_CORE_BASIC_TYPES_H_
	#define LE_FX_ENGINE_COMMON_CORE_BASIC_TYPES_H_

	#include <stddef.h>
	#include <stdlib.h>
	#include <string>
	using ::std::string;
	using ::std::basic_string;
	#include <vector>
	using ::std::vector;

	#include "common/core/os.h"

	// -----------------------------------------------------------------------------
	// Definitions of common basic types:
	// -----------------------------------------------------------------------------

	#if !defined(G_COMPILE) && !defined(BASE_INTEGRAL_TYPES_H_)

	namespace le_fx {

	typedef signed char schar;
	typedef signed char int8;
	typedef short int16;
	typedef int int32;
	typedef long long int64;

	typedef unsigned char uint8;
	typedef unsigned short uint16;
	typedef unsigned int uint32;
	typedef unsigned long long uint64;

	} // namespace le_fx

	#endif

	namespace le_fx {

	struct FloatArray {
	int length;
	float *data;

	FloatArray(void) {
	data = NULL;
	length = 0;
	}
	};

	struct Int16Array {
	int length;
	int16 *data;

	Int16Array(void) {
	data = NULL;
	length = 0;
	}
	};

	struct Int32Array {
	int length;
	int32 *data;

	Int32Array(void) {
	data = NULL;
	length = 0;
	}
	};

	struct Int8Array {
	int length;
	uint8 *data;

	Int8Array(void) {
	data = NULL;
	length = 0;
	}
	};

	//
	// Simple wrapper for waveform data:
	//
	class WaveData : public vector<int16> {
	public:
	WaveData();
	~WaveData();

	void Set(int number_samples, int sampling_rate, int16 *data);
	int sample_rate(void) const;
	void set_sample_rate(int sample_rate);
	bool Equals(const WaveData &wave_data, int threshold = 0) const;

	private:
	int sample_rate_;
	};

	} // namespace le_fx

	#endif // LE_FX_ENGINE_COMMON_CORE_BASIC_TYPES_H_

media/libeffects/loudness/common/core/byte_swapper.h

deleted100644 → 0

+0 −151

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef LE_FX_ENGINE_COMMON_CORE_BYTE_SWAPPER_H_
	#define LE_FX_ENGINE_COMMON_CORE_BYTE_SWAPPER_H_

	#include <stdio.h>
	#include <string.h>

	#include "common/core/basic_types.h"
	#include "common/core/os.h"

	namespace le_fx {

	namespace arch {

	inline bool IsLittleEndian(void) {
	int16 word = 1;
	char cp = reinterpret_cast<char >(&word);
	return cp[0] != 0;
	}

	inline bool IsBigEndian(void) {
	return !IsLittleEndian();
	}

	template <typename T, unsigned int kValSize>
	struct ByteSwapper {
	static T Swap(const T &val) {
	T new_val = val;
	char first = &new_val, last = first + kValSize - 1, x;
	for (; first < last; ++first, --last) {
	x = *last;
	last = first;
	*first = x;
	}
	return new_val;
	}
	};

	template <typename T>
	struct ByteSwapper<T, 1> {
	static T Swap(const T &val) {
	return val;
	}
	};

	template <typename T>
	struct ByteSwapper<T, 2> {
	static T Swap(const T &val) {
	T new_val;
	const char o = (const char )&val;
	char p = reinterpret_cast<char >(&new_val);
	p[0] = o[1];
	p[1] = o[0];
	return new_val;
	}
	};

	template <typename T>
	struct ByteSwapper<T, 4> {
	static T Swap(const T &val) {
	T new_val;
	const char o = (const char )&val;
	char p = reinterpret_cast<char >(&new_val);
	p[0] = o[3];
	p[1] = o[2];
	p[2] = o[1];
	p[3] = o[0];
	return new_val;
	}
	};

	template <typename T>
	struct ByteSwapper<T, 8> {
	static T Swap(const T &val) {
	T new_val = val;
	const char o = (const char )&val;
	char p = reinterpret_cast<char >(&new_val);
	p[0] = o[7];
	p[1] = o[6];
	p[2] = o[5];
	p[3] = o[4];
	p[4] = o[3];
	p[5] = o[2];
	p[6] = o[1];
	p[7] = o[0];
	return new_val;
	}
	};

	template <typename T>
	T SwapBytes(const T &val, bool force_swap) {
	if (force_swap) {
	#if !defined(LE_FX__NEED_BYTESWAP)
	return ByteSwapper<T, sizeof(T)>::Swap(val);
	#else
	return val;
	#endif // !LE_FX_NEED_BYTESWAP
	} else {
	#if !defined(LE_FX_NEED_BYTESWAP)
	return val;
	#else
	return ByteSwapper<T, sizeof(T)>::Swap(val);
	#endif // !LE_FX_NEED_BYTESWAP
	}
	}

	template <typename T>
	const T SwapBytes(const T vals, unsigned int num_items, bool force_swap) {
	if (force_swap) {
	#if !defined(LE_FX_NEED_BYTESWAP)
	T writeable_vals = const_cast<T >(vals);
	for (unsigned int i = 0; i < num_items; i++) {
	writeable_vals[i] = ByteSwapper<T, sizeof(T)>::Swap(vals[i]);
	}
	return writeable_vals;
	#else
	return vals;
	#endif // !LE_FX_NEED_BYTESWAP
	} else {
	#if !defined(LE_FX_NEED_BYTESWAP)
	return vals;
	#else
	T writeable_vals = const_cast<T >(vals);
	for (unsigned int i = 0; i < num_items; i++) {
	writeable_vals[i] = ByteSwapper<T, sizeof(T)>::Swap(vals[i]);
	}
	return writeable_vals;
	#endif // !LE_FX_NEED_BYTESWAP
	}
	}

	} // namespace arch

	} // namespace le_fx

	#endif // LE_FX_ENGINE_COMMON_CORE_BYTE_SWAPPER_H_