videoeditor preview code on honeycomb
Change-Id: I9c3c9cb921ea697ab16732973d26ef9035cda2ee
diff --git a/libvideoeditor/lvpp/VideoEditorBGAudioProcessing.cpp b/libvideoeditor/lvpp/VideoEditorBGAudioProcessing.cpp
new file mode 100755
index 0000000..2049f08
--- /dev/null
+++ b/libvideoeditor/lvpp/VideoEditorBGAudioProcessing.cpp
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2011 NXP Software
+ * 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 ");
+
+ VideoEditorBGAudioProcessing::mAudVolArrIndex = 0;
+ VideoEditorBGAudioProcessing::mDoDucking = 0;
+ VideoEditorBGAudioProcessing::mDucking_enable = 0;
+ VideoEditorBGAudioProcessing::mDucking_lowVolume = 0;
+ VideoEditorBGAudioProcessing::mDucking_threshold = 0;
+ VideoEditorBGAudioProcessing::mDuckingFactor = 0;
+
+ VideoEditorBGAudioProcessing::mBTVolLevel = 0;
+ VideoEditorBGAudioProcessing::mPTVolLevel = 0;
+
+ VideoEditorBGAudioProcessing::mIsSSRCneeded = 0;
+ VideoEditorBGAudioProcessing::mChannelConversion = 0;
+
+ VideoEditorBGAudioProcessing::mBTFormat = MONO_16_BIT;
+
+ VideoEditorBGAudioProcessing::mInSampleRate = 8000;
+ VideoEditorBGAudioProcessing::mOutSampleRate = 16000;
+ VideoEditorBGAudioProcessing::mPTChannelCount = 2;
+ VideoEditorBGAudioProcessing::mBTChannelCount = 1;
+}
+
+M4OSA_Int32 VideoEditorBGAudioProcessing::veProcessAudioMixNDuck(
+ void *pPTBuffer, void *pBTBuffer, void *pOutBuffer) {
+
+ M4AM_Buffer* pPrimaryTrack = (M4AM_Buffer*)pPTBuffer;
+ M4AM_Buffer* pBackgroundTrack = (M4AM_Buffer*)pBTBuffer;
+ M4AM_Buffer* pMixedOutBuffer = (M4AM_Buffer*)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
+ M4OSA_memcpy((M4OSA_MemAddr8)pMixedOutBuffer->m_dataAddress,
+ (M4OSA_MemAddr8)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((this->mDucking_enable) && (this->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++;
+ }
+
+ this->mAudioVolumeArray[this->mAudVolArrIndex] =
+ getDecibelSound(peakDbValue);
+
+ LOGV("VideoEditorBGAudioProcessing:: getDecibelSound %d",
+ this->mAudioVolumeArray[this->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;
+ } else {
+ this->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(this->mDoDucking){
+ if ( this->mDuckingFactor > this->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;
+ }
+ } else {
+ if ( this->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;
+ }
+ }
+ } // end if - mDucking_enable
+
+
+ // Mixing Logic
+
+ LOGV("VideoEditorBGAudioProcessing:: Out of Ducking analysis uiPCMsize\
+ %d %f %f", this->mDoDucking, this->mDuckingFactor,this->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);
+
+ // Mix the two samples
+ if ( this->mDoDucking) {
+
+ // Duck the BG track to ducking factor value before mixing
+ *pBTMdata1 = (M4OSA_Int16)((*pBTMdata1)*(this->mDuckingFactor));
+
+ // mix as normal case
+ *pBTMdata1 = (M4OSA_Int16)(*pBTMdata1 /2 + *pPTMdata2 /2);
+ }
+ else {
+
+ *pBTMdata1 = (M4OSA_Int16)((*pBTMdata1)*(this->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 ");
+ M4OSA_memcpy((M4OSA_MemAddr8)pMixedOutBuffer->m_dataAddress,
+ (M4OSA_MemAddr8)pBackgroundTrack->m_dataAddress,
+ pBackgroundTrack->m_bufferSize);
+
+ LOGV("VideoEditorBGAudioProcessing::lvProcessAudioMixNDuck EXIT");
+ return result;
+}
+
+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;
+}
+
+void VideoEditorBGAudioProcessing ::veSetAudioProcessingParams(
+ veAudMixSettings gInputParams) {
+
+ LOGV("VideoEditorBGAudioProcessing:: ENTER lvSetAudioProcessingParams ");
+ this->mDucking_enable = gInputParams.lvInDucking_enable;
+ this->mDucking_lowVolume = gInputParams.lvInDucking_lowVolume;
+ this->mDucking_threshold = gInputParams.lvInDucking_threshold;
+
+ this->mPTVolLevel = gInputParams.lvPTVolLevel;
+ this->mBTVolLevel = gInputParams.lvBTVolLevel ;
+
+ this->mBTChannelCount = gInputParams.lvBTChannelCount;
+ this->mPTChannelCount = gInputParams.lvPTChannelCount;
+
+ this->mBTFormat = gInputParams.lvBTFormat;
+
+ this->mInSampleRate = gInputParams.lvInSampleRate;
+ this->mOutSampleRate = gInputParams.lvOutSampleRate;
+
+ this->mAudVolArrIndex = 0;
+ this->mDoDucking = 0;
+ this->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);
+
+ // Following logc decides if SSRC support is needed for this mixing
+ if ( gInputParams.lvInSampleRate != gInputParams.lvOutSampleRate){
+ this->mIsSSRCneeded = 1;
+ }else{
+ this->mIsSSRCneeded = 0;
+ }
+ if( gInputParams.lvBTChannelCount != gInputParams.lvPTChannelCount){
+ if (gInputParams.lvBTChannelCount == 2){
+ this->mChannelConversion = 1; // convert to MONO
+ }else{
+ this->mChannelConversion = 2; // Convert to STEREO
+ }
+ }else{
+ this->mChannelConversion = 0;
+ }
+ LOGV("VideoEditorBGAudioProcessing:: EXIT veSetAudioProcessingParams ");
+}
+
+
+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;
+}
+
+M4OSA_Bool VideoEditorBGAudioProcessing:: isThresholdBreached(
+ 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;
+}
+
+}//namespace android