| /* |
| * Copyright (C) 2011 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. |
| */ |
| |
| #define LOG_NDEBUG 1 |
| #define LOG_TAG "VideoEditorBGAudioProcessing" |
| #include <utils/Log.h> |
| #include "VideoEditorBGAudioProcessing.h" |
| |
| namespace android { |
| |
| VideoEditorBGAudioProcessing::VideoEditorBGAudioProcessing() { |
| |
| LOGV("VideoEditorBGAudioProcessing:: Construct VideoEditorBGAudioProcessing "); |
| |
| mAudVolArrIndex = 0; |
| mDoDucking = 0; |
| mDucking_enable = 0; |
| mDucking_lowVolume = 0; |
| mDucking_threshold = 0; |
| mDuckingFactor = 0; |
| |
| mBTVolLevel = 0; |
| mPTVolLevel = 0; |
| |
| mIsSSRCneeded = 0; |
| mChannelConversion = 0; |
| |
| mBTFormat = MONO_16_BIT; |
| |
| mInSampleRate = 8000; |
| mOutSampleRate = 16000; |
| mPTChannelCount = 2; |
| mBTChannelCount = 1; |
| } |
| |
| M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck( |
| void *pPTBuffer, void *pBTBuffer, void *pOutBuffer) { |
| |
| M4AM_Buffer16* pPrimaryTrack = (M4AM_Buffer16*)pPTBuffer; |
| M4AM_Buffer16* pBackgroundTrack = (M4AM_Buffer16*)pBTBuffer; |
| M4AM_Buffer16* pMixedOutBuffer = (M4AM_Buffer16*)pOutBuffer; |
| |
| LOGV("VideoEditorBGAudioProcessing::lvProcessAudioMixNDuck \ |
| pPTBuffer 0x%x pBTBuffer 0x%x pOutBuffer 0x%x", pPTBuffer, |
| pBTBuffer, pOutBuffer); |
| |
| M4OSA_ERR result = M4NO_ERROR; |
| M4OSA_Int16 *pBTMdata1; |
| M4OSA_Int16 *pPTMdata2; |
| M4OSA_UInt32 uiPCMsize; |
| |
| // Ducking variable |
| M4OSA_UInt16 loopIndex = 0; |
| M4OSA_Int16 *pPCM16Sample = M4OSA_NULL; |
| M4OSA_Int32 peakDbValue = 0; |
| M4OSA_Int32 previousDbValue = 0; |
| M4OSA_UInt32 i; |
| |
| // Output size if same as PT size |
| pMixedOutBuffer->m_bufferSize = pPrimaryTrack->m_bufferSize; |
| |
| // Before mixing, we need to have only PT as out buffer |
| memcpy((void *)pMixedOutBuffer->m_dataAddress, |
| (void *)pPrimaryTrack->m_dataAddress, pMixedOutBuffer->m_bufferSize); |
| |
| // Initially contains the input primary track |
| pPTMdata2 = (M4OSA_Int16*)pMixedOutBuffer->m_dataAddress; |
| // Contains BG track processed data(like channel conversion etc.. |
| pBTMdata1 = (M4OSA_Int16*) pBackgroundTrack->m_dataAddress; |
| |
| // Since we need to give sample count and not buffer size |
| uiPCMsize = pMixedOutBuffer->m_bufferSize/2 ; |
| |
| if ((mDucking_enable) && (mPTVolLevel != 0.0)) { |
| // LOGI("VideoEditorBGAudioProcessing:: In Ducking analysis "); |
| loopIndex = 0; |
| peakDbValue = 0; |
| previousDbValue = peakDbValue; |
| |
| pPCM16Sample = (M4OSA_Int16*)pPrimaryTrack->m_dataAddress; |
| |
| while (loopIndex < pPrimaryTrack->m_bufferSize/sizeof(M4OSA_Int16)) { |
| if (pPCM16Sample[loopIndex] >= 0) { |
| peakDbValue = previousDbValue > pPCM16Sample[loopIndex] ? |
| previousDbValue : pPCM16Sample[loopIndex]; |
| previousDbValue = peakDbValue; |
| } else { |
| peakDbValue = previousDbValue > -pPCM16Sample[loopIndex] ? |
| previousDbValue: -pPCM16Sample[loopIndex]; |
| previousDbValue = peakDbValue; |
| } |
| loopIndex++; |
| } |
| |
| mAudioVolumeArray[mAudVolArrIndex] = getDecibelSound(peakDbValue); |
| |
| LOGV("VideoEditorBGAudioProcessing:: getDecibelSound %d", |
| mAudioVolumeArray[mAudVolArrIndex]); |
| |
| // WINDOW_SIZE is 10 by default |
| // Check for threshold is done after 10 cycles |
| if (mAudVolArrIndex >= WINDOW_SIZE - 1) { |
| mDoDucking = isThresholdBreached(mAudioVolumeArray, |
| mAudVolArrIndex,mDucking_threshold ); |
| mAudVolArrIndex = 0; |
| } else { |
| mAudVolArrIndex++; |
| } |
| |
| // |
| // Below logic controls the mixing weightage |
| // for Background and Primary Tracks |
| // for the duration of window under analysis, |
| // to give fade-out for Background and fade-in for primary |
| // Current fading factor is distributed in equal range over |
| // the defined window size. |
| // For a window size = 25 |
| // (500 ms (window under analysis) / 20 ms (sample duration)) |
| // |
| |
| 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 |
| mDuckingFactor -= (mDucking_lowVolume); |
| } else { |
| mDuckingFactor = mDucking_lowVolume; |
| } |
| } else { |
| if (mDuckingFactor < 1.0 ) { |
| // FADE IN BG Track |
| // Increment ducking factor in total steps of |
| // low volume factor to reach orig.volume level |
| mDuckingFactor += (mDucking_lowVolume); |
| } else { |
| mDuckingFactor = 1.0; |
| } |
| } |
| } // end if - mDucking_enable |
| |
| |
| // Mixing Logic |
| |
| LOGV("VideoEditorBGAudioProcessing:: Out of Ducking analysis uiPCMsize\ |
| %d %f %f", mDoDucking, mDuckingFactor,mBTVolLevel); |
| |
| while (uiPCMsize-- > 0) { |
| |
| M4OSA_Int32 temp; |
| // Set vol factor for BT and PT |
| *pBTMdata1 = (M4OSA_Int16)(*pBTMdata1*mBTVolLevel); |
| *pPTMdata2 = (M4OSA_Int16)(*pPTMdata2*mPTVolLevel); |
| |
| // Mix the two samples |
| if (mDoDucking) { |
| |
| // Duck the BG track to ducking factor value before mixing |
| *pBTMdata1 = (M4OSA_Int16)((*pBTMdata1)*(mDuckingFactor)); |
| |
| // mix as normal case |
| *pBTMdata1 = (M4OSA_Int16)(*pBTMdata1 /2 + *pPTMdata2 /2); |
| } else { |
| |
| *pBTMdata1 = (M4OSA_Int16)((*pBTMdata1)*(mDuckingFactor)); |
| *pBTMdata1 = (M4OSA_Int16)(*pBTMdata1 /2 + *pPTMdata2 /2); |
| } |
| |
| if (*pBTMdata1 < 0) { |
| temp = -(*pBTMdata1) * 2; // bring to original Amplitude level |
| |
| if (temp > 32767) { |
| *pBTMdata1 = -32766; // less then max allowed value |
| } else { |
| *pBTMdata1 = (M4OSA_Int16)(-temp); |
| } |
| } else { |
| temp = (*pBTMdata1) * 2; // bring to original Amplitude level |
| if ( temp > 32768) { |
| *pBTMdata1 = 32767; // less than max allowed value |
| } else { |
| *pBTMdata1 = (M4OSA_Int16)temp; |
| } |
| } |
| |
| pBTMdata1++; |
| pPTMdata2++; |
| } |
| //LOGV("VideoEditorBGAudioProcessing:: Copy final out "); |
| memcpy((void *)pMixedOutBuffer->m_dataAddress, |
| (void *)pBackgroundTrack->m_dataAddress, |
| pBackgroundTrack->m_bufferSize); |
| |
| LOGV("VideoEditorBGAudioProcessing::lvProcessAudioMixNDuck EXIT"); |
| return result; |
| } |
| |
| VideoEditorBGAudioProcessing::~VideoEditorBGAudioProcessing() { |
| |
| } |
| |
| M4OSA_Int32 VideoEditorBGAudioProcessing::calculateOutResampleBufSize() { |
| |
| // This already takes care of channel count in mBTBuffer.m_bufferSize |
| return (mOutSampleRate / mInSampleRate) * mBTBuffer.m_bufferSize; |
| } |
| |
| void VideoEditorBGAudioProcessing ::veSetAudioProcessingParams( |
| const veAudMixSettings& gInputParams) { |
| |
| LOGV("VideoEditorBGAudioProcessing:: ENTER lvSetAudioProcessingParams "); |
| mDucking_enable = gInputParams.lvInDucking_enable; |
| mDucking_lowVolume = gInputParams.lvInDucking_lowVolume; |
| mDucking_threshold = gInputParams.lvInDucking_threshold; |
| |
| mPTVolLevel = gInputParams.lvPTVolLevel; |
| mBTVolLevel = gInputParams.lvBTVolLevel ; |
| |
| mBTChannelCount = gInputParams.lvBTChannelCount; |
| mPTChannelCount = gInputParams.lvPTChannelCount; |
| |
| mBTFormat = gInputParams.lvBTFormat; |
| |
| mInSampleRate = gInputParams.lvInSampleRate; |
| mOutSampleRate = gInputParams.lvOutSampleRate; |
| |
| mAudVolArrIndex = 0; |
| mDoDucking = 0; |
| mDuckingFactor = 1.0; // default |
| |
| LOGV("VideoEditorBGAudioProcessing:: ducking_enable 0x%x \ |
| ducking_lowVolume %f ducking_threshold %d fPTVolLevel %f BTVolLevel %f", |
| mDucking_enable, mDucking_lowVolume, mDucking_threshold, |
| mPTVolLevel, mPTVolLevel); |
| |
| // Following logc decides if SSRC support is needed for this mixing |
| mIsSSRCneeded = (gInputParams.lvInSampleRate != gInputParams.lvOutSampleRate); |
| if (gInputParams.lvBTChannelCount != gInputParams.lvPTChannelCount){ |
| if (gInputParams.lvBTChannelCount == 2){ |
| mChannelConversion = 1; // convert to MONO |
| } else { |
| mChannelConversion = 2; // Convert to STEREO |
| } |
| } else { |
| mChannelConversion = 0; |
| } |
| LOGV("VideoEditorBGAudioProcessing:: EXIT veSetAudioProcessingParams "); |
| } |
| |
| |
| // Fast way to compute 10 * log(value) |
| M4OSA_Int32 VideoEditorBGAudioProcessing::getDecibelSound(M4OSA_UInt32 value) { |
| 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 thresholdValue) { |
| |
| int totalValue = 0; |
| for (int i = 0; i < storeCount; ++i) { |
| totalValue += averageValue[i]; |
| } |
| return (totalValue / storeCount > thresholdValue); |
| } |
| |
| }//namespace android |
