| /* |
| * 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. |
| */ |
| /** |
| ****************************************************************************** |
| * @file M4VSS3GPP_EditAudio.c |
| * @brief Video Studio Service 3GPP edit API implementation. |
| * @note |
| ****************************************************************************** |
| */ |
| |
| /****************/ |
| /*** Includes ***/ |
| /****************/ |
| |
| #include "NXPSW_CompilerSwitches.h" |
| /** |
| * Our header */ |
| #include "M4VSS3GPP_API.h" |
| #include "M4VSS3GPP_InternalTypes.h" |
| #include "M4VSS3GPP_InternalFunctions.h" |
| #include "M4VSS3GPP_InternalConfig.h" |
| #include "M4VSS3GPP_ErrorCodes.h" |
| |
| /** |
| * OSAL headers */ |
| #include "M4OSA_Memory.h" /**< OSAL memory management */ |
| #include "M4OSA_Debug.h" /**< OSAL debug management */ |
| |
| #define PWR_FXP_FRACT_MAX (32768) |
| |
| /************************************************************************/ |
| /* Static local functions */ |
| /************************************************************************/ |
| static M4OSA_ERR M4VSS3GPP_intCheckAudioMode( M4VSS3GPP_InternalEditContext |
| *pC ); |
| static M4OSA_Void M4VSS3GPP_intCheckAudioEffects( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_UInt8 uiClipNumber ); |
| static M4OSA_ERR M4VSS3GPP_intApplyAudioEffect( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_UInt8 uiClip1orClip2, |
| M4OSA_Int16 *pPCMdata, |
| M4OSA_UInt32 uiPCMsize ); |
| static M4OSA_ERR M4VSS3GPP_intAudioTransition( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_Int16 *pPCMdata1, |
| M4OSA_Int16 *pPCMdata2, |
| M4OSA_UInt32 uiPCMsize ); |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intEditJumpMP3() |
| * @brief One step of jumping processing for the MP3 clip. |
| * @note On one step, the jump of several AU is done |
| * @param pC (IN/OUT) Internal edit context |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intEditJumpMP3( M4VSS3GPP_InternalEditContext *pC ) |
| { |
| M4OSA_ERR err; |
| M4VSS3GPP_ClipContext *pClip = pC->pC1; /**< shortcut */ |
| M4OSA_Int32 JumpCts; |
| |
| JumpCts = pClip->iActualAudioBeginCut; |
| |
| err = M4VSS3GPP_intClipJumpAudioAt(pClip, &JumpCts); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intOpenClip: M4VSS3GPP_intClipJumpAudioAt(A) returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| if( JumpCts >= pClip->iActualAudioBeginCut ) |
| { |
| pC->State = M4VSS3GPP_kEditState_MP3; |
| |
| /** |
| * Update clip offset with the audio begin cut */ |
| pClip->iAoffset = -JumpCts; |
| |
| /** |
| * The audio is currently in reading mode */ |
| pClip->Astatus = M4VSS3GPP_kClipStatus_READ; |
| } |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intEditStepMP3() |
| * @brief One step of audio processing for the MP3 clip |
| * @param pC (IN/OUT) Internal edit context |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intEditStepMP3( M4VSS3GPP_InternalEditContext *pC ) |
| { |
| M4OSA_ERR err; |
| M4VSS3GPP_ClipContext *pClip = pC->pC1; /**< shortcut */ |
| |
| /** |
| * Copy the input AU to the output AU */ |
| err = pC->pOsaFileWritPtr->writeData(pC->ewc.p3gpWriterContext, |
| pClip->pAudioFramePtr, (M4OSA_UInt32)pClip->uiAudioFrameSize); |
| |
| /** |
| * Read the next audio frame */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pClip); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepMP3: READ_WRITE:\ |
| M4VSS3GPP_intClipReadNextAudioFrame returns 0x%x!", err); |
| return err; |
| } |
| else |
| { |
| /** |
| * Update current time (to=tc+T) */ |
| pC->ewc.dATo = |
| ( pClip->iAudioFrameCts + pClip->iAoffset) / pClip->scale_audio; |
| |
| if( (M4OSA_Int32)(pClip->iAudioFrameCts / pClip->scale_audio + 0.5) |
| >= pClip->iEndTime ) |
| { |
| M4READER_Buffer mp3tagBuffer; |
| |
| /** |
| * The duration is better respected if the first AU and last AU are both above |
| the cut time */ |
| err = pC->pOsaFileWritPtr->writeData(pC->ewc.p3gpWriterContext, |
| pClip->pAudioFramePtr, |
| (M4OSA_UInt32)pClip->uiAudioFrameSize); |
| |
| /* The ID3v1 tag is always at the end of the mp3 file so the end of the cutting |
| process is waited */ |
| /* before writing the metadata in the output file*/ |
| |
| /* Retrieve the data of the ID3v1 Tag */ |
| err = pClip->ShellAPI.m_pReader->m_pFctGetOption( |
| pClip->pReaderContext, M4READER_kOptionID_Mp3Id3v1Tag, |
| (M4OSA_DataOption) &mp3tagBuffer); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepMP3: M4MP3R_getOption returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /* Write the data of the ID3v1 Tag in the output file */ |
| if( 0 != mp3tagBuffer.m_uiBufferSize ) |
| { |
| err = pC->pOsaFileWritPtr->writeData(pC->ewc.p3gpWriterContext, |
| (M4OSA_MemAddr8)mp3tagBuffer.m_pData, mp3tagBuffer.m_uiBufferSize); |
| /** |
| * Free before the error checking anyway */ |
| free(mp3tagBuffer.m_pData); |
| |
| /** |
| * Error checking */ |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepMP3:\ |
| pOsaFileWritPtr->writeData(ID3v1Tag) returns 0x%x", err); |
| return err; |
| } |
| |
| mp3tagBuffer.m_uiBufferSize = 0; |
| mp3tagBuffer.m_pData = M4OSA_NULL; |
| } |
| |
| /* The End Cut has been reached */ |
| err = M4VSS3GPP_intReachedEndOfAudio(pC); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepMP3 : M4VSS3GPP_intReachedEndOfAudio returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| if( ( M4WAR_NO_MORE_AU == err) && (M4OSA_FALSE |
| == pC->bSupportSilence) ) /**< Reached end of clip */ |
| { |
| err = M4VSS3GPP_intReachedEndOfAudio( |
| pC); /**< Clip done, do the next one */ |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepMP3: READ_WRITE:\ |
| M4VSS3GPP_intReachedEndOfAudio returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intEditStepMP3: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intEditStepAudio() |
| * @brief One step of audio processing |
| * @param pC (IN/OUT) Internal edit context |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intEditStepAudio( M4VSS3GPP_InternalEditContext *pC ) |
| { |
| M4OSA_ERR err; |
| int32_t auTimeStamp = -1; |
| |
| M4ENCODER_AudioBuffer pEncInBuffer; /**< Encoder input buffer for api */ |
| M4ENCODER_AudioBuffer pEncOutBuffer; /**< Encoder output buffer for api */ |
| M4OSA_Time |
| frameTimeDelta; /**< Duration of the encoded (then written) data */ |
| M4OSA_Bool bStopAudio; |
| |
| /** |
| * Check if we reached end cut */ |
| if( ( pC->ewc.dATo - pC->pC1->iAoffset / pC->pC1->scale_audio + 0.5) |
| >= pC->pC1->iEndTime ) |
| { |
| /** |
| * Audio is done for this clip */ |
| err = M4VSS3GPP_intReachedEndOfAudio(pC); |
| |
| /* RC: to know when a file has been processed */ |
| if( M4NO_ERROR != err && err != M4VSS3GPP_WAR_SWITCH_CLIP ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: M4VSS3GPP_intReachedEndOfAudio returns 0x%x", |
| err); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * Check Audio Mode, depending on the current output CTS */ |
| err = M4VSS3GPP_intCheckAudioMode( |
| pC); /**< This function change the pC->Astate variable! */ |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: M4VSS3GPP_intCheckAudioMode returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| M4OSA_TRACE2_3(" AUDIO step : dATo = %f state = %d offset = %ld", |
| pC->ewc.dATo, pC->Astate, pC->pC1->iAoffset); |
| |
| bStopAudio = M4OSA_FALSE; |
| |
| switch( pC->Astate ) |
| { |
| /* _________________ */ |
| /*| |*/ |
| /*| READ_WRITE MODE |*/ |
| /*|_________________|*/ |
| |
| case M4VSS3GPP_kEditAudioState_READ_WRITE: |
| { |
| M4OSA_TRACE3_0("M4VSS3GPP_intEditStepAudio READ_WRITE"); |
| |
| /** |
| * Get the output AU to write into */ |
| err = pC->ShellAPI.pWriterDataFcts->pStartAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio:\ |
| READ_WRITE: pWriterDataFcts->pStartAU returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * Compute output audio CTS */ |
| pC->ewc.WriterAudioAU.CTS = |
| pC->pC1->iAudioFrameCts + pC->pC1->iAoffset; |
| |
| /** |
| * BZZZ bug fix (read-write case): |
| * Replace the first AMR AU of the stream with a silence AU. |
| * It removes annoying "BZZZ" audio glitch. |
| * It is not needed if there is a begin cut. |
| * It is not needed for the first clip. |
| * Because of another bugfix (2005-03-24), the first AU written may be |
| * the second one which CTS is 20. Hence the cts<21 test. |
| * (the BZZZ effect occurs even with the second AU!) */ |
| if( ( M4OSA_FALSE == pC->pC1->bFirstAuWritten) |
| && (0 != pC->uiCurrentClip) && (pC->pC1->iAudioFrameCts |
| < (pC->ewc.iSilenceFrameDuration + 1)) ) |
| { |
| /** |
| * Copy a silence AU to the output */ |
| pC->ewc.WriterAudioAU.size = pC->ewc.uiSilenceFrameSize; |
| memcpy((void *)pC->ewc.WriterAudioAU.dataAddress, |
| (void *)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize); |
| M4OSA_TRACE2_0("A #### silence AU"); |
| } |
| else if( (M4OSA_UInt32)pC->pC1->uiAudioFrameSize |
| < pC->ewc.uiAudioMaxAuSize ) |
| { |
| /** |
| * Copy the input AU to the output AU */ |
| pC->ewc.WriterAudioAU.size = |
| (M4OSA_UInt32)pC->pC1->uiAudioFrameSize; |
| memcpy((void *)pC->ewc.WriterAudioAU.dataAddress, |
| (void *)pC->pC1->pAudioFramePtr, pC->ewc.WriterAudioAU.size); |
| } |
| else |
| { |
| M4OSA_TRACE1_2( |
| "M4VSS3GPP_intEditStepAudio: READ_WRITE: AU size greater than MaxAuSize \ |
| (%d>%d)! returning M4VSS3GPP_ERR_INPUT_AUDIO_AU_TOO_LARGE", |
| pC->pC1->uiAudioFrameSize, pC->ewc.uiAudioMaxAuSize); |
| return M4VSS3GPP_ERR_INPUT_AUDIO_AU_TOO_LARGE; |
| } |
| |
| /** |
| * This boolean is only used to fix the BZZ bug... */ |
| pC->pC1->bFirstAuWritten = M4OSA_TRUE; |
| |
| M4OSA_TRACE2_2("B ---- write : cts = %ld [ 0x%x ]", |
| (M4OSA_Int32)(pC->ewc.WriterAudioAU.CTS / pC->ewc.scale_audio), |
| pC->ewc.WriterAudioAU.size); |
| |
| /** |
| * Write the AU */ |
| err = pC->ShellAPI.pWriterDataFcts->pProcessAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| /*11/12/2008 CR 3283 MMS use case for VideoArtist |
| the warning M4WAR_WRITER_STOP_REQ is returned when the targeted output file |
| size is reached |
| The editing is then finished, |
| the warning M4VSS3GPP_WAR_EDITING_DONE is returned*/ |
| if( M4WAR_WRITER_STOP_REQ == err ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intEditStepAudio: File was cut to avoid oversize"); |
| return M4VSS3GPP_WAR_EDITING_DONE; |
| } |
| else |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio:\ |
| READ_WRITE: pWriterDataFcts->pProcessAU returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Audio is now in read mode (there may be a "if(status!=READ)" here, |
| but it is removed for optimization) */ |
| pC->pC1->Astatus = M4VSS3GPP_kClipStatus_READ; |
| |
| /** |
| * Read the next audio frame */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC1); |
| |
| M4OSA_TRACE2_3("C .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: READ_WRITE:\ |
| M4VSS3GPP_intClipReadNextAudioFrame returns 0x%x!", |
| err); |
| return err; |
| } |
| else |
| { |
| /** |
| * Update current time (to=tc+T) */ |
| pC->ewc.dATo = ( pC->pC1->iAudioFrameCts + pC->pC1->iAoffset) |
| / pC->pC1->scale_audio; |
| |
| if( ( M4WAR_NO_MORE_AU == err) |
| && (M4OSA_FALSE == pC->bSupportSilence) ) |
| { |
| /** |
| * If output is other than AMR or AAC |
| (i.e. EVRC,we can't write silence into it) |
| * So we simply end here.*/ |
| bStopAudio = M4OSA_TRUE; |
| } |
| } |
| } |
| break; |
| |
| /* ____________________ */ |
| /*| |*/ |
| /*| DECODE_ENCODE MODE |*/ |
| /*|____________________|*/ |
| |
| case M4VSS3GPP_kEditAudioState_DECODE_ENCODE: |
| { |
| M4OSA_TRACE3_0("M4VSS3GPP_intEditStepAudio DECODE_ENCODE"); |
| |
| /** |
| * Get the output AU to write into */ |
| err = pC->ShellAPI.pWriterDataFcts->pStartAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE:\ |
| pWriterDataFcts->pStartAU returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * If we were reading the clip, we must jump a few AU backward to decode/encode |
| (without writing result) from that point. */ |
| if( M4VSS3GPP_kClipStatus_READ == pC->pC1->Astatus ) |
| { |
| M4OSA_Int32 iTargetCts, iCurrentCts; |
| |
| if( 0 |
| != pC->pC1-> |
| iAudioFrameCts ) /**<don't try to pre-decode if clip is at its beginning. */ |
| { |
| /** |
| * Jump a few AUs backward */ |
| iCurrentCts = pC->pC1->iAudioFrameCts; |
| iTargetCts = iCurrentCts - M4VSS3GPP_NB_AU_PREFETCH |
| * pC->ewc.iSilenceFrameDuration; |
| |
| if( iTargetCts < 0 ) |
| { |
| iTargetCts = 0; /**< Sanity check */ |
| } |
| |
| err = M4VSS3GPP_intClipJumpAudioAt(pC->pC1, &iTargetCts); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE-prefetch:\ |
| M4VSS3GPP_intClipJumpAudioAt returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| err = M4VSS3GPP_intClipReadNextAudioFrame( |
| pC->pC1); /**< read AU where we jumped */ |
| |
| M4OSA_TRACE2_3("D .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE-prefetch:\ |
| M4VSS3GPP_intClipReadNextAudioFrame(a) returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * Decode/encode up to the wanted position */ |
| while( pC->pC1->iAudioFrameCts < iCurrentCts ) |
| { |
| err = M4VSS3GPP_intClipDecodeCurrentAudioFrame(pC->pC1); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE-prefetch: \ |
| M4VSS3GPP_intClipDecodeCurrentAudioFrame returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /* [Mono] or [Stereo interleaved] : all is in one buffer */ |
| pEncInBuffer.pTableBuffer[0] = |
| pC->pC1->AudioDecBufferOut.m_dataAddress; |
| pEncInBuffer.pTableBufferSize[0] = |
| pC->pC1->AudioDecBufferOut.m_bufferSize; |
| pEncInBuffer.pTableBuffer[1] = M4OSA_NULL; |
| pEncInBuffer.pTableBufferSize[1] = 0; |
| |
| /* Time in ms from data size, because it is PCM16 samples */ |
| frameTimeDelta = |
| pEncInBuffer.pTableBufferSize[0] / sizeof(short) |
| / pC->ewc.uiNbChannels; |
| |
| /** |
| * Prepare output buffer */ |
| pEncOutBuffer.pTableBuffer[0] = |
| (M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress; |
| pEncOutBuffer.pTableBufferSize[0] = 0; |
| |
| M4OSA_TRACE2_0("E **** pre-encode"); |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /*OMX Audio decoder used. |
| * OMX Audio dec shell does internal buffering and hence does not return |
| a PCM buffer for every decodeStep call.* |
| * So PCM buffer sizes might be 0. In this case donot call encode Step*/ |
| |
| if( 0 != pEncInBuffer.pTableBufferSize[0] ) |
| { |
| #endif |
| /** |
| * Encode the PCM audio */ |
| |
| err = |
| pC->ShellAPI.pAudioEncoderGlobalFcts->pFctStep( |
| pC->ewc.pAudioEncCtxt, |
| &pEncInBuffer, &pEncOutBuffer); |
| |
| if( ( M4NO_ERROR != err) |
| && (M4WAR_NO_MORE_AU != err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio():\ |
| pAudioEncoderGlobalFcts->pFctStep returns 0x%x", |
| err); |
| return err; |
| } |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| } //if(0 != pEncInBuffer.pTableBufferSize[0]) |
| |
| #endif |
| pC->pC1->pAudioFramePtr = M4OSA_NULL; |
| |
| // Get timestamp of last read AU |
| pC->pC1->ShellAPI.m_pAudioDecoder->m_pFctGetOptionAudioDec( |
| pC->pC1->pAudioDecCtxt, M4AD_kOptionID_AuCTS, |
| (M4OSA_DataOption) &auTimeStamp); |
| |
| if (auTimeStamp == -1) { |
| M4OSA_TRACE1_0("M4VSS3GPP_intEditStepAudio: \ |
| invalid audio timestamp returned"); |
| return M4WAR_INVALID_TIME; |
| } |
| |
| pC->pC1->iAudioFrameCts = auTimeStamp; |
| |
| } |
| } |
| |
| /** |
| * Audio is now OK for decoding */ |
| pC->pC1->Astatus = M4VSS3GPP_kClipStatus_DECODE; |
| } |
| |
| /** |
| * Decode the input audio */ |
| err = M4VSS3GPP_intClipDecodeCurrentAudioFrame(pC->pC1); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE:\ |
| M4VSS3GPP_intClipDecodeCurrentAudioFrame returns 0x%x", |
| err); |
| return err; |
| } |
| |
| pC->pC1->pAudioFramePtr = M4OSA_NULL; |
| |
| // Get timestamp of last read AU |
| pC->pC1->ShellAPI.m_pAudioDecoder->m_pFctGetOptionAudioDec( |
| pC->pC1->pAudioDecCtxt, M4AD_kOptionID_AuCTS, |
| (M4OSA_DataOption) &auTimeStamp); |
| |
| if (auTimeStamp == -1) { |
| M4OSA_TRACE1_0("M4VSS3GPP_intEditStepAudio: invalid audio \ |
| timestamp returned"); |
| return M4WAR_INVALID_TIME; |
| } |
| |
| pC->pC1->iAudioFrameCts = auTimeStamp; |
| |
| /** |
| * Apply the effect */ |
| if( pC->iClip1ActiveEffect >= 0 ) |
| { |
| err = M4VSS3GPP_intApplyAudioEffect(pC, 1, (M4OSA_Int16 |
| *)pC->pC1->AudioDecBufferOut.m_dataAddress, |
| pC->pC1->AudioDecBufferOut.m_bufferSize); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE:\ |
| M4VSS3GPP_intEndAudioEffect returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Compute output audio CTS */ |
| pC->ewc.WriterAudioAU.CTS = |
| pC->pC1->iAudioFrameCts + pC->pC1->iAoffset; |
| |
| /* May happen with corrupted input files (which have stts entries not |
| multiple of SilenceFrameDuration) */ |
| if( pC->ewc.WriterAudioAU.CTS < 0 ) |
| { |
| pC->ewc.WriterAudioAU.CTS = 0; |
| } |
| |
| /** |
| * BZZZ bug fix (decode-encode case): |
| * (Yes, the Bzz bug may also occur when we re-encode. It doesn't |
| * occur at the decode before the encode, but at the playback!) |
| * Replace the first AMR AU of the encoded stream with a silence AU. |
| * It removes annoying "BZZZ" audio glitch. |
| * It is not needed if there is a begin cut. |
| * It is not needed for the first clip. |
| * Because of another bugfix (2005-03-24), the first AU written may be |
| * the second one which CTS is 20. Hence the cts<21 test. |
| * (the BZZZ effect occurs even with the second AU!) */ |
| if( ( M4OSA_FALSE == pC->pC1->bFirstAuWritten) |
| && (0 != pC->uiCurrentClip) && (pC->pC1->iAudioFrameCts |
| < (pC->ewc.iSilenceFrameDuration + 1)) ) |
| { |
| /** |
| * Copy a silence AMR AU to the output */ |
| pC->ewc.WriterAudioAU.size = pC->ewc.uiSilenceFrameSize; |
| memcpy((void *)pC->ewc.WriterAudioAU.dataAddress, |
| (void *)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize); |
| M4OSA_TRACE2_0("G #### silence AU"); |
| } |
| else |
| { |
| /** |
| * Encode the filtered PCM audio directly into the output AU */ |
| |
| /* [Mono] or [Stereo interleaved] : all is in one buffer */ |
| pEncInBuffer.pTableBuffer[0] = |
| pC->pC1->AudioDecBufferOut.m_dataAddress; |
| pEncInBuffer.pTableBufferSize[0] = |
| pC->pC1->AudioDecBufferOut.m_bufferSize; |
| pEncInBuffer.pTableBuffer[1] = M4OSA_NULL; |
| pEncInBuffer.pTableBufferSize[1] = 0; |
| |
| /* Time in ms from data size, because it is PCM16 samples */ |
| frameTimeDelta = |
| pEncInBuffer.pTableBufferSize[0] / sizeof(short) |
| / pC->ewc.uiNbChannels; |
| |
| /** |
| * Prepare output buffer */ |
| pEncOutBuffer.pTableBuffer[0] = |
| (M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress; |
| pEncOutBuffer.pTableBufferSize[0] = 0; |
| |
| M4OSA_TRACE2_0("H ++++ encode AU"); |
| |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /*OMX Audio decoder used. |
| * OMX Audio dec shell does internal buffering and hence does not return |
| a PCM buffer for every decodeStep call.* |
| * So PCM buffer sizes might be 0. In this case donot call encode Step*/ |
| |
| if( 0 != pEncInBuffer.pTableBufferSize[0] ) |
| { |
| |
| #endif |
| |
| /** |
| * Encode the PCM audio */ |
| |
| err = pC->ShellAPI.pAudioEncoderGlobalFcts->pFctStep( |
| pC->ewc.pAudioEncCtxt, |
| &pEncInBuffer, &pEncOutBuffer); |
| |
| if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio():\ |
| pAudioEncoderGlobalFcts->pFctStep returns 0x%x", |
| err); |
| return err; |
| } |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| } |
| |
| #endif |
| |
| /** |
| * Set AU size */ |
| |
| pC->ewc.WriterAudioAU.size = pEncOutBuffer.pTableBufferSize[ |
| 0]; /**< Get the size of encoded data */ |
| } |
| |
| /** |
| * This boolean is only used to fix the BZZ bug... */ |
| pC->pC1->bFirstAuWritten = M4OSA_TRUE; |
| |
| M4OSA_TRACE2_2("I ---- write : cts = %ld [ 0x%x ]", |
| (M4OSA_Int32)(pC->ewc.WriterAudioAU.CTS / pC->ewc.scale_audio), |
| pC->ewc.WriterAudioAU.size); |
| |
| /** |
| * Write the AU */ |
| err = pC->ShellAPI.pWriterDataFcts->pProcessAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| /*11/12/2008 CR 3283 MMS use case for VideoArtist |
| the warning M4WAR_WRITER_STOP_REQ is returned when the targeted output file |
| size is reached |
| The editing is then finished, |
| the warning M4VSS3GPP_WAR_EDITING_DONE is returned*/ |
| if( M4WAR_WRITER_STOP_REQ == err ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intEditStepAudio: File was cut to avoid oversize"); |
| return M4VSS3GPP_WAR_EDITING_DONE; |
| } |
| else |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE:\ |
| pWriterDataFcts->pProcessAU returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Read the next audio frame */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC1); |
| |
| M4OSA_TRACE2_3("J .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: DECODE_ENCODE:\ |
| M4VSS3GPP_intClipReadNextAudioFrame returns 0x%x!", |
| err); |
| return err; |
| } |
| else |
| { |
| /** |
| * Update current time (to=tc+T) */ |
| pC->ewc.dATo = ( pC->pC1->iAudioFrameCts + pC->pC1->iAoffset) |
| / pC->pC1->scale_audio; |
| |
| if( ( M4WAR_NO_MORE_AU == err) |
| && (M4OSA_FALSE == pC->bSupportSilence) ) |
| { |
| /** |
| * If output is other than AMR or AAC |
| (i.e. EVRC,we can't write silence into it) |
| * So we simply end here.*/ |
| bStopAudio = M4OSA_TRUE; |
| } |
| } |
| } |
| break; |
| |
| /* _________________ */ |
| /*| |*/ |
| /*| TRANSITION MODE |*/ |
| /*|_________________|*/ |
| |
| case M4VSS3GPP_kEditAudioState_TRANSITION: |
| { |
| M4OSA_TRACE3_0("M4VSS3GPP_intEditStepAudio TRANSITION"); |
| |
| /** |
| * Get the output AU to write into */ |
| err = pC->ShellAPI.pWriterDataFcts->pStartAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| pWriterDataFcts->pStartAU returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * If we were reading the clip, we must jump a few AU backward to decode/encode |
| (without writing result) from that point. */ |
| if( M4VSS3GPP_kClipStatus_READ == pC->pC1->Astatus ) |
| { |
| M4OSA_Int32 iTargetCts, iCurrentCts; |
| |
| if( 0 |
| != pC->pC1-> |
| iAudioFrameCts ) /**<don't try to pre-decode if clip is at its beginning.*/ |
| { |
| /** |
| * Jump a few AUs backward */ |
| iCurrentCts = pC->pC1->iAudioFrameCts; |
| iTargetCts = iCurrentCts - M4VSS3GPP_NB_AU_PREFETCH |
| * pC->ewc.iSilenceFrameDuration; |
| |
| if( iTargetCts < 0 ) |
| { |
| iTargetCts = 0; /**< Sanity check */ |
| } |
| |
| err = M4VSS3GPP_intClipJumpAudioAt(pC->pC1, &iTargetCts); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION-prefetch:\ |
| M4VSS3GPP_intClipJumpAudioAt returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| err = M4VSS3GPP_intClipReadNextAudioFrame( |
| pC->pC1); /**< read AU where we jumped */ |
| |
| M4OSA_TRACE2_3("K .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION-prefetch:\ |
| M4VSS3GPP_intClipReadNextAudioFrame(a) returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * Decode/encode up to the wanted position */ |
| while( pC->pC1->iAudioFrameCts < iCurrentCts ) |
| { |
| err = M4VSS3GPP_intClipDecodeCurrentAudioFrame(pC->pC1); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION-prefetch:\ |
| M4VSS3GPP_intClipDecodeCurrentAudioFrame returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /* [Mono] or [Stereo interleaved] : all is in one buffer */ |
| pEncInBuffer.pTableBuffer[0] = |
| pC->pC1->AudioDecBufferOut.m_dataAddress; |
| pEncInBuffer.pTableBufferSize[0] = |
| pC->pC1->AudioDecBufferOut.m_bufferSize; |
| pEncInBuffer.pTableBuffer[1] = M4OSA_NULL; |
| pEncInBuffer.pTableBufferSize[1] = 0; |
| |
| /* Time in ms from data size, because it is PCM16 samples */ |
| frameTimeDelta = |
| pEncInBuffer.pTableBufferSize[0] / sizeof(short) |
| / pC->ewc.uiNbChannels; |
| |
| /** |
| * Prepare output buffer */ |
| pEncOutBuffer.pTableBuffer[0] = |
| (M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress; |
| pEncOutBuffer.pTableBufferSize[0] = 0; |
| |
| M4OSA_TRACE2_0("L **** pre-encode"); |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /*OMX Audio decoder used. |
| * OMX Audio dec shell does internal buffering and hence does not return |
| a PCM buffer for every decodeStep call.* |
| * So PCM buffer sizes might be 0. In this case donot call encode Step*/ |
| |
| if( 0 != pEncInBuffer.pTableBufferSize[0] ) |
| { |
| |
| #endif |
| /** |
| * Encode the PCM audio */ |
| |
| err = |
| pC->ShellAPI.pAudioEncoderGlobalFcts->pFctStep( |
| pC->ewc.pAudioEncCtxt, |
| &pEncInBuffer, &pEncOutBuffer); |
| |
| if( ( M4NO_ERROR != err) |
| && (M4WAR_NO_MORE_AU != err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio():\ |
| pAudioEncoderGlobalFcts->pFctStep returns 0x%x", |
| err); |
| return err; |
| } |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| } |
| |
| #endif |
| |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC1); |
| |
| M4OSA_TRACE2_3( |
| "M .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION-prefetch:\ |
| M4VSS3GPP_intClipReadNextAudioFrame(b) returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| } |
| |
| /** |
| * Audio is now OK for decoding */ |
| pC->pC1->Astatus = M4VSS3GPP_kClipStatus_DECODE; |
| } |
| |
| /** |
| * Decode the first input audio */ |
| err = M4VSS3GPP_intClipDecodeCurrentAudioFrame(pC->pC1); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intClipDecodeCurrentAudioFrame(C1) returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Decode the second input audio */ |
| err = M4VSS3GPP_intClipDecodeCurrentAudioFrame(pC->pC2); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intClipDecodeCurrentAudioFrame(C2) returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Check both clips decoded the same amount of PCM samples */ |
| if( pC->pC1->AudioDecBufferOut.m_bufferSize |
| != pC->pC2->AudioDecBufferOut.m_bufferSize ) |
| { |
| M4OSA_TRACE1_2( |
| "ERR : AudioTransition: both clips AU must have the same decoded\ |
| PCM size! pc1 size=0x%x, pC2 size = 0x%x", |
| pC->pC1->AudioDecBufferOut.m_bufferSize, |
| pC->pC2->AudioDecBufferOut.m_bufferSize); |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /*OMX Audio decoder used. |
| * OMX Audio dec shell does internal buffering and hence does not return |
| a PCM buffer for every decodeStep call.* |
| * So PCM buffer sizes might be 0 or different for clip1 and clip2. |
| * So no need to return error in this case */ |
| |
| M4OSA_TRACE1_2( |
| "M4VSS3GPP_intEditStepAudio: , pc1 AudBuff size=0x%x,\ |
| pC2 AudBuff size = 0x%x", |
| pC->pC1->AudioDecBufferOut.m_bufferSize, |
| pC->pC2->AudioDecBufferOut.m_bufferSize); |
| |
| #else |
| |
| return M4VSS3GPP_ERR_AUDIO_DECODED_PCM_SIZE_ISSUE; |
| |
| #endif // M4VSS_SUPPORT_OMX_CODECS |
| |
| } |
| |
| /** |
| * Apply the audio effect on clip1 */ |
| if( pC->iClip1ActiveEffect >= 0 ) |
| { |
| err = M4VSS3GPP_intApplyAudioEffect(pC, 1, (M4OSA_Int16 |
| *)pC->pC1->AudioDecBufferOut.m_dataAddress, |
| pC->pC1->AudioDecBufferOut.m_bufferSize); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intApplyAudioEffect(C1) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Apply the audio effect on clip2 */ |
| if( pC->iClip2ActiveEffect >= 0 ) |
| { |
| err = M4VSS3GPP_intApplyAudioEffect(pC, 2, (M4OSA_Int16 |
| *)pC->pC2->AudioDecBufferOut.m_dataAddress, |
| pC->pC2->AudioDecBufferOut.m_bufferSize); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intApplyAudioEffect(C2) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Apply the transition effect */ |
| err = M4VSS3GPP_intAudioTransition(pC, |
| (M4OSA_Int16 *)pC->pC1->AudioDecBufferOut.m_dataAddress, |
| (M4OSA_Int16 *)pC->pC2->AudioDecBufferOut.m_dataAddress, |
| pC->pC1->AudioDecBufferOut.m_bufferSize); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intAudioTransition returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /* [Mono] or [Stereo interleaved] : all is in one buffer */ |
| pEncInBuffer.pTableBuffer[0] = |
| pC->pC1->AudioDecBufferOut.m_dataAddress; |
| pEncInBuffer.pTableBufferSize[0] = |
| pC->pC1->AudioDecBufferOut.m_bufferSize; |
| pEncInBuffer.pTableBuffer[1] = M4OSA_NULL; |
| pEncInBuffer.pTableBufferSize[1] = 0; |
| |
| /* Time in ms from data size, because it is PCM16 samples */ |
| frameTimeDelta = pEncInBuffer.pTableBufferSize[0] / sizeof(short) |
| / pC->ewc.uiNbChannels; |
| |
| /** |
| * Prepare output buffer */ |
| pEncOutBuffer.pTableBuffer[0] = |
| (M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress; |
| pEncOutBuffer.pTableBufferSize[0] = 0; |
| |
| M4OSA_TRACE2_0("N **** blend AUs"); |
| |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /*OMX Audio decoder used. |
| * OMX Audio dec shell does internal buffering and hence does not return |
| a PCM buffer for every decodeStep call.* |
| * So PCM buffer sizes might be 0. In this case donot call encode Step*/ |
| |
| if( 0 != pEncInBuffer.pTableBufferSize[0] ) |
| { |
| |
| #endif |
| |
| /** |
| * Encode the PCM audio */ |
| |
| err = pC->ShellAPI.pAudioEncoderGlobalFcts->pFctStep( |
| pC->ewc.pAudioEncCtxt, &pEncInBuffer, &pEncOutBuffer); |
| |
| if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio():\ |
| pAudioEncoderGlobalFcts->pFctStep returns 0x%x", |
| err); |
| return err; |
| } |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| } |
| |
| #endif |
| |
| /** |
| * Set AU cts and size */ |
| |
| pC->ewc.WriterAudioAU.size = pEncOutBuffer.pTableBufferSize[ |
| 0]; /**< Get the size of encoded data */ |
| pC->ewc.WriterAudioAU.CTS += frameTimeDelta; |
| |
| M4OSA_TRACE2_2("O ---- write : cts = %ld [ 0x%x ]", |
| (M4OSA_Int32)(pC->ewc.WriterAudioAU.CTS / pC->ewc.scale_audio), |
| pC->ewc.WriterAudioAU.size); |
| |
| /** |
| * Write the AU */ |
| err = pC->ShellAPI.pWriterDataFcts->pProcessAU( |
| pC->ewc.p3gpWriterContext, M4VSS3GPP_WRITER_AUDIO_STREAM_ID, |
| &pC->ewc.WriterAudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| /*11/12/2008 CR 3283 MMS use case for VideoArtist |
| the warning M4WAR_WRITER_STOP_REQ is returned when the targeted output |
| file size is reached |
| The editing is then finished,the warning M4VSS3GPP_WAR_EDITING_DONE |
| is returned*/ |
| if( M4WAR_WRITER_STOP_REQ == err ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intEditStepAudio: File was cut to avoid oversize"); |
| return M4VSS3GPP_WAR_EDITING_DONE; |
| } |
| else |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| pWriterDataFcts->pProcessAU returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Read the next audio frame */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC1); |
| |
| M4OSA_TRACE2_3("P .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC1->iAudioFrameCts / pC->pC1->scale_audio, |
| pC->pC1->iAoffset / pC->pC1->scale_audio, |
| pC->pC1->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intClipReadNextAudioFrame(C1) returns 0x%x!", |
| err); |
| return err; |
| } |
| else |
| { |
| M4OSA_ERR secondaryError; |
| |
| /** |
| * Update current time (to=tc+T) */ |
| pC->ewc.dATo = ( pC->pC1->iAudioFrameCts + pC->pC1->iAoffset) |
| / pC->pC1->scale_audio; |
| |
| /** |
| * Read the next audio frame in the second clip */ |
| secondaryError = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC2); |
| |
| M4OSA_TRACE2_3("Q .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC2->iAudioFrameCts / pC->pC2->scale_audio, |
| pC->pC2->iAoffset / pC->pC2->scale_audio, |
| pC->pC2->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(secondaryError) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: TRANSITION:\ |
| M4VSS3GPP_intClipReadNextAudioFrame(C2) returns 0x%x!", |
| secondaryError); |
| return err; |
| } |
| |
| if( ( ( M4WAR_NO_MORE_AU == err) |
| || (M4WAR_NO_MORE_AU == secondaryError)) |
| && (M4OSA_FALSE == pC->bSupportSilence) ) |
| { |
| /** |
| * If output is other than AMR or AAC |
| (i.e. EVRC,we can't write silence into it) |
| * So we simply end here.*/ |
| bStopAudio = M4OSA_TRUE; |
| } |
| } |
| } |
| break; |
| |
| /* ____________ */ |
| /*| |*/ |
| /*| ERROR CASE |*/ |
| /*|____________|*/ |
| |
| default: |
| |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intEditStepAudio: invalid internal state (0x%x), \ |
| returning M4VSS3GPP_ERR_INTERNAL_STATE", |
| pC->Astate); |
| return M4VSS3GPP_ERR_INTERNAL_STATE; |
| } |
| |
| /** |
| * Check if we are forced to stop audio */ |
| if( M4OSA_TRUE == bStopAudio ) |
| { |
| /** |
| * Audio is done for this clip */ |
| err = M4VSS3GPP_intReachedEndOfAudio(pC); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intEditStepAudio: M4VSS3GPP_intReachedEndOfAudio returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intEditStepAudio: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intCheckAudioMode() |
| * @brief Check which audio process mode we must use, depending on the output CTS. |
| * @param pC (IN/OUT) Internal edit context |
| ****************************************************************************** |
| */ |
| static M4OSA_ERR M4VSS3GPP_intCheckAudioMode( M4VSS3GPP_InternalEditContext |
| *pC ) |
| { |
| M4OSA_ERR err; |
| const M4OSA_Int32 TD = pC->pTransitionList[pC-> |
| uiCurrentClip].uiTransitionDuration; /**< Transition duration */ |
| |
| const M4VSS3GPP_EditAudioState previousAstate = pC->Astate; |
| |
| /** |
| * Check if Clip1 is on its begin cut, or in its begin effect or end effect zone */ |
| M4VSS3GPP_intCheckAudioEffects(pC, 1); |
| |
| /** |
| * Check if we are in the transition with next clip */ |
| if( ( TD > 0) && ((M4OSA_Int32)(pC->ewc.dATo - pC->pC1->iAoffset |
| / pC->pC1->scale_audio + 0.5) >= (pC->pC1->iEndTime - TD)) ) |
| { |
| /** |
| * We are in a transition */ |
| pC->Astate = M4VSS3GPP_kEditAudioState_TRANSITION; |
| pC->bTransitionEffect = M4OSA_TRUE; |
| |
| /** |
| * Do we enter the transition section ? */ |
| if( M4VSS3GPP_kEditAudioState_TRANSITION != previousAstate ) |
| { |
| /** |
| * Open second clip for transition, if not yet opened */ |
| if( M4OSA_NULL == pC->pC2 ) |
| { |
| err = M4VSS3GPP_intOpenClip(pC, &pC->pC2, |
| &pC->pClipList[pC->uiCurrentClip + 1]); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intCheckAudioMode: M4VSS3GPP_intOpenClip() returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| /** |
| * In case of short transition and bad luck (...), there may be no video AU |
| * in the transition. In that case, the second clip has not been opened. |
| * So we must update the video offset here. */ |
| // Decorrelate input and output encoding timestamp to handle encoder prefetch |
| /**< Add current video output CTS to the clip offset */ |
| pC->pC2->iVoffset += (M4OSA_UInt32)pC->ewc.dInputVidCts; |
| } |
| |
| /** |
| * Add current audio output CTS to the clip offset |
| * (video offset has already been set when doing the video transition) */ |
| pC->pC2->iAoffset += |
| (M4OSA_UInt32)(pC->ewc.dATo * pC->ewc.scale_audio + 0.5); |
| |
| /** |
| * 2005-03-24: BugFix for audio-video synchro: |
| * There may be a portion of the duration of an audio AU of desynchro at each assembly. |
| * It leads to an audible desynchro when there are a lot of clips assembled. |
| * This bug fix allows to resynch the audio track when the delta is higher |
| * than one audio AU duration. |
| * We Step one AU in the second clip and we change the audio offset accordingly. */ |
| if( ( pC->pC2->iAoffset |
| - (M4OSA_Int32)(pC->pC2->iVoffset *pC->pC2->scale_audio + 0.5)) |
| > pC->ewc.iSilenceFrameDuration ) |
| { |
| /** |
| * Advance one AMR frame */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pC->pC2); |
| |
| M4OSA_TRACE2_3("Z .... read : cts = %.0f + %.0f [ 0x%x ]", |
| pC->pC2->iAudioFrameCts / pC->pC2->scale_audio, |
| pC->pC2->iAoffset / pC->pC2->scale_audio, |
| pC->pC2->uiAudioFrameSize); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intCheckAudioMode:\ |
| M4VSS3GPP_intClipReadNextAudioFrame returns 0x%x!", |
| err); |
| return err; |
| } |
| /** |
| * Update audio offset accordingly*/ |
| pC->pC2->iAoffset -= pC->ewc.iSilenceFrameDuration; |
| } |
| } |
| |
| /** |
| * Check begin and end effects for clip2 */ |
| M4VSS3GPP_intCheckAudioEffects(pC, 2); |
| } |
| else |
| { |
| /** |
| * We are not in a transition */ |
| pC->bTransitionEffect = M4OSA_FALSE; |
| |
| /** |
| * Check if current mode is Read/Write or Decode/Encode */ |
| if( pC->iClip1ActiveEffect >= 0 ) |
| { |
| pC->Astate = M4VSS3GPP_kEditAudioState_DECODE_ENCODE; |
| } |
| else |
| { |
| pC->Astate = M4VSS3GPP_kEditAudioState_READ_WRITE; |
| } |
| } |
| |
| /** |
| * Check if we create/destroy an encoder */ |
| if( ( M4VSS3GPP_kEditAudioState_READ_WRITE == previousAstate) |
| && /**< read mode */ |
| (M4VSS3GPP_kEditAudioState_READ_WRITE != pC->Astate) ) /**< encode mode */ |
| { |
| M4OSA_UInt32 uiAudioBitrate; |
| |
| /* Compute max bitrate depending on input files bitrates and transitions */ |
| if( pC->Astate == M4VSS3GPP_kEditAudioState_TRANSITION ) |
| { |
| /* Max of the two blended files */ |
| if( pC->pC1->pSettings->ClipProperties.uiAudioBitrate |
| > pC->pC2->pSettings->ClipProperties.uiAudioBitrate ) |
| uiAudioBitrate = |
| pC->pC1->pSettings->ClipProperties.uiAudioBitrate; |
| else |
| uiAudioBitrate = |
| pC->pC2->pSettings->ClipProperties.uiAudioBitrate; |
| } |
| else |
| { |
| /* Same as input file */ |
| uiAudioBitrate = pC->pC1->pSettings->ClipProperties.uiAudioBitrate; |
| } |
| |
| /** |
| * Create the encoder */ |
| err = M4VSS3GPP_intCreateAudioEncoder(&pC->ewc, &pC->ShellAPI, |
| uiAudioBitrate); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intCheckAudioMode: M4VSS3GPP_intResetAudioEncoder() returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intCheckAudioMode(): returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_Void M4VSS3GPP_intCheckAudioEffects() |
| * @brief Check which audio effect must be applied at the current time |
| ****************************************************************************** |
| */ |
| static M4OSA_Void M4VSS3GPP_intCheckAudioEffects( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_UInt8 uiClipNumber ) |
| { |
| M4OSA_UInt8 uiClipIndex; |
| M4OSA_UInt8 uiFxIndex; |
| M4VSS3GPP_ClipContext *pClip; |
| M4VSS3GPP_EffectSettings *pFx; |
| M4OSA_Int32 BC, EC; |
| M4OSA_Int8 *piClipActiveEffect; |
| M4OSA_Int32 t; |
| |
| if( 1 == uiClipNumber ) |
| { |
| uiClipIndex = pC->uiCurrentClip; |
| pClip = pC->pC1; |
| piClipActiveEffect = &(pC->iClip1ActiveEffect); |
| } |
| else /**< (2 == uiClipNumber) */ |
| { |
| uiClipIndex = pC->uiCurrentClip + 1; |
| pClip = pC->pC2; |
| piClipActiveEffect = &(pC->iClip2ActiveEffect); |
| } |
| |
| /** |
| * Shortcuts for code readability */ |
| BC = pClip->iActualAudioBeginCut; |
| EC = pClip->iEndTime; |
| |
| /** |
| Change the absolut time to clip related time |
| RC t = (M4OSA_Int32)(pC->ewc.dATo - pClip->iAoffset/pClip->scale_audio + 0.5); |
| < rounding */; |
| t = (M4OSA_Int32)(pC->ewc.dATo/*- pClip->iAoffset/pClip->scale_audio*/ |
| + 0.5); /**< rounding */ |
| ; |
| |
| /** |
| * Default: no effect active */ |
| *piClipActiveEffect = -1; |
| |
| /** |
| * Check the three effects */ |
| // RC for (uiFxIndex=0; uiFxIndex<pC->pClipList[uiClipIndex].nbEffects; uiFxIndex++) |
| for ( uiFxIndex = 0; uiFxIndex < pC->nbEffects; uiFxIndex++ ) |
| { |
| /** Shortcut, reverse order because of priority between effects |
| ( EndEffect always clean ) */ |
| pFx = &(pC->pEffectsList[pC->nbEffects - 1 - uiFxIndex]); |
| |
| if( M4VSS3GPP_kAudioEffectType_None != pFx->AudioEffectType ) |
| { |
| /** |
| * Check if there is actually a video effect */ |
| if( ( t >= (M4OSA_Int32)(/*BC +*/pFx->uiStartTime)) |
| && /**< Are we after the start time of the effect? */ |
| (t < (M4OSA_Int32)(/*BC +*/pFx->uiStartTime + pFx-> |
| uiDuration)) ) /**< Are we into the effect duration? */ |
| { |
| /** |
| * Set the active effect */ |
| *piClipActiveEffect = pC->nbEffects - 1 - uiFxIndex; |
| |
| /** |
| * The first effect has the highest priority, then the second one, |
| then the thirs one. |
| * Hence, as soon as we found an active effect, we can get out of this loop */ |
| uiFxIndex = pC->nbEffects; /** get out of the for loop */ |
| } |
| /** |
| * Bugfix: The duration of the end effect has been set according to the |
| announced clip duration. |
| * If the announced duration is smaller than the real one, the end effect |
| won't be applied at |
| * the very end of the clip. To solve this issue we force the end effect. */ |
| |
| } |
| } |
| |
| return; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intApplyAudioEffect() |
| * @brief Apply audio effect to pPCMdata |
| * @param pC (IN/OUT) Internal edit context |
| * @param uiClip1orClip2 (IN/OUT) 1 for first clip, 2 for second clip |
| * @param pPCMdata (IN/OUT) Input and Output PCM audio data |
| * @param uiPCMsize (IN) Size of pPCMdata |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| static M4OSA_ERR M4VSS3GPP_intApplyAudioEffect( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_UInt8 uiClip1orClip2, |
| M4OSA_Int16 *pPCMdata, |
| M4OSA_UInt32 uiPCMsize ) |
| { |
| M4VSS3GPP_ClipContext *pClip; |
| M4VSS3GPP_ClipSettings *pClipSettings; |
| M4VSS3GPP_EffectSettings *pFx; |
| M4OSA_Int32 |
| i32sample; /**< we will cast each Int16 sample into this Int32 variable */ |
| M4OSA_Int32 iPos; |
| M4OSA_Int32 iDur; |
| |
| M4OSA_DEBUG_IF2(( 1 != uiClip1orClip2) && (2 != uiClip1orClip2), |
| M4ERR_PARAMETER, |
| "M4VSS3GPP_intBeginAudioEffect: uiClip1orClip2 invalid"); |
| |
| if( 1 == uiClip1orClip2 ) |
| { |
| pClip = pC->pC1; |
| pClipSettings = &(pC->pClipList[pC-> |
| uiCurrentClip]); /**< Get a shortcut to the clip settings */ |
| // RC pFx = &(pClipSettings->Effects[pC->iClip1ActiveEffect]);/**< Get a shortcut |
| // to the active effect */ |
| pFx = &(pC-> |
| pEffectsList[pC-> |
| iClip1ActiveEffect]); /**< Get a shortcut to the active effect */ |
| M4OSA_DEBUG_IF2(( pC->iClip1ActiveEffect < 0) |
| || (pC->iClip1ActiveEffect > 2), M4ERR_PARAMETER, |
| "M4VSS3GPP_intApplyAudioEffect: iClip1ActiveEffect invalid"); |
| } |
| else /**< if (2==uiClip1orClip2) */ |
| { |
| pClip = pC->pC2; |
| pClipSettings = &(pC->pClipList[pC->uiCurrentClip |
| + 1]); /**< Get a shortcut to the clip settings */ |
| // RC pFx = &(pClipSettings->Effects[pC->iClip2ActiveEffect]);/**< Get a shortcut |
| // to the active effect */ |
| pFx = &(pC-> |
| pEffectsList[pC-> |
| iClip2ActiveEffect]); /**< Get a shortcut to the active effect */ |
| M4OSA_DEBUG_IF2(( pC->iClip2ActiveEffect < 0) |
| || (pC->iClip2ActiveEffect > 2), M4ERR_PARAMETER, |
| "M4VSS3GPP_intApplyAudioEffect: iClip2ActiveEffect invalid"); |
| } |
| |
| iDur = (M4OSA_Int32)pFx->uiDuration; |
| |
| /** |
| * Compute how far from the beginning of the effect we are, in clip-base time. |
| * It is done with integers because the offset and begin cut have been rounded already. */ |
| iPos = |
| (M4OSA_Int32)(pC->ewc.dATo + 0.5 - pClip->iAoffset / pClip->scale_audio) |
| - pClip->iActualAudioBeginCut - pFx->uiStartTime; |
| |
| /** |
| * Sanity check */ |
| if( iPos > iDur ) |
| { |
| iPos = iDur; |
| } |
| else if( iPos < 0 ) |
| { |
| iPos = 0; |
| } |
| |
| /** |
| * At this point, iPos is the effect progress, in a 0 to iDur base */ |
| switch( pFx->AudioEffectType ) |
| { |
| case M4VSS3GPP_kAudioEffectType_FadeIn: |
| |
| /** |
| * Original samples are signed 16bits. |
| * We convert it to signed 32bits and multiply it by iPos. |
| * So we must assure that iPos is not higher that 16bits max. |
| * iPos max value is iDur, so we test iDur. */ |
| while( iDur > PWR_FXP_FRACT_MAX ) |
| { |
| iDur >>= |
| 2; /**< divide by 2 would be more logical (instead of 4), |
| but we have enough dynamic..) */ |
| iPos >>= 2; /**< idem */ |
| } |
| |
| /** |
| * From buffer size (bytes) to number of sample (int16): divide by two */ |
| uiPCMsize >>= 1; |
| |
| /** |
| * Loop on samples */ |
| while( uiPCMsize-- > 0 ) /**< decrementing to optimize */ |
| { |
| i32sample = *pPCMdata; |
| i32sample *= iPos; |
| i32sample /= iDur; |
| *pPCMdata++ = (M4OSA_Int16)i32sample; |
| } |
| |
| break; |
| |
| case M4VSS3GPP_kAudioEffectType_FadeOut: |
| |
| /** |
| * switch from 0->Dur to Dur->0 in order to do fadeOUT instead of fadeIN */ |
| iPos = iDur - iPos; |
| |
| /** |
| * Original samples are signed 16bits. |
| * We convert it to signed 32bits and multiply it by iPos. |
| * So we must assure that iPos is not higher that 16bits max. |
| * iPos max value is iDur, so we test iDur. */ |
| while( iDur > PWR_FXP_FRACT_MAX ) |
| { |
| iDur >>= |
| 2; /**< divide by 2 would be more logical (instead of 4), |
| but we have enough dynamic..) */ |
| iPos >>= 2; /**< idem */ |
| } |
| |
| /** |
| * From buffer size (bytes) to number of sample (int16): divide by two */ |
| uiPCMsize >>= 1; |
| |
| /** |
| * Loop on samples, apply the fade factor on each */ |
| while( uiPCMsize-- > 0 ) /**< decrementing counter to optimize */ |
| { |
| i32sample = *pPCMdata; |
| i32sample *= iPos; |
| i32sample /= iDur; |
| *pPCMdata++ = (M4OSA_Int16)i32sample; |
| } |
| |
| break; |
| |
| default: |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intApplyAudioEffect: unknown audio effect type (0x%x),\ |
| returning M4VSS3GPP_ERR_INVALID_AUDIO_EFFECT_TYPE", |
| pFx->AudioEffectType); |
| return M4VSS3GPP_ERR_INVALID_AUDIO_EFFECT_TYPE; |
| } |
| |
| /** |
| * Return */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intApplyAudioEffect: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intAudioTransition() |
| * @brief Apply transition effect to two PCM buffer |
| * @note The result of the transition is put in the first buffer. |
| * I know it's not beautiful, but it fits my current needs, and it's efficient! |
| * So why bother with a third output buffer? |
| * @param pC (IN/OUT) Internal edit context |
| * @param pPCMdata1 (IN/OUT) First input and Output PCM audio data |
| * @param pPCMdata2 (IN) Second input PCM audio data |
| * @param uiPCMsize (IN) Size of both PCM buffers |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| static M4OSA_ERR M4VSS3GPP_intAudioTransition( M4VSS3GPP_InternalEditContext |
| *pC, M4OSA_Int16 *pPCMdata1, |
| M4OSA_Int16 *pPCMdata2, |
| M4OSA_UInt32 uiPCMsize ) |
| { |
| M4OSA_Int32 i32sample1, |
| i32sample2; /**< we will cast each Int16 sample into this Int32 variable */ |
| M4OSA_Int32 iPos1, iPos2; |
| M4OSA_Int32 iDur = (M4OSA_Int32)pC-> |
| pTransitionList[pC->uiCurrentClip].uiTransitionDuration; |
| |
| /** |
| * Compute how far from the end cut we are, in clip-base time. |
| * It is done with integers because the offset and begin cut have been rounded already. */ |
| iPos1 = pC->pC1->iEndTime - (M4OSA_Int32)(pC->ewc.dATo |
| + 0.5 - pC->pC1->iAoffset / pC->pC1->scale_audio); |
| |
| /** |
| * Sanity check */ |
| if( iPos1 > iDur ) |
| { |
| iPos1 = iDur; |
| } |
| else if( iPos1 < 0 ) |
| { |
| iPos1 = 0; |
| } |
| |
| /** |
| * Position of second clip in the transition */ |
| iPos2 = iDur - iPos1; |
| |
| /** |
| * At this point, iPos2 is the transition progress, in a 0 to iDur base. |
| * iPos1 is the transition progress, in a iDUr to 0 base. */ |
| switch( pC->pTransitionList[pC->uiCurrentClip].AudioTransitionType ) |
| { |
| case M4VSS3GPP_kAudioTransitionType_CrossFade: |
| |
| /** |
| * Original samples are signed 16bits. |
| * We convert it to signed 32bits and multiply it by iPos. |
| * So we must assure that iPos is not higher that 16bits max. |
| * iPos max value is iDur, so we test iDur. */ |
| while( iDur > PWR_FXP_FRACT_MAX ) |
| { |
| iDur >>= |
| 2; /**< divide by 2 would be more logical (instead of 4), |
| but we have enough dynamic..) */ |
| iPos1 >>= 2; /**< idem */ |
| iPos2 >>= 2; /**< idem */ |
| } |
| |
| /** |
| * From buffer size (bytes) to number of sample (int16): divide by two */ |
| uiPCMsize >>= 1; |
| |
| /** |
| * Loop on samples, apply the fade factor on each */ |
| while( uiPCMsize-- > 0 ) /**< decrementing counter to optimize */ |
| { |
| i32sample1 = *pPCMdata1; /**< Get clip1 sample */ |
| i32sample1 *= iPos1; /**< multiply by fade numerator */ |
| i32sample1 /= iDur; /**< divide by fade denominator */ |
| |
| i32sample2 = *pPCMdata2; /**< Get clip2 sample */ |
| i32sample2 *= iPos2; /**< multiply by fade numerator */ |
| i32sample2 /= iDur; /**< divide by fade denominator */ |
| |
| *pPCMdata1++ = (M4OSA_Int16)(i32sample1 |
| + i32sample2); /**< mix the two samples */ |
| pPCMdata2++; /**< don't forget to increment the second buffer */ |
| } |
| break; |
| |
| case M4VSS3GPP_kAudioTransitionType_None: |
| /** |
| * This is a stupid-non optimized version of the None transition... |
| * We copy the PCM frames */ |
| if( iPos1 < (iDur >> 1) ) /**< second half of transition */ |
| { |
| /** |
| * Copy the input PCM to the output buffer */ |
| memcpy((void *)pPCMdata1, |
| (void *)pPCMdata2, uiPCMsize); |
| } |
| /** |
| * the output must be put in the first buffer. |
| * For the first half of the non-transition it's already the case! |
| * So we have nothing to do here... |
| */ |
| |
| break; |
| |
| default: |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intAudioTransition: unknown transition type (0x%x),\ |
| returning M4VSS3GPP_ERR_INVALID_AUDIO_TRANSITION_TYPE", |
| pC->pTransitionList[pC->uiCurrentClip].AudioTransitionType); |
| return M4VSS3GPP_ERR_INVALID_AUDIO_TRANSITION_TYPE; |
| } |
| |
| /** |
| * Return */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intAudioTransition: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intCreateAudioEncoder() |
| * @brief Reset the audio encoder (Create it if needed) |
| * @note |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intCreateAudioEncoder( M4VSS3GPP_EncodeWriteContext *pC_ewc, |
| M4VSS3GPP_MediaAndCodecCtxt *pC_ShellAPI, |
| M4OSA_UInt32 uiAudioBitrate ) |
| { |
| M4OSA_ERR err; |
| |
| /** |
| * If an encoder already exist, we destroy it */ |
| if( M4OSA_NULL != pC_ewc->pAudioEncCtxt ) |
| { |
| err = pC_ShellAPI->pAudioEncoderGlobalFcts->pFctClose( |
| pC_ewc->pAudioEncCtxt); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intResetAudioEncoder: pAudioEncoderGlobalFcts->pFctClose returns 0x%x", |
| err); |
| /**< don't return, we still have stuff to free */ |
| } |
| |
| err = pC_ShellAPI->pAudioEncoderGlobalFcts->pFctCleanUp( |
| pC_ewc->pAudioEncCtxt); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intResetAudioEncoder:\ |
| pAudioEncoderGlobalFcts->pFctCleanUp returns 0x%x", err); |
| /**< don't return, we still have stuff to free */ |
| } |
| |
| pC_ewc->pAudioEncCtxt = M4OSA_NULL; |
| } |
| |
| /** |
| * Creates a new encoder */ |
| switch( pC_ewc->AudioStreamType ) |
| { |
| //EVRC |
| // case M4SYS_kEVRC: |
| // |
| // err = M4VSS3GPP_setCurrentAudioEncoder(&pC->ShellAPI, |
| // pC_ewc->AudioStreamType); |
| // M4ERR_CHECK_RETURN(err); |
| // |
| // pC_ewc->AudioEncParams.Format = M4ENCODER_kEVRC; |
| // pC_ewc->AudioEncParams.Frequency = M4ENCODER_k8000Hz; |
| // pC_ewc->AudioEncParams.ChannelNum = M4ENCODER_kMono; |
| // pC_ewc->AudioEncParams.Bitrate = M4VSS3GPP_EVRC_DEFAULT_BITRATE; |
| // break; |
| |
| case M4SYS_kAMR: |
| |
| err = M4VSS3GPP_setCurrentAudioEncoder(pC_ShellAPI, |
| pC_ewc->AudioStreamType); |
| M4ERR_CHECK_RETURN(err); |
| |
| pC_ewc->AudioEncParams.Format = M4ENCODER_kAMRNB; |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k8000Hz; |
| pC_ewc->AudioEncParams.ChannelNum = M4ENCODER_kMono; |
| pC_ewc->AudioEncParams.Bitrate = M4VSS3GPP_AMR_DEFAULT_BITRATE; |
| pC_ewc->AudioEncParams.SpecifParam.AmrSID = M4ENCODER_kAmrNoSID; |
| break; |
| |
| case M4SYS_kAAC: |
| |
| err = M4VSS3GPP_setCurrentAudioEncoder(pC_ShellAPI, |
| pC_ewc->AudioStreamType); |
| M4ERR_CHECK_RETURN(err); |
| |
| pC_ewc->AudioEncParams.Format = M4ENCODER_kAAC; |
| |
| switch( pC_ewc->uiSamplingFrequency ) |
| { |
| case 8000: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k8000Hz; |
| break; |
| |
| case 16000: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k16000Hz; |
| break; |
| |
| case 22050: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k22050Hz; |
| break; |
| |
| case 24000: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k24000Hz; |
| break; |
| |
| case 32000: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k32000Hz; |
| break; |
| |
| case 44100: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k44100Hz; |
| break; |
| |
| case 48000: |
| pC_ewc->AudioEncParams.Frequency = M4ENCODER_k48000Hz; |
| break; |
| |
| default: |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intCreateAudioEncoder: invalid input AAC sampling frequency\ |
| (%d Hz), returning M4VSS3GPP_ERR_AUDIO_DECODER_INIT_FAILED", |
| pC_ewc->uiSamplingFrequency); |
| return M4VSS3GPP_ERR_AUDIO_DECODER_INIT_FAILED; |
| } |
| pC_ewc->AudioEncParams.ChannelNum = (pC_ewc->uiNbChannels == 1) |
| ? M4ENCODER_kMono : M4ENCODER_kStereo; |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.Regulation = |
| M4ENCODER_kAacRegulNone; //M4ENCODER_kAacBitReservoir |
| /* unused */ |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.bIS = M4OSA_FALSE; |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.bMS = M4OSA_FALSE; |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.bPNS = M4OSA_FALSE; |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.bTNS = M4OSA_FALSE; |
| /* TODO change into highspeed asap */ |
| pC_ewc->AudioEncParams.SpecifParam.AacParam.bHighSpeed = |
| M4OSA_FALSE; |
| |
| /* Quantify value (ceil one) */ |
| if( uiAudioBitrate <= 16000 ) |
| pC_ewc->AudioEncParams.Bitrate = 16000; |
| |
| else if( uiAudioBitrate <= 24000 ) |
| pC_ewc->AudioEncParams.Bitrate = 24000; |
| |
| else if( uiAudioBitrate <= 32000 ) |
| pC_ewc->AudioEncParams.Bitrate = 32000; |
| |
| else if( uiAudioBitrate <= 48000 ) |
| pC_ewc->AudioEncParams.Bitrate = 48000; |
| |
| else if( uiAudioBitrate <= 64000 ) |
| pC_ewc->AudioEncParams.Bitrate = 64000; |
| |
| else |
| pC_ewc->AudioEncParams.Bitrate = 96000; |
| |
| /* Special requirement of our encoder */ |
| if( ( pC_ewc->uiNbChannels == 2) |
| && (pC_ewc->AudioEncParams.Bitrate < 32000) ) |
| pC_ewc->AudioEncParams.Bitrate = 32000; |
| |
| break; |
| |
| default: |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intResetAudioEncoder: Undefined output audio format (%d),\ |
| returning M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT", |
| pC_ewc->AudioStreamType); |
| return M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT; |
| } |
| |
| /* Initialise the audio encoder */ |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intResetAudioEncoder:\ |
| pAudioEncoderGlobalFcts->pFctInit called with userdata 0x%x", |
| pC_ShellAPI->pCurrentAudioEncoderUserData); |
| err = pC_ShellAPI->pAudioEncoderGlobalFcts->pFctInit(&pC_ewc->pAudioEncCtxt, |
| pC_ShellAPI->pCurrentAudioEncoderUserData); |
| |
| #else |
| |
| err = pC_ShellAPI->pAudioEncoderGlobalFcts->pFctInit(&pC_ewc->pAudioEncCtxt, |
| M4OSA_NULL /* no HW encoder */); |
| |
| #endif |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intResetAudioEncoder: pAudioEncoderGlobalFcts->pFctInit returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /* Open the audio encoder */ |
| err = pC_ShellAPI->pAudioEncoderGlobalFcts->pFctOpen(pC_ewc->pAudioEncCtxt, |
| &pC_ewc->AudioEncParams, &pC_ewc->pAudioEncDSI, |
| M4OSA_NULL /* no grabbing */); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intResetAudioEncoder: pAudioEncoderGlobalFcts->pFctOpen returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intResetAudioEncoder: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
