Merge "EffectDownmix: Remove obsolete define" am: a4c95a851c (fe2a4056) · Commits · e / os / android_frameworks_av

media/libeffects/downmix/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -33,7 +33,6 @@ cc_library_shared {
		relative_install_path: "soundfx",

		cflags: [
		"-DBUILD_FLOAT",
		"-fvisibility=hidden",
		"-Wall",
		"-Werror",

media/libeffects/downmix/EffectDownmix.c

+3 −328

Original line number	Diff line number	Diff line
		@@ -31,13 +31,8 @@
		// Do not submit with DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER defined, strictly for testing
		//#define DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER 0

		#ifdef BUILD_FLOAT
		#define MINUS_3_DB_IN_FLOAT 0.70710678f // -3dB = 0.70710678f
		const audio_format_t gTargetFormat = AUDIO_FORMAT_PCM_FLOAT;
		#else
		#define MINUS_3_DB_IN_Q19_12 2896 // -3dB = 0.707 * 2^12 = 2896
		const audio_format_t gTargetFormat = AUDIO_FORMAT_PCM_16_BIT;
		#endif

		// subset of possible audio_channel_mask_t values, and AUDIO_CHANNEL_OUT_* renamed to CHANNEL_MASK_*
		typedef enum {
		@@ -88,7 +83,7 @@ static const effect_descriptor_t * const gDescriptors[] = {

		// number of effects in this library
		const int kNbEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
		#ifdef BUILD_FLOAT

		static LVM_FLOAT clamp_float(LVM_FLOAT a) {
		if (a > 1.0f) {
		return 1.0f;
		@@ -100,7 +95,7 @@ static LVM_FLOAT clamp_float(LVM_FLOAT a) {
		return a;
		}
		}
		#endif

		/*----------------------------------------------------------------------------
		* Test code
		--------------------------------------------------------------------------/
		@@ -303,106 +298,6 @@ int32_t DownmixLib_GetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t
		return -EINVAL;
		}

		#ifndef BUILD_FLOAT
		/--- Effect Control Interface Implementation ---/

		static int Downmix_Process(effect_handle_t self,
		audio_buffer_t inBuffer, audio_buffer_t outBuffer) {

		downmix_object_t *pDownmixer;
		int16_t pSrc, pDst;
		downmix_module_t pDwmModule = (downmix_module_t )self;

		if (pDwmModule == NULL) {
		return -EINVAL;
		}

		if (inBuffer == NULL \|\| inBuffer->raw == NULL \|\|
		outBuffer == NULL \|\| outBuffer->raw == NULL \|\|
		inBuffer->frameCount != outBuffer->frameCount) {
		return -EINVAL;
		}

		pDownmixer = (downmix_object_t*) &pDwmModule->context;

		if (pDownmixer->state == DOWNMIX_STATE_UNINITIALIZED) {
		ALOGE("Downmix_Process error: trying to use an uninitialized downmixer");
		return -EINVAL;
		} else if (pDownmixer->state == DOWNMIX_STATE_INITIALIZED) {
		ALOGE("Downmix_Process error: trying to use a non-configured downmixer");
		return -ENODATA;
		}

		pSrc = inBuffer->s16;
		pDst = outBuffer->s16;
		size_t numFrames = outBuffer->frameCount;

		const bool accumulate =
		(pDwmModule->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
		const uint32_t downmixInputChannelMask = pDwmModule->config.inputCfg.channels;

		switch(pDownmixer->type) {

		case DOWNMIX_TYPE_STRIP:
		if (accumulate) {
		while (numFrames) {
		pDst[0] = clamp16(pDst[0] + pSrc[0]);
		pDst[1] = clamp16(pDst[1] + pSrc[1]);
		pSrc += pDownmixer->input_channel_count;
		pDst += 2;
		numFrames--;
		}
		} else {
		while (numFrames) {
		pDst[0] = pSrc[0];
		pDst[1] = pSrc[1];
		pSrc += pDownmixer->input_channel_count;
		pDst += 2;
		numFrames--;
		}
		}
		break;

		case DOWNMIX_TYPE_FOLD:
		#ifdef DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER
		// bypass the optimized downmix routines for the common formats
		if (!Downmix_foldGeneric(
		downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {
		ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);
		return -EINVAL;
		}
		break;
		#endif
		// optimize for the common formats
		switch((downmix_input_channel_mask_t)downmixInputChannelMask) {
		case CHANNEL_MASK_QUAD_BACK:
		case CHANNEL_MASK_QUAD_SIDE:
		Downmix_foldFromQuad(pSrc, pDst, numFrames, accumulate);
		break;
		case CHANNEL_MASK_5POINT1_BACK:
		case CHANNEL_MASK_5POINT1_SIDE:
		Downmix_foldFrom5Point1(pSrc, pDst, numFrames, accumulate);
		break;
		case CHANNEL_MASK_7POINT1:
		Downmix_foldFrom7Point1(pSrc, pDst, numFrames, accumulate);
		break;
		default:
		if (!Downmix_foldGeneric(
		downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {
		ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);
		return -EINVAL;
		}
		break;
		}
		break;

		default:
		return -EINVAL;
		}

		return 0;
		}
		#else /BUILD_FLOAT/
		/--- Effect Control Interface Implementation ---/

		static int Downmix_Process(effect_handle_t self,
		@@ -503,7 +398,6 @@ static int Downmix_Process(effect_handle_t self,

		return 0;
		}
		#endif

		static int Downmix_Command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
		void pCmdData, uint32_t replySize, void *pReplyData) {
		@@ -940,35 +834,6 @@ int Downmix_getParameter(downmix_object_t pDownmixer, int32_t param, uint32_t
		*
		*----------------------------------------------------------------------------
		*/
		#ifndef BUILD_FLOAT
		void Downmix_foldFromQuad(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate) {
		// sample at index 0 is FL
		// sample at index 1 is FR
		// sample at index 2 is RL
		// sample at index 3 is RR
		if (accumulate) {
		while (numFrames) {
		// FL + RL
		pDst[0] = clamp16(pDst[0] + ((pSrc[0] + pSrc[2]) >> 1));
		// FR + RR
		pDst[1] = clamp16(pDst[1] + ((pSrc[1] + pSrc[3]) >> 1));
		pSrc += 4;
		pDst += 2;
		numFrames--;
		}
		} else { // same code as above but without adding and clamping pDst[i] to itself
		while (numFrames) {
		// FL + RL
		pDst[0] = clamp16((pSrc[0] + pSrc[2]) >> 1);
		// FR + RR
		pDst[1] = clamp16((pSrc[1] + pSrc[3]) >> 1);
		pSrc += 4;
		pDst += 2;
		numFrames--;
		}
		}
		}
		#else
		void Downmix_foldFromQuad(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate) {
		// sample at index 0 is FL
		// sample at index 1 is FR
		@@ -996,7 +861,6 @@ void Downmix_foldFromQuad(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bo
		}
		}
		}
		#endif

		/*----------------------------------------------------------------------------
		* Downmix_foldFrom5Point1()
		@@ -1015,52 +879,6 @@ void Downmix_foldFromQuad(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bo
		*
		*----------------------------------------------------------------------------
		*/
		#ifndef BUILD_FLOAT
		void Downmix_foldFrom5Point1(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate) {
		int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
		// sample at index 0 is FL
		// sample at index 1 is FR
		// sample at index 2 is FC
		// sample at index 3 is LFE
		// sample at index 4 is RL
		// sample at index 5 is RR
		// code is mostly duplicated between the two values of accumulate to avoid repeating the test
		// for every sample
		if (accumulate) {
		while (numFrames) {
		// centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
		centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
		+ (pSrc[3] * MINUS_3_DB_IN_Q19_12);
		// FL + centerPlusLfeContrib + RL
		lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
		// FR + centerPlusLfeContrib + RR
		rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
		// accumulate in destination
		pDst[0] = clamp16(pDst[0] + (lt >> 13));
		pDst[1] = clamp16(pDst[1] + (rt >> 13));
		pSrc += 6;
		pDst += 2;
		numFrames--;
		}
		} else { // same code as above but without adding and clamping pDst[i] to itself
		while (numFrames) {
		// centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
		centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
		+ (pSrc[3] * MINUS_3_DB_IN_Q19_12);
		// FL + centerPlusLfeContrib + RL
		lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
		// FR + centerPlusLfeContrib + RR
		rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
		// store in destination
		pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
		pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
		pSrc += 6;
		pDst += 2;
		numFrames--;
		}
		}
		}
		#else
		void Downmix_foldFrom5Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate) {
		LVM_FLOAT lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
		// sample at index 0 is FL
		@@ -1105,7 +923,6 @@ void Downmix_foldFrom5Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames,
		}
		}
		}
		#endif

		/*----------------------------------------------------------------------------
		* Downmix_foldFrom7Point1()
		@@ -1124,54 +941,6 @@ void Downmix_foldFrom5Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames,
		*
		*----------------------------------------------------------------------------
		*/
		#ifndef BUILD_FLOAT
		void Downmix_foldFrom7Point1(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate) {
		int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
		// sample at index 0 is FL
		// sample at index 1 is FR
		// sample at index 2 is FC
		// sample at index 3 is LFE
		// sample at index 4 is RL
		// sample at index 5 is RR
		// sample at index 6 is SL
		// sample at index 7 is SR
		// code is mostly duplicated between the two values of accumulate to avoid repeating the test
		// for every sample
		if (accumulate) {
		while (numFrames) {
		// centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
		centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
		+ (pSrc[3] * MINUS_3_DB_IN_Q19_12);
		// FL + centerPlusLfeContrib + SL + RL
		lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
		// FR + centerPlusLfeContrib + SR + RR
		rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
		//accumulate in destination
		pDst[0] = clamp16(pDst[0] + (lt >> 13));
		pDst[1] = clamp16(pDst[1] + (rt >> 13));
		pSrc += 8;
		pDst += 2;
		numFrames--;
		}
		} else { // same code as above but without adding and clamping pDst[i] to itself
		while (numFrames) {
		// centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
		centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
		+ (pSrc[3] * MINUS_3_DB_IN_Q19_12);
		// FL + centerPlusLfeContrib + SL + RL
		lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
		// FR + centerPlusLfeContrib + SR + RR
		rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
		// store in destination
		pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
		pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
		pSrc += 8;
		pDst += 2;
		numFrames--;
		}
		}
		}
		#else
		void Downmix_foldFrom7Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate) {
		LVM_FLOAT lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
		// sample at index 0 is FL
		@@ -1218,7 +987,7 @@ void Downmix_foldFrom7Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames,
		}
		}
		}
		#endif

		/*----------------------------------------------------------------------------
		* Downmix_foldGeneric()
		*----------------------------------------------------------------------------
		@@ -1245,99 +1014,6 @@ void Downmix_foldFrom7Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames,
		*
		*----------------------------------------------------------------------------
		*/
		#ifndef BUILD_FLOAT
		bool Downmix_foldGeneric(
		uint32_t mask, int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate) {

		if (!Downmix_validChannelMask(mask)) {
		return false;
		}

		const bool hasSides = (mask & kSides) != 0;
		const bool hasBacks = (mask & kBacks) != 0;

		const int numChan = audio_channel_count_from_out_mask(mask);
		const bool hasFC = ((mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) == AUDIO_CHANNEL_OUT_FRONT_CENTER);
		const bool hasLFE =
		((mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) == AUDIO_CHANNEL_OUT_LOW_FREQUENCY);
		const bool hasBC = ((mask & AUDIO_CHANNEL_OUT_BACK_CENTER) == AUDIO_CHANNEL_OUT_BACK_CENTER);
		// compute at what index each channel is: samples will be in the following order:
		// FL FR FC LFE BL BR BC SL SR
		// when a channel is not present, its index is set to the same as the index of the preceding
		// channel
		const int indexFC = hasFC ? 2 : 1; // front center
		const int indexLFE = hasLFE ? indexFC + 1 : indexFC; // low frequency
		const int indexBL = hasBacks ? indexLFE + 1 : indexLFE; // back left
		const int indexBR = hasBacks ? indexBL + 1 : indexBL; // back right
		const int indexBC = hasBC ? indexBR + 1 : indexBR; // back center
		const int indexSL = hasSides ? indexBC + 1 : indexBC; // side left
		const int indexSR = hasSides ? indexSL + 1 : indexSL; // side right

		int32_t lt, rt, centersLfeContrib; // samples in Q19.12 format
		// code is mostly duplicated between the two values of accumulate to avoid repeating the test
		// for every sample
		if (accumulate) {
		while (numFrames) {
		// compute contribution of FC, BC and LFE
		centersLfeContrib = 0;
		if (hasFC) { centersLfeContrib += pSrc[indexFC]; }
		if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }
		if (hasBC) { centersLfeContrib += pSrc[indexBC]; }
		centersLfeContrib *= MINUS_3_DB_IN_Q19_12;
		// always has FL/FR
		lt = (pSrc[0] << 12);
		rt = (pSrc[1] << 12);
		// mix in sides and backs
		if (hasSides) {
		lt += pSrc[indexSL] << 12;
		rt += pSrc[indexSR] << 12;
		}
		if (hasBacks) {
		lt += pSrc[indexBL] << 12;
		rt += pSrc[indexBR] << 12;
		}
		lt += centersLfeContrib;
		rt += centersLfeContrib;
		// accumulate in destination
		pDst[0] = clamp16(pDst[0] + (lt >> 13));
		pDst[1] = clamp16(pDst[1] + (rt >> 13));
		pSrc += numChan;
		pDst += 2;
		numFrames--;
		}
		} else {
		while (numFrames) {
		// compute contribution of FC, BC and LFE
		centersLfeContrib = 0;
		if (hasFC) { centersLfeContrib += pSrc[indexFC]; }
		if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }
		if (hasBC) { centersLfeContrib += pSrc[indexBC]; }
		centersLfeContrib *= MINUS_3_DB_IN_Q19_12;
		// always has FL/FR
		lt = (pSrc[0] << 12);
		rt = (pSrc[1] << 12);
		// mix in sides and backs
		if (hasSides) {
		lt += pSrc[indexSL] << 12;
		rt += pSrc[indexSR] << 12;
		}
		if (hasBacks) {
		lt += pSrc[indexBL] << 12;
		rt += pSrc[indexBR] << 12;
		}
		lt += centersLfeContrib;
		rt += centersLfeContrib;
		// store in destination
		pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
		pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
		pSrc += numChan;
		pDst += 2;
		numFrames--;
		}
		}
		return true;
		}
		#else
		bool Downmix_foldGeneric(
		uint32_t mask, LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate) {

		@@ -1429,4 +1105,3 @@ bool Downmix_foldGeneric(
		}
		return true;
		}
		#endif

