Clean up background audio processing code (3b9ba852) · Commits · e / os / android_frameworks_av

libvideoeditor/lvpp/VideoEditorBGAudioProcessing.cpp

+128 −162

Original line number	Diff line number	Diff line
		@@ -26,25 +26,25 @@ VideoEditorBGAudioProcessing ::VideoEditorBGAudioProcessing() {

		LOGV("VideoEditorBGAudioProcessing:: Construct VideoEditorBGAudioProcessing ");

		VideoEditorBGAudioProcessing::mAudVolArrIndex = 0;
		VideoEditorBGAudioProcessing::mDoDucking = 0;
		VideoEditorBGAudioProcessing::mDucking_enable = 0;
		VideoEditorBGAudioProcessing::mDucking_lowVolume = 0;
		VideoEditorBGAudioProcessing::mDucking_threshold = 0;
		VideoEditorBGAudioProcessing::mDuckingFactor = 0;
		mAudVolArrIndex = 0;
		mDoDucking = 0;
		mDucking_enable = 0;
		mDucking_lowVolume = 0;
		mDucking_threshold = 0;
		mDuckingFactor = 0;

		VideoEditorBGAudioProcessing::mBTVolLevel = 0;
		VideoEditorBGAudioProcessing::mPTVolLevel = 0;
		mBTVolLevel = 0;
		mPTVolLevel = 0;

		VideoEditorBGAudioProcessing::mIsSSRCneeded = 0;
		VideoEditorBGAudioProcessing::mChannelConversion = 0;
		mIsSSRCneeded = 0;
		mChannelConversion = 0;

		VideoEditorBGAudioProcessing::mBTFormat = MONO_16_BIT;
		mBTFormat = MONO_16_BIT;

		VideoEditorBGAudioProcessing::mInSampleRate = 8000;
		VideoEditorBGAudioProcessing::mOutSampleRate = 16000;
		VideoEditorBGAudioProcessing::mPTChannelCount = 2;
		VideoEditorBGAudioProcessing::mBTChannelCount = 1;
		mInSampleRate = 8000;
		mOutSampleRate = 16000;
		mPTChannelCount = 2;
		mBTChannelCount = 1;
		}

		M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
		@@ -85,7 +85,7 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
		// Since we need to give sample count and not buffer size
		uiPCMsize = pMixedOutBuffer->m_bufferSize/2 ;

		if((this->mDucking_enable) && (this->mPTVolLevel != 0.0)) {
		if ((mDucking_enable) && (mPTVolLevel != 0.0)) {
		// LOGI("VideoEditorBGAudioProcessing:: In Ducking analysis ");
		loopIndex = 0;
		peakDbValue = 0;
		@@ -93,8 +93,7 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(

		pPCM16Sample = (M4OSA_Int16*)pPrimaryTrack->m_dataAddress;

		while( loopIndex < pPrimaryTrack->m_bufferSize/sizeof(M4OSA_Int16))
		{
		while (loopIndex < pPrimaryTrack->m_bufferSize/sizeof(M4OSA_Int16)) {
		if (pPCM16Sample[loopIndex] >= 0) {
		peakDbValue = previousDbValue > pPCM16Sample[loopIndex] ?
		previousDbValue : pPCM16Sample[loopIndex];
		@@ -107,21 +106,19 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
		loopIndex++;
		}

		this->mAudioVolumeArray[this->mAudVolArrIndex] =
		getDecibelSound(peakDbValue);
		mAudioVolumeArray[mAudVolArrIndex] = getDecibelSound(peakDbValue);

		LOGV("VideoEditorBGAudioProcessing:: getDecibelSound %d",
		this->mAudioVolumeArray[this->mAudVolArrIndex]);
		mAudioVolumeArray[mAudVolArrIndex]);

		// WINDOW_SIZE is 10 by default
		// Check for threshold is done after 10 cycles
		if ( this->mAudVolArrIndex >= WINDOW_SIZE -1) {
		this->mDoDucking = isThresholdBreached(this->mAudioVolumeArray,
		this->mAudVolArrIndex,this->mDucking_threshold );

		this->mAudVolArrIndex = 0;
		if (mAudVolArrIndex >= WINDOW_SIZE - 1) {
		mDoDucking = isThresholdBreached(mAudioVolumeArray,
		mAudVolArrIndex,mDucking_threshold );
		mAudVolArrIndex = 0;
		} else {
		this->mAudVolArrIndex++;
		mAudVolArrIndex++;
		}

		//
		@@ -135,25 +132,23 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
		// (500 ms (window under analysis) / 20 ms (sample duration))
		//

		if(this->mDoDucking){
		if ( this->mDuckingFactor > this->mDucking_lowVolume) {
		if (mDoDucking) {
		if (mDuckingFactor > mDucking_lowVolume) {
		// FADE OUT BG Track
		// Increment ducking factor in total steps in factor
		// of low volume steps to reach low volume level
		this->mDuckingFactor -= (this->mDucking_lowVolume);
		}
		else {
		this->mDuckingFactor = this->mDucking_lowVolume;
		mDuckingFactor -= (mDucking_lowVolume);
		} else {
		mDuckingFactor = mDucking_lowVolume;
		}
		} else {
		if ( this->mDuckingFactor < 1.0 ){
		if (mDuckingFactor < 1.0 ) {
		// FADE IN BG Track
		// Increment ducking factor in total steps of
		// low volume factor to reach orig.volume level
		this->mDuckingFactor += (this->mDucking_lowVolume);
		}
		else{
		this->mDuckingFactor = 1.0;
		mDuckingFactor += (mDucking_lowVolume);
		} else {
		mDuckingFactor = 1.0;
		}
		}
		} // end if - mDucking_enable
		@@ -162,27 +157,26 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
		// Mixing Logic

		LOGV("VideoEditorBGAudioProcessing:: Out of Ducking analysis uiPCMsize\
		%d %f %f", this->mDoDucking, this->mDuckingFactor,this->mBTVolLevel);
		%d %f %f", mDoDucking, mDuckingFactor,mBTVolLevel);

		while (uiPCMsize-- > 0) {

		M4OSA_Int32 temp;
		// Set vol factor for BT and PT
		pBTMdata1 = (M4OSA_Int16)(pBTMdata1*this->mBTVolLevel);
		pPTMdata2 = (M4OSA_Int16)(pPTMdata2*this->mPTVolLevel);
		pBTMdata1 = (M4OSA_Int16)(pBTMdata1*mBTVolLevel);
		pPTMdata2 = (M4OSA_Int16)(pPTMdata2*mPTVolLevel);

		// Mix the two samples
		if ( this->mDoDucking) {
		if (mDoDucking) {

		// Duck the BG track to ducking factor value before mixing
		pBTMdata1 = (M4OSA_Int16)((pBTMdata1)*(this->mDuckingFactor));
		pBTMdata1 = (M4OSA_Int16)((pBTMdata1)*(mDuckingFactor));

		// mix as normal case
		pBTMdata1 = (M4OSA_Int16)(pBTMdata1 /2 + *pPTMdata2 /2);
		}
		else {
		} else {

		pBTMdata1 = (M4OSA_Int16)((pBTMdata1)*(this->mDuckingFactor));
		pBTMdata1 = (M4OSA_Int16)((pBTMdata1)*(mDuckingFactor));
		pBTMdata1 = (M4OSA_Int16)(pBTMdata1 /2 + *pPTMdata2 /2);
		}

		@@ -191,17 +185,14 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(

		if (temp > 32767) {
		*pBTMdata1 = -32766; // less then max allowed value
		}
		else{
		} else {
		*pBTMdata1 = (M4OSA_Int16)(-temp);
		}
		}
		else {
		} else {
		temp = (pBTMdata1) 2; // bring to original Amplitude level
		if ( temp > 32768) {
		*pBTMdata1 = 32767; // less than max allowed value
		}
		else {
		} else {
		*pBTMdata1 = (M4OSA_Int16)temp;
		}
		}
		@@ -220,131 +211,106 @@ M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(

		VideoEditorBGAudioProcessing::~VideoEditorBGAudioProcessing() {

		//free(VideoEditorBGAudioProcessing:: pTempBuffer);
		}

		M4OSA_Int32 VideoEditorBGAudioProcessing::calculateOutResampleBufSize() {

		M4OSA_Int32 bufSize =0;

		// This already takes care of channel count in mBTBuffer.m_bufferSize
		bufSize = (this->mOutSampleRate/this->mInSampleRate)*this->mBTBuffer.m_bufferSize;

		return bufSize;
		return (mOutSampleRate / mInSampleRate) * mBTBuffer.m_bufferSize;
		}

		void VideoEditorBGAudioProcessing ::veSetAudioProcessingParams(
		veAudMixSettings gInputParams) {
		const veAudMixSettings& gInputParams) {

		LOGV("VideoEditorBGAudioProcessing:: ENTER lvSetAudioProcessingParams ");
		this->mDucking_enable = gInputParams.lvInDucking_enable;
		this->mDucking_lowVolume = gInputParams.lvInDucking_lowVolume;
		this->mDucking_threshold = gInputParams.lvInDucking_threshold;
		mDucking_enable = gInputParams.lvInDucking_enable;
		mDucking_lowVolume = gInputParams.lvInDucking_lowVolume;
		mDucking_threshold = gInputParams.lvInDucking_threshold;

		this->mPTVolLevel = gInputParams.lvPTVolLevel;
		this->mBTVolLevel = gInputParams.lvBTVolLevel ;
		mPTVolLevel = gInputParams.lvPTVolLevel;
		mBTVolLevel = gInputParams.lvBTVolLevel ;

		this->mBTChannelCount = gInputParams.lvBTChannelCount;
		this->mPTChannelCount = gInputParams.lvPTChannelCount;
		mBTChannelCount = gInputParams.lvBTChannelCount;
		mPTChannelCount = gInputParams.lvPTChannelCount;

		this->mBTFormat = gInputParams.lvBTFormat;
		mBTFormat = gInputParams.lvBTFormat;

		this->mInSampleRate = gInputParams.lvInSampleRate;
		this->mOutSampleRate = gInputParams.lvOutSampleRate;
		mInSampleRate = gInputParams.lvInSampleRate;
		mOutSampleRate = gInputParams.lvOutSampleRate;

		this->mAudVolArrIndex = 0;
		this->mDoDucking = 0;
		this->mDuckingFactor = 1.0; // default
		mAudVolArrIndex = 0;
		mDoDucking = 0;
		mDuckingFactor = 1.0; // default

		LOGV("VideoEditorBGAudioProcessing:: ducking_enable 0x%x \
		ducking_lowVolume %f ducking_threshold %d fPTVolLevel %f BTVolLevel %f",
		this->mDucking_enable, this->mDucking_lowVolume, this->mDucking_threshold,
		this->mPTVolLevel, this->mPTVolLevel);
		mDucking_enable, mDucking_lowVolume, mDucking_threshold,
		mPTVolLevel, mPTVolLevel);

		// Following logc decides if SSRC support is needed for this mixing
		if ( gInputParams.lvInSampleRate != gInputParams.lvOutSampleRate){
		this->mIsSSRCneeded = 1;
		}else{
		this->mIsSSRCneeded = 0;
		}
		mIsSSRCneeded = (gInputParams.lvInSampleRate != gInputParams.lvOutSampleRate);
		if (gInputParams.lvBTChannelCount != gInputParams.lvPTChannelCount){
		if (gInputParams.lvBTChannelCount == 2){
		this->mChannelConversion = 1; // convert to MONO
		mChannelConversion = 1; // convert to MONO
		} else {
		this->mChannelConversion = 2; // Convert to STEREO
		mChannelConversion = 2; // Convert to STEREO
		}
		} else {
		this->mChannelConversion = 0;
		mChannelConversion = 0;
		}
		LOGV("VideoEditorBGAudioProcessing:: EXIT veSetAudioProcessingParams ");
		}


		// Fast way to compute 10 * log(value)
		M4OSA_Int32 VideoEditorBGAudioProcessing::getDecibelSound(M4OSA_UInt32 value) {

		int dbSound = 1;

		if (value == 0) return 0;

		if (value > 0x4000 && value <= 0x8000) // 32768
		dbSound = 90;
		else if (value > 0x2000 && value <= 0x4000) // 16384
		dbSound = 84;
		else if (value > 0x1000 && value <= 0x2000) // 8192
		dbSound = 78;
		else if (value > 0x0800 && value <= 0x1000) // 4028
		dbSound = 72;
		else if (value > 0x0400 && value <= 0x0800) // 2048
		dbSound = 66;
		else if (value > 0x0200 && value <= 0x0400) // 1024
		dbSound = 60;
		else if (value > 0x0100 && value <= 0x0200) // 512
		dbSound = 54;
		else if (value > 0x0080 && value <= 0x0100) // 256
		dbSound = 48;
		else if (value > 0x0040 && value <= 0x0080) // 128
		dbSound = 42;
		else if (value > 0x0020 && value <= 0x0040) // 64
		dbSound = 36;
		else if (value > 0x0010 && value <= 0x0020) // 32
		dbSound = 30;
		else if (value > 0x0008 && value <= 0x0010) //16
		dbSound = 24;
		else if (value > 0x0007 && value <= 0x0008) //8
		dbSound = 24;
		else if (value > 0x0003 && value <= 0x0007) // 4
		dbSound = 18;
		else if (value > 0x0001 && value <= 0x0003) //2
		dbSound = 12;
		else if (value > 0x000 && value <= 0x0001) // 1
		dbSound = 6;
		else
		dbSound = 0;

		return dbSound;
		if (value <= 0 \|\| value > 0x8000) {
		return 0;
		} else if (value > 0x4000) { // 32768
		return 90;
		} else if (value > 0x2000) { // 16384
		return 84;
		} else if (value > 0x1000) { // 8192
		return 78;
		} else if (value > 0x0800) { // 4028
		return 72;
		} else if (value > 0x0400) { // 2048
		return 66;
		} else if (value > 0x0200) { // 1024
		return 60;
		} else if (value > 0x0100) { // 512
		return 54;
		} else if (value > 0x0080) { // 256
		return 48;
		} else if (value > 0x0040) { // 128
		return 42;
		} else if (value > 0x0020) { // 64
		return 36;
		} else if (value > 0x0010) { // 32
		return 30;
		} else if (value > 0x0008) { // 16
		return 24;
		} else if (value > 0x0007) { // 8
		return 24;
		} else if (value > 0x0003) { // 4
		return 18;
		} else if (value > 0x0001) { // 2
		return 12;
		} else { // 1
		return 6;
		}
		}

		M4OSA_Bool VideoEditorBGAudioProcessing::isThresholdBreached(
		M4OSA_Int32* averageValue, M4OSA_Int32 storeCount,
		M4OSA_Int32* averageValue,
		M4OSA_Int32 storeCount,
		M4OSA_Int32 thresholdValue) {

		M4OSA_Bool result = 0;
		int i;
		int finalValue = 0;

		for (i=0; i< storeCount;i++)
		finalValue += averageValue[i];

		finalValue = finalValue/storeCount;

		//printf ("<%d > \t ", finalValue);

		if (finalValue > thresholdValue)
		result = M4OSA_TRUE;
		else
		result = M4OSA_FALSE;

		return result;
		int totalValue = 0;
		for (int i = 0; i < storeCount; ++i) {
		totalValue += averageValue[i];
		}
		return (totalValue / storeCount > thresholdValue);
		}

		}//namespace android

libvideoeditor/lvpp/VideoEditorBGAudioProcessing.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -53,8 +53,12 @@ typedef struct {
		class VideoEditorBGAudioProcessing {
		public:
		VideoEditorBGAudioProcessing();
		void veSetAudioProcessingParams(veAudMixSettings mixParams);
		M4OSA_Int32 veProcessAudioMixNDuck(void* , void , void );
		void veSetAudioProcessingParams(const veAudMixSettings& mixParams);

		M4OSA_Int32 veProcessAudioMixNDuck(
		void* primaryTrackBuffer,
		void* backgroundTrackBuffer,
		void* mixedOutputBuffer);

		~VideoEditorBGAudioProcessing();

		@@ -78,11 +82,7 @@ private:
		M4OSA_Float mPTVolLevel;
		M4OSA_Float mBTVolLevel;

		M4AM_Buffer16 mPTBuffer;
		M4AM_Buffer16 mBTBuffer;
		M4AM_Buffer16 mOutMixBuffer;
		M4OSA_Int16 *mTempBuffer;
		M4OSA_Int32 mTempFrameCount;

		M4OSA_Int32 getDecibelSound(M4OSA_UInt32 value);
		M4OSA_Bool isThresholdBreached(M4OSA_Int32* averageValue,