media/libeffects/downmix/EffectDownmix.h

+1 −10

Original line number	Diff line number	Diff line
		@@ -27,9 +27,8 @@
		*/

		#define DOWNMIX_OUTPUT_CHANNELS AUDIO_CHANNEL_OUT_STEREO
		#ifdef BUILD_FLOAT
		#define LVM_FLOAT float
		#endif

		typedef enum {
		DOWNMIX_STATE_UNINITIALIZED,
		DOWNMIX_STATE_INITIALIZED,
		@@ -97,18 +96,10 @@ int Downmix_Configure(downmix_module_t pDwmModule, effect_config_t pConfig, bo
		int Downmix_Reset(downmix_object_t *pDownmixer, bool init);
		int Downmix_setParameter(downmix_object_t pDownmixer, int32_t param, uint32_t size, void pValue);
		int Downmix_getParameter(downmix_object_t pDownmixer, int32_t param, uint32_t pSize, void *pValue);
		#ifdef BUILD_FLOAT
		void Downmix_foldFromQuad(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate);
		void Downmix_foldFrom5Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate);
		void Downmix_foldFrom7Point1(LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate);
		bool Downmix_foldGeneric(
		uint32_t mask, LVM_FLOAT pSrc, LVM_FLOAT pDst, size_t numFrames, bool accumulate);
		#else
		void Downmix_foldFromQuad(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate);
		void Downmix_foldFrom5Point1(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate);
		void Downmix_foldFrom7Point1(int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate);
		bool Downmix_foldGeneric(
		uint32_t mask, int16_t pSrc, int16_tpDst, size_t numFrames, bool accumulate);
		#endif

		#endif /ANDROID_EFFECTDOWNMIX_H_/