| /* |
| * 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_Clip.c |
| * @brief Implementation of functions related to input clip management. |
| * @note All functions in this file are static, i.e. non public |
| ****************************************************************************** |
| */ |
| |
| /****************/ |
| /*** Includes ***/ |
| /****************/ |
| |
| #include "NXPSW_CompilerSwitches.h" |
| /** |
| * Our headers */ |
| #include "M4VSS3GPP_API.h" |
| #include "M4VSS3GPP_ErrorCodes.h" |
| #include "M4VSS3GPP_InternalTypes.h" |
| #include "M4VSS3GPP_InternalFunctions.h" |
| #include "M4VSS3GPP_InternalConfig.h" |
| |
| /** |
| * OSAL headers */ |
| #include "M4OSA_Memory.h" /* OSAL memory management */ |
| #include "M4OSA_Debug.h" /* OSAL debug management */ |
| |
| |
| /** |
| * Common headers (for aac) */ |
| #include "M4_Common.h" |
| |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| #include "M4VD_EXTERNAL_Interface.h" |
| |
| #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */ |
| |
| /* Osal header fileno */ |
| #include "M4OSA_CharStar.h" |
| |
| /** |
| ****************************************************************************** |
| * define Static function prototypes |
| ****************************************************************************** |
| */ |
| |
| static M4OSA_ERR M4VSS3GPP_intClipPrepareAudioDecoder( |
| M4VSS3GPP_ClipContext *pClipCtxt ); |
| |
| static M4OSA_ERR M4VSS3GPP_intCheckAndGetCodecAacProperties( |
| M4VSS3GPP_ClipContext *pClipCtxt); |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipOpen() |
| * @brief Open a clip. Creates a clip context. |
| * @note |
| * @param hClipCtxt (OUT) Return the internal clip context |
| * @param pClipSettings (IN) Edit settings of this clip. The module will keep a |
| * reference to this pointer |
| * @param pFileReadPtrFct (IN) Pointer to OSAL file reader functions |
| * @param bSkipAudioTrack (IN) If true, do not open the audio |
| * @param bFastOpenMode (IN) If true, use the fast mode of the 3gpp reader |
| * (only the first AU is read) |
| * @return M4NO_ERROR: No error |
| * @return M4ERR_ALLOC: There is no more available memory |
| ****************************************************************************** |
| */ |
| |
| M4OSA_ERR M4VSS3GPP_intClipInit( M4VSS3GPP_ClipContext ** hClipCtxt, |
| M4OSA_FileReadPointer *pFileReadPtrFct ) |
| { |
| M4VSS3GPP_ClipContext *pClipCtxt; |
| M4OSA_ERR err; |
| |
| M4OSA_DEBUG_IF2((M4OSA_NULL == hClipCtxt), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipInit: hClipCtxt is M4OSA_NULL"); |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pFileReadPtrFct), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipInit: pFileReadPtrFct is M4OSA_NULL"); |
| |
| /** |
| * Allocate the clip context */ |
| *hClipCtxt = |
| (M4VSS3GPP_ClipContext *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_ClipContext), |
| M4VSS3GPP, (M4OSA_Char *)"M4VSS3GPP_ClipContext"); |
| |
| if( M4OSA_NULL == *hClipCtxt ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intClipInit(): unable to allocate M4VSS3GPP_ClipContext,\ |
| returning M4ERR_ALLOC"); |
| return M4ERR_ALLOC; |
| } |
| M4OSA_TRACE3_1("M4VSS3GPP_intClipInit(): clipCtxt=0x%x", *hClipCtxt); |
| |
| |
| /** |
| * Use this shortcut to simplify the code */ |
| pClipCtxt = *hClipCtxt; |
| |
| /* Inialization of context Variables */ |
| memset((void *)pClipCtxt, 0,sizeof(M4VSS3GPP_ClipContext)); |
| |
| pClipCtxt->pSettings = M4OSA_NULL; |
| |
| /** |
| * Init the clip context */ |
| pClipCtxt->iVoffset = 0; |
| pClipCtxt->iAoffset = 0; |
| pClipCtxt->Vstatus = M4VSS3GPP_kClipStatus_READ; |
| pClipCtxt->Astatus = M4VSS3GPP_kClipStatus_READ; |
| |
| pClipCtxt->pReaderContext = M4OSA_NULL; |
| pClipCtxt->pVideoStream = M4OSA_NULL; |
| pClipCtxt->pAudioStream = M4OSA_NULL; |
| pClipCtxt->VideoAU.m_dataAddress = M4OSA_NULL; |
| pClipCtxt->AudioAU.m_dataAddress = M4OSA_NULL; |
| |
| pClipCtxt->pViDecCtxt = M4OSA_NULL; |
| pClipCtxt->iVideoDecCts = 0; |
| pClipCtxt->iVideoRenderCts = 0; |
| pClipCtxt->lastDecodedPlane = M4OSA_NULL; |
| pClipCtxt->iActualVideoBeginCut = 0; |
| pClipCtxt->iActualAudioBeginCut = 0; |
| pClipCtxt->bVideoAuAvailable = M4OSA_FALSE; |
| pClipCtxt->bFirstAuWritten = M4OSA_FALSE; |
| |
| pClipCtxt->bMpeg4GovState = M4OSA_FALSE; |
| |
| pClipCtxt->bAudioFrameAvailable = M4OSA_FALSE; |
| pClipCtxt->pAudioFramePtr = M4OSA_NULL; |
| pClipCtxt->iAudioFrameCts = 0; |
| pClipCtxt->pAudioDecCtxt = 0; |
| pClipCtxt->AudioDecBufferOut.m_bufferSize = 0; |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = M4OSA_NULL; |
| |
| pClipCtxt->pFileReadPtrFct = pFileReadPtrFct; |
| pClipCtxt->pPlaneYuv = M4OSA_NULL; |
| pClipCtxt->pPlaneYuvWithEffect = M4OSA_NULL; |
| pClipCtxt->m_pPreResizeFrame = M4OSA_NULL; |
| pClipCtxt->bGetYuvDataFromDecoder = M4OSA_TRUE; |
| |
| /* |
| * Reset pointers for media and codecs interfaces */ |
| err = M4VSS3GPP_clearInterfaceTables(&pClipCtxt->ShellAPI); |
| M4ERR_CHECK_RETURN(err); |
| |
| /* |
| * Call the media and codecs subscription module */ |
| err = M4VSS3GPP_subscribeMediaAndCodec(&pClipCtxt->ShellAPI); |
| M4ERR_CHECK_RETURN(err); |
| |
| return M4NO_ERROR; |
| } |
| |
| // This method maps the frequency value to a string. |
| static const char* freqToString(int freq) { |
| switch (freq) { |
| case 8000: |
| return "_8000"; |
| case 11025: |
| return "_11025"; |
| case 12000: |
| return "_12000"; |
| case 16000: |
| return "_16000"; |
| case 22050: |
| return "_22050"; |
| case 24000: |
| return "_24000"; |
| case 32000: |
| return "_32000"; |
| case 44100: |
| return "_44100"; |
| case 48000: |
| return "_48000"; |
| default: |
| M4OSA_TRACE1_1("Unsupported sampling rate: %d Hz", freq); |
| return NULL; |
| } |
| } |
| |
| // This method maps the number of channel value to |
| // a string that will be part of a file name extension |
| static const char* channelToStringAndFileExt(int channels) { |
| switch (channels) { |
| case 1: |
| return "_1.pcm"; |
| case 2: |
| return "_2.pcm"; |
| default: |
| M4OSA_TRACE1_1("Unsupported %d channels", channels); |
| return NULL; |
| } |
| } |
| |
| /* Note: if the clip is opened in fast mode, it can only be used for analysis and nothing else. */ |
| M4OSA_ERR M4VSS3GPP_intClipOpen( M4VSS3GPP_ClipContext *pClipCtxt, |
| M4VSS3GPP_ClipSettings *pClipSettings, M4OSA_Bool bSkipAudioTrack, |
| M4OSA_Bool bFastOpenMode, M4OSA_Bool bAvoidOpeningVideoDec ) |
| { |
| M4OSA_ERR err; |
| M4READER_MediaFamily mediaFamily; |
| M4_StreamHandler *pStreamHandler; |
| M4_StreamHandler dummyStreamHandler; |
| M4OSA_Int32 iDuration; |
| M4OSA_Void *decoderUserData; |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| |
| M4DECODER_MPEG4_DecoderConfigInfo dummy; |
| M4DECODER_VideoSize videoSizeFromDSI; |
| #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */ |
| |
| M4DECODER_OutputFilter FilterOption; |
| |
| /** |
| * Check input parameters */ |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pClipCtxt), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipOpen: pClipCtxt is M4OSA_NULL"); |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettings), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipOpen: pClipSettings is M4OSA_NULL"); |
| |
| M4OSA_TRACE3_2( |
| "M4VSS3GPP_intClipOpen: called with pClipCtxt: 0x%x, bAvoidOpeningVideoDec=0x%x", |
| pClipCtxt, bAvoidOpeningVideoDec); |
| /** |
| * Keep a pointer to the clip settings. Remember that we don't possess it! */ |
| pClipCtxt->pSettings = pClipSettings; |
| if(M4VIDEOEDITING_kFileType_ARGB8888 == pClipCtxt->pSettings->FileType) { |
| M4OSA_TRACE3_0("M4VSS3GPP_intClipOpen: Image stream; set current vid dec"); |
| err = M4VSS3GPP_setCurrentVideoDecoder( |
| &pClipCtxt->ShellAPI, M4DA_StreamTypeVideoARGB8888); |
| M4ERR_CHECK_RETURN(err); |
| |
| decoderUserData = M4OSA_NULL; |
| |
| err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctCreate( |
| &pClipCtxt->pViDecCtxt, |
| &dummyStreamHandler, |
| pClipCtxt->ShellAPI.m_pReader, |
| pClipCtxt->ShellAPI.m_pReaderDataIt, |
| &pClipCtxt->VideoAU, |
| decoderUserData); |
| |
| if (M4NO_ERROR != err) { |
| M4OSA_TRACE1_1("M4VSS3GPP_intClipOpen: \ |
| m_pVideoDecoder->m_pFctCreate returns 0x%x", err); |
| return err; |
| } |
| M4OSA_TRACE3_1("M4VSS3GPP_intClipOpen: \ |
| Vid dec started; pViDecCtxt=0x%x", pClipCtxt->pViDecCtxt); |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| * Get the correct reader interface */ |
| err = M4VSS3GPP_setCurrentReader(&pClipCtxt->ShellAPI, |
| pClipCtxt->pSettings->FileType); |
| M4ERR_CHECK_RETURN(err); |
| |
| /** |
| * Init the 3GPP or MP3 reader */ |
| err = |
| pClipCtxt->ShellAPI.m_pReader->m_pFctCreate(&pClipCtxt->pReaderContext); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctCreate returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Link the reader interface to the reader context (used by the decoder to know the reader) */ |
| pClipCtxt->ShellAPI.m_pReaderDataIt->m_readerContext = |
| pClipCtxt->pReaderContext; |
| |
| /** |
| * Set the OSAL read function set */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctSetOption( |
| pClipCtxt->pReaderContext, |
| M4READER_kOptionID_SetOsaFileReaderFctsPtr, |
| (M4OSA_DataOption)(pClipCtxt->pFileReadPtrFct)); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctSetOption returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Set the fast open mode if asked (3GPP only) */ |
| if( M4VIDEOEDITING_kFileType_3GPP == pClipCtxt->pSettings->FileType ) |
| { |
| if( M4OSA_TRUE == bFastOpenMode ) |
| { |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctSetOption( |
| pClipCtxt->pReaderContext, |
| M4READER_3GP_kOptionID_FastOpenMode, M4OSA_NULL); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen():\ |
| m_pReader->m_pFctSetOption(FastOpenMode) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Set the skip audio option if asked */ |
| if( M4OSA_TRUE == bSkipAudioTrack ) |
| { |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctSetOption( |
| pClipCtxt->pReaderContext, |
| M4READER_3GP_kOptionID_VideoOnly, M4OSA_NULL); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctSetOption(VideoOnly) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| } |
| if (pClipCtxt->pSettings->FileType == M4VIDEOEDITING_kFileType_PCM) { |
| // Compose the temp filename with sample rate and channel information. |
| const char* freqStr = freqToString( |
| pClipCtxt->pSettings->ClipProperties.uiSamplingFrequency); |
| |
| if (freqStr == NULL) { |
| return M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_SAMPLING_FREQUENCY; |
| } |
| |
| const char* chanStr = channelToStringAndFileExt( |
| pClipCtxt->pSettings->ClipProperties.uiNbChannels); |
| |
| if (chanStr == NULL) { |
| return M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_NB_OF_CHANNELS; |
| } |
| |
| // Allocate one byte more to hold the null terminator |
| M4OSA_UInt32 length = |
| strlen(pClipSettings->pFile) + strlen(freqStr) + strlen(chanStr) + 1; |
| |
| char* pTempFile = (char *) malloc(length); |
| if (pTempFile == NULL) { |
| M4OSA_TRACE1_1("M4VSS3GPP_intClipOpen(): malloc %d bytes fail",length); |
| return M4ERR_ALLOC; |
| } |
| memset(pTempFile, 0, length); |
| memcpy(pTempFile, pClipSettings->pFile, strlen(pClipSettings->pFile)); |
| strncat(pTempFile, freqStr, strlen(freqStr)); |
| strncat(pTempFile, chanStr, strlen(chanStr)); |
| |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctOpen( pClipCtxt->pReaderContext, pTempFile); |
| if (pTempFile != NULL) { |
| free(pTempFile); |
| pTempFile = NULL; |
| } |
| if ( M4NO_ERROR != err ) { |
| M4OSA_TRACE1_1("M4VSS3GPP_intClipOpen(): open pcm file returns error : 0x%x", err); |
| return err; |
| } |
| } |
| else |
| { |
| /** |
| * Open the 3GPP/MP3 clip file */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctOpen( pClipCtxt->pReaderContext, |
| pClipSettings->pFile); |
| } |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_UInt32 uiDummy, uiCoreId; |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctOpen returns 0x%x", err); |
| |
| /** |
| * If the error is from the core reader, we change it to a public VSS3GPP error */ |
| M4OSA_ERR_SPLIT(err, uiDummy, uiCoreId, uiDummy); |
| |
| if( M4MP4_READER == uiCoreId ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intClipOpen(): returning M4VSS3GPP_ERR_INVALID_3GPP_FILE"); |
| return M4VSS3GPP_ERR_INVALID_3GPP_FILE; |
| } |
| return err; |
| } |
| |
| /** |
| * Get the audio and video streams */ |
| while( err == M4NO_ERROR ) |
| { |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctGetNextStream( |
| pClipCtxt->pReaderContext, &mediaFamily, &pStreamHandler); |
| |
| /*in case we found a BIFS stream or something else...*/ |
| if( ( err == ((M4OSA_UInt32)M4ERR_READER_UNKNOWN_STREAM_TYPE)) |
| || (err == ((M4OSA_UInt32)M4WAR_TOO_MUCH_STREAMS)) ) |
| { |
| err = M4NO_ERROR; |
| continue; |
| } |
| |
| if( M4NO_ERROR == err ) /**< One stream found */ |
| { |
| /** |
| * Found a video stream */ |
| if( ( mediaFamily == M4READER_kMediaFamilyVideo) |
| && (M4OSA_NULL == pClipCtxt->pVideoStream) ) |
| { |
| if( ( M4DA_StreamTypeVideoH263 == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeVideoMpeg4 |
| == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeVideoMpeg4Avc |
| == pStreamHandler->m_streamType) ) |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipOpen():\ |
| Found a H263 or MPEG-4 or H264 video stream in input 3gpp clip; %d", |
| pStreamHandler->m_streamType); |
| |
| /** |
| * Keep pointer to the video stream */ |
| pClipCtxt->pVideoStream = |
| (M4_VideoStreamHandler *)pStreamHandler; |
| pStreamHandler->m_bStreamIsOK = M4OSA_TRUE; |
| |
| /** |
| * Reset the stream reader */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctReset( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pVideoStream); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctReset(video) returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Initializes an access Unit */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctFillAuStruct( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pVideoStream, |
| &pClipCtxt->VideoAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen():\ |
| m_pReader->m_pFctFillAuStruct(video) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| else /**< Not H263 or MPEG-4 (H264, etc.) */ |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS_editClipOpen():\ |
| Found an unsupported video stream (0x%x) in input 3gpp clip", |
| pStreamHandler->m_streamType); |
| |
| pStreamHandler->m_bStreamIsOK = M4OSA_FALSE; |
| } |
| } |
| /** |
| * Found an audio stream */ |
| else if( ( mediaFamily == M4READER_kMediaFamilyAudio) |
| && (M4OSA_NULL == pClipCtxt->pAudioStream) ) |
| { |
| if( ( M4DA_StreamTypeAudioAmrNarrowBand |
| == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeAudioAac == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeAudioMp3 |
| == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeAudioEvrc |
| == pStreamHandler->m_streamType) |
| || (M4DA_StreamTypeAudioPcm |
| == pStreamHandler->m_streamType) ) |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipOpen(): \ |
| Found an AMR-NB or AAC or MP3 audio stream in input clip; %d", |
| pStreamHandler->m_streamType); |
| |
| /** |
| * Keep pointer to the audio stream */ |
| pClipCtxt->pAudioStream = |
| (M4_AudioStreamHandler *)pStreamHandler; |
| pStreamHandler->m_bStreamIsOK = M4OSA_TRUE; |
| |
| /** |
| * Reset the stream reader */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctReset( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctReset(audio) returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Initializes an access Unit */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctFillAuStruct( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &pClipCtxt->AudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen():\ |
| m_pReader->m_pFctFillAuStruct(audio) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| else /**< Not AMR-NB or AAC (AMR-WB...) */ |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen():\ |
| Found an unsupported audio stream (0x%x) in input 3gpp/mp3 clip", |
| pStreamHandler->m_streamType); |
| |
| pStreamHandler->m_bStreamIsOK = M4OSA_FALSE; |
| } |
| } |
| } |
| else if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen(): m_pReader->m_pFctGetNextStream() returns 0x%x!", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Init Video decoder */ |
| if( M4OSA_NULL != pClipCtxt->pVideoStream ) |
| { |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| /* If external decoders are possible, it's best to avoid opening the decoder if the clip is only |
| going to be used for analysis, as we're not going to use it for the analysis in the case of a |
| possible external decoder anyway, and either there could be no decoder at this point or the HW |
| decoder could be present, which we want to avoid opening for that. See comments in |
| intBuildAnalysis for more details. */ |
| |
| /* CHANGEME Temporarily only do this for MPEG4, since for now only MPEG4 external decoders are |
| supported, and the following wouldn't work for H263 so a release where external decoders are |
| possible, but not used, wouldn't work with H263 stuff. */ |
| |
| if( bAvoidOpeningVideoDec && M4DA_StreamTypeVideoMpeg4 |
| == pClipCtxt->pVideoStream->m_basicProperties.m_streamType ) |
| { |
| /* Oops! The mere act of opening the decoder also results in the image size being |
| filled in the video stream! Compensate for this by using ParseVideoDSI to fill |
| this info. */ |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipOpen: Mpeg4 stream; vid dec not started"); |
| err = M4DECODER_EXTERNAL_ParseVideoDSI(pClipCtxt->pVideoStream-> |
| m_basicProperties.m_pDecoderSpecificInfo, |
| pClipCtxt->pVideoStream-> |
| m_basicProperties.m_decoderSpecificInfoSize, |
| &dummy, &videoSizeFromDSI); |
| |
| pClipCtxt->pVideoStream->m_videoWidth = videoSizeFromDSI.m_uiWidth; |
| pClipCtxt->pVideoStream->m_videoHeight = |
| videoSizeFromDSI.m_uiHeight; |
| } |
| else |
| { |
| |
| #endif |
| |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipOpen: Mp4/H263/H264 stream; set current vid dec"); |
| err = M4VSS3GPP_setCurrentVideoDecoder(&pClipCtxt->ShellAPI, |
| pClipCtxt->pVideoStream->m_basicProperties.m_streamType); |
| M4ERR_CHECK_RETURN(err); |
| |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| |
| decoderUserData = |
| pClipCtxt->ShellAPI.m_pCurrentVideoDecoderUserData; |
| |
| #else |
| |
| decoderUserData = M4OSA_NULL; |
| |
| #endif |
| |
| err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctCreate( |
| &pClipCtxt->pViDecCtxt, |
| &pClipCtxt->pVideoStream->m_basicProperties, |
| pClipCtxt->ShellAPI.m_pReader, |
| pClipCtxt->ShellAPI.m_pReaderDataIt, |
| &pClipCtxt->VideoAU, decoderUserData); |
| |
| if( ( ((M4OSA_UInt32)M4ERR_DECODER_H263_PROFILE_NOT_SUPPORTED) == err) |
| || (((M4OSA_UInt32)M4ERR_DECODER_H263_NOT_BASELINE) == err) ) |
| { |
| /** |
| * Our decoder is not compatible with H263 profile other than 0. |
| * So it returns this internal error code. |
| * We translate it to our own error code */ |
| return M4VSS3GPP_ERR_H263_PROFILE_NOT_SUPPORTED; |
| } |
| else if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen: m_pVideoDecoder->m_pFctCreate returns 0x%x", |
| err); |
| return err; |
| } |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipOpen: Vid dec started; pViDecCtxt=0x%x", |
| pClipCtxt->pViDecCtxt); |
| |
| if( M4DA_StreamTypeVideoMpeg4Avc |
| == pClipCtxt->pVideoStream->m_basicProperties.m_streamType ) |
| { |
| FilterOption.m_pFilterFunction = |
| (M4OSA_Void *) &M4VIFI_ResizeBilinearYUV420toYUV420; |
| FilterOption.m_pFilterUserData = M4OSA_NULL; |
| err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption( |
| pClipCtxt->pViDecCtxt, M4DECODER_kOptionID_OutputFilter, |
| (M4OSA_DataOption) &FilterOption); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipOpen: m_pVideoDecoder->m_pFctSetOption returns 0x%x", |
| err); |
| return err; |
| } |
| else |
| { |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipOpen: m_pVideoDecoder->m_pFctSetOption\ |
| M4DECODER_kOptionID_OutputFilter OK"); |
| } |
| } |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /** |
| * Init Audio decoder */ |
| if( M4OSA_NULL != pClipCtxt->pAudioStream ) |
| { |
| err = M4VSS3GPP_intClipPrepareAudioDecoder(pClipCtxt); |
| M4ERR_CHECK_RETURN(err); |
| M4OSA_TRACE3_1("M4VSS3GPP_intClipOpen: Audio dec started; context=0x%x", |
| pClipCtxt->pAudioDecCtxt); |
| } |
| else |
| { |
| pClipCtxt->AudioAU.m_streamID = 0; |
| pClipCtxt->AudioAU.m_dataAddress = M4OSA_NULL; |
| pClipCtxt->AudioAU.m_size = 0; |
| pClipCtxt->AudioAU.m_CTS = 0; |
| pClipCtxt->AudioAU.m_DTS = 0; |
| pClipCtxt->AudioAU.m_attribute = 0; |
| pClipCtxt->AudioAU.m_maxsize = 0; |
| pClipCtxt->AudioAU.m_structSize = sizeof(pClipCtxt->AudioAU); |
| } |
| |
| /** |
| * Get the duration of the longest stream */ |
| if( M4OSA_TRUE == pClipCtxt->pSettings->ClipProperties.bAnalysed ) |
| { |
| /* If already calculated set it to previous value */ |
| /* Because fast open and full open can return a different value, |
| it can mismatch user settings */ |
| /* Video track is more important than audio track (if video track is shorter than |
| audio track, it can led to cut larger than expected) */ |
| iDuration = pClipCtxt->pSettings->ClipProperties.uiClipVideoDuration; |
| |
| if( iDuration == 0 ) |
| { |
| iDuration = pClipCtxt->pSettings->ClipProperties.uiClipDuration; |
| } |
| } |
| else |
| { |
| /* Else compute it from streams */ |
| iDuration = 0; |
| |
| if( M4OSA_NULL != pClipCtxt->pVideoStream ) |
| { |
| iDuration = (M4OSA_Int32)( |
| pClipCtxt->pVideoStream->m_basicProperties.m_duration); |
| } |
| |
| if( ( M4OSA_NULL != pClipCtxt->pAudioStream) && ((M4OSA_Int32)( |
| pClipCtxt->pAudioStream->m_basicProperties.m_duration) |
| > iDuration) && iDuration == 0 ) |
| { |
| iDuration = (M4OSA_Int32)( |
| pClipCtxt->pAudioStream->m_basicProperties.m_duration); |
| } |
| } |
| |
| /** |
| * If end time is not used, we set it to the video track duration */ |
| if( 0 == pClipCtxt->pSettings->uiEndCutTime ) |
| { |
| pClipCtxt->pSettings->uiEndCutTime = (M4OSA_UInt32)iDuration; |
| } |
| |
| pClipCtxt->iEndTime = (M4OSA_Int32)pClipCtxt->pSettings->uiEndCutTime; |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intClipOpen(): returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_Void M4VSS3GPP_intClipDeleteAudioTrack() |
| * @brief Delete the audio track. Clip will be like if it had no audio track |
| * @note |
| * @param pClipCtxt (IN) Internal clip context |
| ****************************************************************************** |
| */ |
| M4OSA_Void M4VSS3GPP_intClipDeleteAudioTrack( M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| /** |
| * But we don't have to free the audio stream. It will be freed by the reader when closing it*/ |
| pClipCtxt->pAudioStream = M4OSA_NULL; |
| |
| /** |
| * We will return a constant silence AMR AU. |
| * We set it here once, instead of at each read audio step. */ |
| pClipCtxt->pAudioFramePtr = (M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData; |
| pClipCtxt->uiAudioFrameSize = pClipCtxt->uiSilenceFrameSize; |
| |
| /** |
| * Free the decoded audio buffer (it needs to be re-allocated to store silence |
| frame eventually)*/ |
| if( M4OSA_NULL != pClipCtxt->AudioDecBufferOut.m_dataAddress ) |
| { |
| free(pClipCtxt->AudioDecBufferOut.m_dataAddress); |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = M4OSA_NULL; |
| } |
| |
| return; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipDecodeVideoUpToCurrentTime() |
| * @brief Jump to the previous RAP and decode up to the current video time |
| * @param pClipCtxt (IN) Internal clip context |
| * @param iCts (IN) Target CTS |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intClipDecodeVideoUpToCts( M4VSS3GPP_ClipContext *pClipCtxt, |
| M4OSA_Int32 iCts ) |
| { |
| M4OSA_Int32 iRapCts, iClipCts; |
| M4_MediaTime dDecodeTime; |
| M4OSA_Bool bClipJump = M4OSA_FALSE; |
| M4OSA_ERR err; |
| |
| /** |
| * Compute the time in the clip base */ |
| iClipCts = iCts - pClipCtxt->iVoffset; |
| |
| /** |
| * If we were reading the clip, we must jump to the previous RAP |
| * to decode from that point. */ |
| if( M4VSS3GPP_kClipStatus_READ == pClipCtxt->Vstatus ) |
| { |
| /** |
| * The decoder must be told to jump */ |
| bClipJump = M4OSA_TRUE; |
| pClipCtxt->iVideoDecCts = iClipCts; |
| |
| /** |
| * Remember the clip reading state */ |
| pClipCtxt->Vstatus = M4VSS3GPP_kClipStatus_DECODE_UP_TO; |
| } |
| |
| /** |
| * If we are in decodeUpTo() process, check if we need to do |
| one more step or if decoding is finished */ |
| if( M4VSS3GPP_kClipStatus_DECODE_UP_TO == pClipCtxt->Vstatus ) |
| { |
| /* Do a step of 500 ms decoding */ |
| pClipCtxt->iVideoDecCts += 500; |
| |
| if( pClipCtxt->iVideoDecCts > iClipCts ) |
| { |
| /* Target time reached, we switch back to DECODE mode */ |
| pClipCtxt->iVideoDecCts = iClipCts; |
| pClipCtxt->Vstatus = M4VSS3GPP_kClipStatus_DECODE; |
| } |
| |
| M4OSA_TRACE2_1("c ,,,, decode up to : %ld", pClipCtxt->iVideoDecCts); |
| } |
| else |
| { |
| /* Just decode at current clip cts */ |
| pClipCtxt->iVideoDecCts = iClipCts; |
| |
| M4OSA_TRACE2_1("d ,,,, decode up to : %ld", pClipCtxt->iVideoDecCts); |
| } |
| |
| /** |
| * Decode up to the target */ |
| M4OSA_TRACE3_2( |
| "M4VSS3GPP_intClipDecodeVideoUpToCts: Decoding upTo CTS %.3f, pClipCtxt=0x%x", |
| dDecodeTime, pClipCtxt); |
| |
| dDecodeTime = (M4OSA_Double)pClipCtxt->iVideoDecCts; |
| pClipCtxt->isRenderDup = M4OSA_FALSE; |
| err = |
| pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctDecode(pClipCtxt->pViDecCtxt, |
| &dDecodeTime, bClipJump, 0); |
| |
| if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err) |
| && (err != M4WAR_VIDEORENDERER_NO_NEW_FRAME) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipDecodeVideoUpToCts: m_pFctDecode returns 0x%x!", |
| err); |
| return err; |
| } |
| |
| if( err == M4WAR_VIDEORENDERER_NO_NEW_FRAME ) |
| { |
| pClipCtxt->isRenderDup = M4OSA_TRUE; |
| } |
| |
| /** |
| * Return */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intClipDecodeVideoUpToCts: returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipReadNextAudioFrame() |
| * @brief Read one AU frame in the clip |
| * @note |
| * @param pClipCtxt (IN) Internal clip context |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intClipReadNextAudioFrame( |
| M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| M4OSA_ERR err; |
| |
| /* ------------------------------ */ |
| /* ---------- NO AUDIO ---------- */ |
| /* ------------------------------ */ |
| |
| if( M4OSA_NULL == pClipCtxt->pAudioStream ) |
| { |
| /* If there is no audio track, we return silence AUs */ |
| pClipCtxt->pAudioFramePtr = |
| (M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData; |
| pClipCtxt->uiAudioFrameSize = pClipCtxt->uiSilenceFrameSize; |
| pClipCtxt->iAudioFrameCts += pClipCtxt->iSilenceFrameDuration; |
| |
| M4OSA_TRACE2_0("b #### blank track"); |
| } |
| |
| /* ---------------------------------- */ |
| /* ---------- AMR-NB, EVRC ---------- */ |
| /* ---------------------------------- */ |
| |
| else if( ( M4VIDEOEDITING_kAMR_NB |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) |
| || (M4VIDEOEDITING_kEVRC |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) ) |
| { |
| if( M4OSA_FALSE == pClipCtxt->bAudioFrameAvailable ) |
| { |
| /** |
| * No AU available, so we must must read one from the original track reader */ |
| err = pClipCtxt->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &pClipCtxt->AudioAU); |
| |
| if( M4NO_ERROR == err ) |
| { |
| /** |
| * Set the current AMR frame position at the beginning of the read AU */ |
| pClipCtxt->pAudioFramePtr = pClipCtxt->AudioAU.m_dataAddress; |
| |
| /** |
| * Set the AMR frame CTS */ |
| pClipCtxt->iAudioFrameCts = |
| (M4OSA_Int32)(pClipCtxt->AudioAU.m_CTS |
| * pClipCtxt->scale_audio + 0.5); |
| } |
| else if( ( M4WAR_NO_MORE_AU == err) && (M4VIDEOEDITING_kAMR_NB |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) ) |
| { |
| /** |
| * If there is less audio than the stream duration indicated, |
| * we return silence at the end of the stream. */ |
| pClipCtxt->pAudioFramePtr = |
| (M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData; |
| pClipCtxt->uiAudioFrameSize = pClipCtxt->uiSilenceFrameSize; |
| pClipCtxt->iAudioFrameCts += pClipCtxt->iSilenceFrameDuration; |
| |
| M4OSA_TRACE2_0("a #### silence AU"); |
| |
| /** |
| * Return with M4WAR_NO_MORE_AU */ |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AMR: \ |
| returning M4WAR_NO_MORE_AU (silence)"); |
| return M4WAR_NO_MORE_AU; |
| } |
| else /**< fatal error (or no silence in EVRC) */ |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AMR: m_pFctGetNextAu() returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| else /* bAudioFrameAvailable */ |
| { |
| /** |
| * Go to the next AMR frame in the AU */ |
| pClipCtxt->pAudioFramePtr += pClipCtxt->uiAudioFrameSize; |
| |
| /** |
| * Increment CTS: one AMR frame is 20 ms long */ |
| pClipCtxt->iAudioFrameCts += pClipCtxt->iSilenceFrameDuration; |
| } |
| |
| /** |
| * Get the size of the pointed AMR frame */ |
| switch( pClipCtxt->pSettings->ClipProperties.AudioStreamType ) |
| { |
| case M4VIDEOEDITING_kAMR_NB: |
| pClipCtxt->uiAudioFrameSize = |
| (M4OSA_UInt16)M4VSS3GPP_intGetFrameSize_AMRNB( |
| pClipCtxt->pAudioFramePtr); |
| break; |
| |
| case M4VIDEOEDITING_kEVRC: |
| pClipCtxt->uiAudioFrameSize = |
| (M4OSA_UInt16)M4VSS3GPP_intGetFrameSize_EVRC( |
| pClipCtxt->pAudioFramePtr); |
| break; |
| default: |
| break; |
| } |
| |
| if( 0 == pClipCtxt->uiAudioFrameSize ) |
| { |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AMR: AU frame size == 0,\ |
| returning M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AMR_AU"); |
| return M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AU; |
| } |
| else if( pClipCtxt->uiAudioFrameSize > pClipCtxt->AudioAU.m_size ) |
| { |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AMR: AU frame size greater than AU size!,\ |
| returning M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AMR_AU"); |
| return M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AU; |
| } |
| |
| /** |
| * Check if the end of the current AU has been reached or not */ |
| if( ( pClipCtxt->pAudioFramePtr + pClipCtxt->uiAudioFrameSize) |
| < (pClipCtxt->AudioAU.m_dataAddress + pClipCtxt->AudioAU.m_size) ) |
| { |
| pClipCtxt->bAudioFrameAvailable = M4OSA_TRUE; |
| } |
| else |
| { |
| pClipCtxt->bAudioFrameAvailable = |
| M4OSA_FALSE; /**< will be used for next call */ |
| } |
| } |
| |
| /* ------------------------- */ |
| /* ---------- AAC ---------- */ |
| /* ------------------------- */ |
| |
| else if( ( M4VIDEOEDITING_kAAC |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) |
| || (M4VIDEOEDITING_kAACplus |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) |
| || (M4VIDEOEDITING_keAACplus |
| == pClipCtxt->pSettings->ClipProperties.AudioStreamType) ) |
| { |
| err = pClipCtxt->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &pClipCtxt->AudioAU); |
| |
| if( M4NO_ERROR == err ) |
| { |
| pClipCtxt->pAudioFramePtr = pClipCtxt->AudioAU.m_dataAddress; |
| pClipCtxt->uiAudioFrameSize = |
| (M4OSA_UInt16)pClipCtxt->AudioAU.m_size; |
| pClipCtxt->iAudioFrameCts = |
| (M4OSA_Int32)(pClipCtxt->AudioAU.m_CTS * pClipCtxt->scale_audio |
| + 0.5); |
| |
| /* Patch because m_CTS is unfortunately rounded in 3gp reader shell */ |
| /* (cts is not an integer with frequency 24 kHz for example) */ |
| pClipCtxt->iAudioFrameCts = ( ( pClipCtxt->iAudioFrameCts |
| + pClipCtxt->iSilenceFrameDuration / 2) |
| / pClipCtxt->iSilenceFrameDuration) |
| * pClipCtxt->iSilenceFrameDuration; |
| } |
| else if( M4WAR_NO_MORE_AU == err ) |
| { |
| /** |
| * If there is less audio than the stream duration indicated, |
| * we return silence at the end of the stream. */ |
| pClipCtxt->pAudioFramePtr = |
| (M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData; |
| pClipCtxt->uiAudioFrameSize = pClipCtxt->uiSilenceFrameSize; |
| pClipCtxt->iAudioFrameCts += pClipCtxt->iSilenceFrameDuration; |
| |
| M4OSA_TRACE2_0("a #### silence AU"); |
| |
| /** |
| * Return with M4WAR_NO_MORE_AU */ |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AAC:\ |
| returning M4WAR_NO_MORE_AU (silence)"); |
| return M4WAR_NO_MORE_AU; |
| } |
| else /**< fatal error */ |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-AAC: m_pFctGetNextAu() returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /* --------------------------------- */ |
| /* ---------- MP3, others ---------- */ |
| /* --------------------------------- */ |
| |
| else |
| { |
| err = pClipCtxt->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &pClipCtxt->AudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipReadNextAudioFrame()-MP3: m_pFctGetNextAu() returns 0x%x", |
| err); |
| return err; |
| } |
| |
| pClipCtxt->pAudioFramePtr = pClipCtxt->AudioAU.m_dataAddress; |
| pClipCtxt->uiAudioFrameSize = (M4OSA_UInt16)pClipCtxt->AudioAU.m_size; |
| pClipCtxt->iAudioFrameCts = |
| (M4OSA_Int32)(pClipCtxt->AudioAU.m_CTS * pClipCtxt->scale_audio |
| + 0.5); |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipReadNextAudioFrame(): returning M4NO_ERROR"); |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipPrepareAudioDecoder() |
| * @brief Creates and initialize the audio decoder for the clip. |
| * @note |
| * @param pClipCtxt (IN) internal clip context |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| static M4OSA_ERR M4VSS3GPP_intClipPrepareAudioDecoder( |
| M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| M4OSA_ERR err = M4NO_ERROR; |
| M4_StreamType audiotype; |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| M4_AACType iAacType = 0; |
| |
| #endif |
| |
| /** |
| * Set the proper audio decoder */ |
| |
| audiotype = pClipCtxt->pAudioStream->m_basicProperties.m_streamType; |
| |
| //EVRC |
| if( M4DA_StreamTypeAudioEvrc |
| != audiotype ) /* decoder not supported yet, but allow to do null encoding */ |
| |
| err = M4VSS3GPP_setCurrentAudioDecoder(&pClipCtxt->ShellAPI, audiotype); |
| M4ERR_CHECK_RETURN(err); |
| |
| /** |
| * Creates the audio decoder */ |
| if( M4OSA_NULL == pClipCtxt->ShellAPI.m_pAudioDecoder ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intClipPrepareAudioDecoder(): Fails to initiate the audio decoder."); |
| return M4VSS3GPP_ERR_AUDIO_DECODER_INIT_FAILED; |
| } |
| |
| if( M4OSA_NULL == pClipCtxt->pAudioDecCtxt ) |
| { |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| |
| if( M4OSA_TRUE == pClipCtxt->ShellAPI.bAllowFreeingOMXCodecInterface ) |
| { |
| if( M4DA_StreamTypeAudioAac == audiotype ) { |
| err = M4VSS3GPP_intCheckAndGetCodecAacProperties( |
| pClipCtxt); |
| } else if (M4DA_StreamTypeAudioPcm != audiotype) { |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, pClipCtxt->pAudioStream, |
| M4OSA_NULL); |
| } else { |
| err = M4NO_ERROR; |
| } |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder: m_pAudioDecoder->m_pFctCreateAudioDec\ |
| returns 0x%x", err); |
| return err; |
| } |
| } |
| else |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder:\ |
| Creating external audio decoder of type 0x%x", audiotype); |
| /* External OMX codecs are used*/ |
| if( M4DA_StreamTypeAudioAac == audiotype ) |
| { |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, pClipCtxt->pAudioStream, |
| pClipCtxt->ShellAPI.pCurrentAudioDecoderUserData); |
| |
| if( M4NO_ERROR == err ) |
| { |
| /* AAC properties*/ |
| /*get from Reader; temporary, till Audio decoder shell API |
| available to get the AAC properties*/ |
| pClipCtxt->AacProperties.aNumChan = |
| pClipCtxt->pAudioStream->m_nbChannels; |
| pClipCtxt->AacProperties.aSampFreq = |
| pClipCtxt->pAudioStream->m_samplingFrequency; |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder-> |
| m_pFctGetOptionAudioDec(pClipCtxt->pAudioDecCtxt, |
| M4AD_kOptionID_StreamType, |
| (M4OSA_DataOption) &iAacType); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder:\ |
| m_pAudioDecoder->m_pFctGetOptionAudioDec returns err 0x%x", err); |
| iAacType = M4_kAAC; //set to default |
| err = M4NO_ERROR; |
| } |
| else { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder: \ |
| m_pAudioDecoder->m_pFctGetOptionAudioDec returns streamType %d", |
| iAacType); |
| } |
| switch( iAacType ) |
| { |
| case M4_kAAC: |
| pClipCtxt->AacProperties.aSBRPresent = 0; |
| pClipCtxt->AacProperties.aPSPresent = 0; |
| break; |
| |
| case M4_kAACplus: |
| pClipCtxt->AacProperties.aSBRPresent = 1; |
| pClipCtxt->AacProperties.aPSPresent = 0; |
| pClipCtxt->AacProperties.aExtensionSampFreq = |
| pClipCtxt->pAudioStream->m_samplingFrequency; |
| break; |
| |
| case M4_keAACplus: |
| pClipCtxt->AacProperties.aSBRPresent = 1; |
| pClipCtxt->AacProperties.aPSPresent = 1; |
| pClipCtxt->AacProperties.aExtensionSampFreq = |
| pClipCtxt->pAudioStream->m_samplingFrequency; |
| break; |
| default: |
| break; |
| } |
| M4OSA_TRACE3_2( |
| "M4VSS3GPP_intClipPrepareAudioDecoder: AAC NBChans=%d, SamplFreq=%d", |
| pClipCtxt->AacProperties.aNumChan, |
| pClipCtxt->AacProperties.aSampFreq); |
| } |
| } |
| else |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, pClipCtxt->pAudioStream, |
| pClipCtxt->ShellAPI.pCurrentAudioDecoderUserData); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder:\ |
| m_pAudioDecoder->m_pFctCreateAudioDec returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| #else |
| /* Trick, I use pUserData to retrieve aac properties, |
| waiting for some better implementation... */ |
| |
| if( M4DA_StreamTypeAudioAac == audiotype ) |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, |
| pClipCtxt->pAudioStream, &(pClipCtxt->AacProperties)); |
| else |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, pClipCtxt->pAudioStream, |
| M4OSA_NULL /* to be changed with HW interfaces */); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder:\ |
| m_pAudioDecoder->m_pFctCreateAudioDec returns 0x%x", |
| err); |
| return err; |
| } |
| |
| #endif |
| |
| } |
| |
| if( M4DA_StreamTypeAudioAmrNarrowBand == audiotype ) { |
| /* AMR DECODER CONFIGURATION */ |
| |
| /* nothing specific to do */ |
| } |
| else if( M4DA_StreamTypeAudioEvrc == audiotype ) { |
| /* EVRC DECODER CONFIGURATION */ |
| |
| /* nothing specific to do */ |
| } |
| else if( M4DA_StreamTypeAudioMp3 == audiotype ) { |
| /* MP3 DECODER CONFIGURATION */ |
| |
| /* nothing specific to do */ |
| } |
| else if( M4DA_StreamTypeAudioAac == audiotype ) |
| { |
| /* AAC DECODER CONFIGURATION */ |
| |
| /* Decode high quality aac but disable PS and SBR */ |
| /* Because we have to mix different kind of AAC so we must take the lowest capability */ |
| /* In MCS it was not needed because there is only one stream */ |
| M4_AacDecoderConfig AacDecParam; |
| |
| AacDecParam.m_AACDecoderProfile = AAC_kAAC; |
| AacDecParam.m_DownSamplingMode = AAC_kDS_OFF; |
| |
| if( M4ENCODER_kMono == pClipCtxt->pAudioStream->m_nbChannels ) |
| { |
| AacDecParam.m_OutputMode = AAC_kMono; |
| } |
| else |
| { |
| AacDecParam.m_OutputMode = AAC_kStereo; |
| } |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, |
| M4AD_kOptionID_UserParam, (M4OSA_DataOption) &AacDecParam); |
| } |
| |
| if( M4OSA_NULL != pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec ) { |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, M4AD_kOptionID_3gpReaderInterface, |
| (M4OSA_DataOption) pClipCtxt->ShellAPI.m_pReaderDataIt); |
| |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, M4AD_kOptionID_AudioAU, |
| (M4OSA_DataOption) &pClipCtxt->AudioAU); |
| } |
| |
| if( M4OSA_NULL != pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStartAudioDec ) |
| { |
| /* Not implemented in all decoders */ |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStartAudioDec( |
| pClipCtxt->pAudioDecCtxt); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipPrepareAudioDecoder:\ |
| m_pAudioDecoder->m_pFctStartAudioDec returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Allocate output buffer for the audio decoder */ |
| pClipCtxt->AudioDecBufferOut.m_bufferSize = |
| pClipCtxt->pAudioStream->m_byteFrameLength |
| * pClipCtxt->pAudioStream->m_byteSampleSize |
| * pClipCtxt->pAudioStream->m_nbChannels; |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = |
| (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pClipCtxt->AudioDecBufferOut.m_bufferSize |
| * sizeof(M4OSA_Int16), |
| M4VSS3GPP, (M4OSA_Char *)"AudioDecBufferOut.m_bufferSize"); |
| |
| if( M4OSA_NULL == pClipCtxt->AudioDecBufferOut.m_dataAddress ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intClipPrepareAudioDecoder():\ |
| unable to allocate AudioDecBufferOut.m_dataAddress, returning M4ERR_ALLOC"); |
| return M4ERR_ALLOC; |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipDecodeCurrentAudioFrame() |
| * @brief Decode the current AUDIO frame. |
| * @note |
| * @param pClipCtxt (IN) internal clip context |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intClipDecodeCurrentAudioFrame( |
| M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| M4OSA_ERR err; |
| |
| /** |
| * Silence mode */ |
| if( pClipCtxt->pSilenceFrameData |
| == (M4OSA_UInt8 *)pClipCtxt->pAudioFramePtr ) |
| { |
| if( pClipCtxt->AudioDecBufferOut.m_dataAddress == M4OSA_NULL ) |
| { |
| /** |
| * Allocate output buffer for the audio decoder */ |
| pClipCtxt->AudioDecBufferOut.m_bufferSize = |
| pClipCtxt->uiSilencePcmSize; |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = |
| (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc( |
| pClipCtxt->AudioDecBufferOut.m_bufferSize |
| * sizeof(M4OSA_Int16), |
| M4VSS3GPP,(M4OSA_Char *) "AudioDecBufferOut.m_bufferSize"); |
| |
| if( M4OSA_NULL == pClipCtxt->AudioDecBufferOut.m_dataAddress ) |
| { |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intClipDecodeCurrentAudioFrame():\ |
| unable to allocate AudioDecBufferOut.m_dataAddress, returning M4ERR_ALLOC"); |
| return M4ERR_ALLOC; |
| } |
| } |
| |
| /* Fill it with 0 (= pcm silence) */ |
| memset(pClipCtxt->AudioDecBufferOut.m_dataAddress,0, |
| pClipCtxt->AudioDecBufferOut.m_bufferSize * sizeof(M4OSA_Int16)); |
| } |
| else if (pClipCtxt->pSettings->FileType == M4VIDEOEDITING_kFileType_PCM) |
| { |
| pClipCtxt->AudioDecBufferIn.m_dataAddress = (M4OSA_MemAddr8) pClipCtxt->pAudioFramePtr; |
| pClipCtxt->AudioDecBufferIn.m_bufferSize = pClipCtxt->uiAudioFrameSize; |
| |
| memcpy((void *)pClipCtxt->AudioDecBufferOut.m_dataAddress, |
| (void *)pClipCtxt->AudioDecBufferIn.m_dataAddress, pClipCtxt->AudioDecBufferIn.m_bufferSize); |
| pClipCtxt->AudioDecBufferOut.m_bufferSize = pClipCtxt->AudioDecBufferIn.m_bufferSize; |
| /** |
| * Return with no error */ |
| |
| M4OSA_TRACE3_0("M4VSS3GPP_intClipDecodeCurrentAudioFrame(): returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| /** |
| * Standard decoding mode */ |
| else |
| { |
| /** |
| * Decode current AMR frame */ |
| if ( pClipCtxt->pAudioFramePtr != M4OSA_NULL ) { |
| pClipCtxt->AudioDecBufferIn.m_dataAddress = |
| (M4OSA_MemAddr8)pClipCtxt->pAudioFramePtr; |
| pClipCtxt->AudioDecBufferIn.m_bufferSize = |
| pClipCtxt->uiAudioFrameSize; |
| pClipCtxt->AudioDecBufferIn.m_timeStampUs = |
| (int64_t) (pClipCtxt->iAudioFrameCts * 1000LL); |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStepAudioDec( |
| pClipCtxt->pAudioDecCtxt, |
| &pClipCtxt->AudioDecBufferIn, &pClipCtxt->AudioDecBufferOut, |
| M4OSA_FALSE); |
| } else { |
| // Pass Null input buffer |
| // Reader invoked from Audio decoder source |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStepAudioDec( |
| pClipCtxt->pAudioDecCtxt, |
| M4OSA_NULL, &pClipCtxt->AudioDecBufferOut, |
| M4OSA_FALSE); |
| } |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipDecodeCurrentAudioFrame():\ |
| m_pAudioDecoder->m_pFctStepAudio returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intClipDecodeCurrentAudioFrame(): returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipJumpAudioAt() |
| * @brief Jump in the audio track of the clip. |
| * @note |
| * @param pClipCtxt (IN) internal clip context |
| * @param pJumpCts (IN/OUT) in:target CTS, out: reached CTS |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intClipJumpAudioAt( M4VSS3GPP_ClipContext *pClipCtxt, |
| M4OSA_Int32 *pJumpCts ) |
| { |
| M4OSA_ERR err; |
| M4OSA_Int32 iTargetCts; |
| M4OSA_Int32 iJumpCtsMs; |
| |
| /** |
| * Check input parameters */ |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pClipCtxt), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipJumpAudioAt: pClipCtxt is M4OSA_NULL"); |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pJumpCts), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipJumpAudioAt: pJumpCts is M4OSA_NULL"); |
| |
| iTargetCts = *pJumpCts; |
| |
| /** |
| * If there is no audio stream, we simulate a jump at the target jump CTS */ |
| if( M4OSA_NULL == pClipCtxt->pAudioStream ) |
| { |
| /** |
| * the target CTS will be reached at next ReadFrame call (thus the -20) */ |
| *pJumpCts = iTargetCts - pClipCtxt->iSilenceFrameDuration; |
| |
| /* Patch because m_CTS is unfortunately rounded in 3gp reader shell */ |
| /* (cts is not an integer with frequency 24 kHz for example) */ |
| *pJumpCts = ( ( *pJumpCts + pClipCtxt->iSilenceFrameDuration / 2) |
| / pClipCtxt->iSilenceFrameDuration) |
| * pClipCtxt->iSilenceFrameDuration; |
| pClipCtxt->iAudioFrameCts = |
| * |
| pJumpCts; /* simulate a read at jump position for later silence AUs */ |
| } |
| else |
| { |
| M4OSA_Int32 current_time = 0; |
| M4OSA_Int32 loop_counter = 0; |
| |
| if( (M4DA_StreamTypeAudioMp3 |
| == pClipCtxt->pAudioStream->m_basicProperties.m_streamType) ) |
| { |
| while( ( loop_counter < M4VSS3GPP_MP3_JUMPED_AU_NUMBER_MAX) |
| && (current_time < iTargetCts) ) |
| { |
| err = pClipCtxt->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &pClipCtxt->AudioAU); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE3_1( |
| "M4VSS3GPP_intClipJumpAudioAt: m_pFctGetNextAu() returns 0x%x", |
| err); |
| return err; |
| } |
| |
| current_time = (M4OSA_Int32)pClipCtxt->AudioAU.m_CTS; |
| loop_counter++; |
| } |
| |
| /** |
| * The current AU is stored */ |
| pClipCtxt->pAudioFramePtr = pClipCtxt->AudioAU.m_dataAddress; |
| pClipCtxt->uiAudioFrameSize = |
| (M4OSA_UInt16)pClipCtxt->AudioAU.m_size; |
| pClipCtxt->iAudioFrameCts = |
| (M4OSA_Int32)(pClipCtxt->AudioAU.m_CTS * pClipCtxt->scale_audio |
| + 0.5); |
| |
| *pJumpCts = pClipCtxt->iAudioFrameCts; |
| } |
| else |
| { |
| /** |
| * Jump in the audio stream */ |
| iJumpCtsMs = |
| (M4OSA_Int32)(*pJumpCts / pClipCtxt->scale_audio + 0.5); |
| |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctJump( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream, |
| &iJumpCtsMs); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipJumpAudioAt(): m_pFctJump() returns 0x%x", |
| err); |
| return err; |
| } |
| |
| *pJumpCts = |
| (M4OSA_Int32)(iJumpCtsMs * pClipCtxt->scale_audio + 0.5); |
| |
| /* Patch because m_CTS is unfortunately rounded in 3gp reader shell */ |
| /* (cts is not an integer with frequency 24 kHz for example) */ |
| *pJumpCts = ( ( *pJumpCts + pClipCtxt->iSilenceFrameDuration / 2) |
| / pClipCtxt->iSilenceFrameDuration) |
| * pClipCtxt->iSilenceFrameDuration; |
| pClipCtxt->iAudioFrameCts = 0; /* No frame read yet */ |
| |
| /** |
| * To detect some may-be bugs, I prefer to reset all these after a jump */ |
| pClipCtxt->bAudioFrameAvailable = M4OSA_FALSE; |
| pClipCtxt->pAudioFramePtr = M4OSA_NULL; |
| |
| /** |
| * In AMR, we have to manage multi-framed AUs, |
| but also in AAC the jump can be 1 AU too much backward */ |
| if( *pJumpCts < iTargetCts ) |
| { |
| /** |
| * Jump doesn't read any AU, we must read at least one */ |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pClipCtxt); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipJumpAudioAt():\ |
| M4VSS3GPP_intClipReadNextAudioFrame(a) returns 0x%x", |
| err); |
| return err; |
| } |
| |
| /** |
| * Read AU frames as long as we reach the AU before the target CTS |
| * (so the target will be reached when the user call ReadNextAudioFrame). */ |
| while( pClipCtxt->iAudioFrameCts |
| < (iTargetCts - pClipCtxt->iSilenceFrameDuration) ) |
| { |
| err = M4VSS3GPP_intClipReadNextAudioFrame(pClipCtxt); |
| |
| if( M4OSA_ERR_IS_ERROR(err) ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipJumpAudioAt():\ |
| M4VSS3GPP_intClipReadNextAudioFrame(b) returns 0x%x", |
| err); |
| return err; |
| } |
| } |
| |
| /** |
| * Return the CTS that will be reached at next ReadFrame */ |
| *pJumpCts = pClipCtxt->iAudioFrameCts |
| + pClipCtxt->iSilenceFrameDuration; |
| } |
| } |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_0("M4VSS3GPP_intClipJumpAudioAt(): returning M4NO_ERROR"); |
| return M4NO_ERROR; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_ERR M4VSS3GPP_intClipClose() |
| * @brief Close a clip. Destroy the context. |
| * @note |
| * @param pClipCtxt (IN) Internal clip context |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| M4OSA_ERR M4VSS3GPP_intClipClose( M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| M4OSA_ERR err; |
| |
| /** |
| * Check input parameters */ |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pClipCtxt), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipClose: pClipCtxt is M4OSA_NULL"); |
| |
| /** |
| * Free the video decoder context */ |
| if( M4OSA_NULL != pClipCtxt->pViDecCtxt ) |
| { |
| pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctDestroy( |
| pClipCtxt->pViDecCtxt); |
| pClipCtxt->pViDecCtxt = M4OSA_NULL; |
| } |
| |
| /** |
| * Free the audio decoder context */ |
| if( M4OSA_NULL != pClipCtxt->pAudioDecCtxt ) |
| { |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctDestroyAudioDec( |
| pClipCtxt->pAudioDecCtxt); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipClose: m_pAudioDecoder->m_pFctDestroyAudioDec returns 0x%x", |
| err); |
| /**< don't return, we still have stuff to free */ |
| } |
| |
| pClipCtxt->pAudioDecCtxt = M4OSA_NULL; |
| } |
| |
| /** |
| * Free the decoded audio buffer */ |
| if( M4OSA_NULL != pClipCtxt->AudioDecBufferOut.m_dataAddress ) |
| { |
| free(pClipCtxt->AudioDecBufferOut.m_dataAddress); |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = M4OSA_NULL; |
| } |
| |
| /** |
| * Audio AU is allocated by reader. |
| * If no audio track, audio AU is set at 'silent' (SID) by VSS. |
| * As a consequence, if audio AU is set to 'silent' (static) |
| it can't be free unless it is set to NULL */ |
| if( ( (M4OSA_MemAddr8)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048 |
| == pClipCtxt->AudioAU.m_dataAddress) |
| || ((M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData |
| == pClipCtxt->AudioAU.m_dataAddress) ) |
| { |
| pClipCtxt->AudioAU.m_dataAddress = M4OSA_NULL; |
| } |
| |
| if( M4OSA_NULL != pClipCtxt->pReaderContext ) |
| { |
| /** |
| * Close the 3GPP or MP3 reader */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctClose( |
| pClipCtxt->pReaderContext); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipClose(): m_pReader->m_pFctClose returns 0x%x", |
| err); |
| } |
| |
| /** |
| * Destroy the 3GPP or MP3 reader context */ |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctDestroy( |
| pClipCtxt->pReaderContext); |
| |
| if( M4NO_ERROR != err ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipClose(): m_pReader->m_pFctDestroy returns 0x%x", |
| err); |
| } |
| |
| pClipCtxt->pReaderContext = M4OSA_NULL; |
| } |
| |
| /** |
| * Return with no error */ |
| M4OSA_TRACE3_1("M4VSS3GPP_intClipClose(Ctxt=0x%x): returning M4NO_ERROR", |
| pClipCtxt); |
| return M4NO_ERROR; |
| } |
| |
| M4OSA_ERR M4VSS3GPP_intClipCleanUp( M4VSS3GPP_ClipContext *pClipCtxt ) |
| { |
| M4OSA_ERR err = M4NO_ERROR, err2; |
| |
| /** |
| * Check input parameters */ |
| M4OSA_DEBUG_IF2((M4OSA_NULL == pClipCtxt), M4ERR_PARAMETER, |
| "M4VSS3GPP_intClipCleanUp: pClipCtxt is M4OSA_NULL"); |
| |
| /** |
| * Free the video decoder context */ |
| if( M4OSA_NULL != pClipCtxt->pViDecCtxt ) |
| { |
| pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctDestroy( |
| pClipCtxt->pViDecCtxt); |
| pClipCtxt->pViDecCtxt = M4OSA_NULL; |
| } |
| |
| /** |
| * Free the audio decoder context */ |
| if( M4OSA_NULL != pClipCtxt->pAudioDecCtxt ) |
| { |
| err2 = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctDestroyAudioDec( |
| pClipCtxt->pAudioDecCtxt); |
| |
| if( M4NO_ERROR != err2 ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipCleanUp: m_pAudioDecoder->m_pFctDestroyAudioDec returns 0x%x", |
| err); |
| /**< don't return, we still have stuff to free */ |
| if( M4NO_ERROR != err ) |
| err = err2; |
| } |
| |
| pClipCtxt->pAudioDecCtxt = M4OSA_NULL; |
| } |
| |
| /** |
| * Free the decoded audio buffer */ |
| if( M4OSA_NULL != pClipCtxt->AudioDecBufferOut.m_dataAddress ) |
| { |
| free(pClipCtxt->AudioDecBufferOut.m_dataAddress); |
| pClipCtxt->AudioDecBufferOut.m_dataAddress = M4OSA_NULL; |
| } |
| |
| /** |
| * Audio AU is allocated by reader. |
| * If no audio track, audio AU is set at 'silent' (SID) by VSS. |
| * As a consequence, if audio AU is set to 'silent' (static) |
| it can't be free unless it is set to NULL */ |
| if( ( (M4OSA_MemAddr8)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048 |
| == pClipCtxt->AudioAU.m_dataAddress) |
| || ((M4OSA_MemAddr8)pClipCtxt->pSilenceFrameData |
| == pClipCtxt->AudioAU.m_dataAddress) ) |
| { |
| pClipCtxt->AudioAU.m_dataAddress = M4OSA_NULL; |
| } |
| |
| if( M4OSA_NULL != pClipCtxt->pReaderContext ) |
| { |
| /** |
| * Close the 3GPP or MP3 reader */ |
| err2 = pClipCtxt->ShellAPI.m_pReader->m_pFctClose( |
| pClipCtxt->pReaderContext); |
| |
| if( M4NO_ERROR != err2 ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipCleanUp(): m_pReader->m_pFctClose returns 0x%x", |
| err); |
| |
| if( M4NO_ERROR != err ) |
| err = err2; |
| } |
| |
| /** |
| * Destroy the 3GPP or MP3 reader context */ |
| err2 = pClipCtxt->ShellAPI.m_pReader->m_pFctDestroy( |
| pClipCtxt->pReaderContext); |
| |
| if( M4NO_ERROR != err2 ) |
| { |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intClipCleanUp(): m_pReader->m_pFctDestroy returns 0x%x", |
| err); |
| |
| if( M4NO_ERROR != err ) |
| err = err2; |
| } |
| |
| pClipCtxt->pReaderContext = M4OSA_NULL; |
| } |
| |
| if(pClipCtxt->pPlaneYuv != M4OSA_NULL) { |
| if(pClipCtxt->pPlaneYuv[0].pac_data != M4OSA_NULL) { |
| free(pClipCtxt->pPlaneYuv[0].pac_data); |
| pClipCtxt->pPlaneYuv[0].pac_data = M4OSA_NULL; |
| } |
| free(pClipCtxt->pPlaneYuv); |
| pClipCtxt->pPlaneYuv = M4OSA_NULL; |
| } |
| |
| if(pClipCtxt->pPlaneYuvWithEffect != M4OSA_NULL) { |
| if(pClipCtxt->pPlaneYuvWithEffect[0].pac_data != M4OSA_NULL) { |
| free(pClipCtxt->pPlaneYuvWithEffect[0].pac_data); |
| pClipCtxt->pPlaneYuvWithEffect[0].pac_data = M4OSA_NULL; |
| } |
| free(pClipCtxt->pPlaneYuvWithEffect); |
| pClipCtxt->pPlaneYuvWithEffect = M4OSA_NULL; |
| } |
| /** |
| * Free the shells interfaces */ |
| M4VSS3GPP_unRegisterAllWriters(&pClipCtxt->ShellAPI); |
| M4VSS3GPP_unRegisterAllEncoders(&pClipCtxt->ShellAPI); |
| M4VSS3GPP_unRegisterAllReaders(&pClipCtxt->ShellAPI); |
| M4VSS3GPP_unRegisterAllDecoders(&pClipCtxt->ShellAPI); |
| |
| M4OSA_TRACE3_1("M4VSS3GPP_intClipCleanUp: pClipCtxt=0x%x", pClipCtxt); |
| /** |
| * Free the clip context */ |
| free(pClipCtxt); |
| |
| return err; |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_UInt32 M4VSS3GPP_intGetFrameSize_AMRNB() |
| * @brief Return the length, in bytes, of the AMR Narrow-Band frame contained in the given buffer |
| * @note |
| * @param pAudioFrame (IN) AMRNB frame |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| |
| M4OSA_UInt32 M4VSS3GPP_intGetFrameSize_AMRNB( M4OSA_MemAddr8 pAudioFrame ) |
| { |
| M4OSA_UInt32 frameSize = 0; |
| M4OSA_UInt32 frameType = ( ( *pAudioFrame) &(0xF << 3)) >> 3; |
| |
| switch( frameType ) |
| { |
| case 0: |
| frameSize = 95; |
| break; /* 4750 bps */ |
| |
| case 1: |
| frameSize = 103; |
| break; /* 5150 bps */ |
| |
| case 2: |
| frameSize = 118; |
| break; /* 5900 bps */ |
| |
| case 3: |
| frameSize = 134; |
| break; /* 6700 bps */ |
| |
| case 4: |
| frameSize = 148; |
| break; /* 7400 bps */ |
| |
| case 5: |
| frameSize = 159; |
| break; /* 7950 bps */ |
| |
| case 6: |
| frameSize = 204; |
| break; /* 10200 bps */ |
| |
| case 7: |
| frameSize = 244; |
| break; /* 12000 bps */ |
| |
| case 8: |
| frameSize = 39; |
| break; /* SID (Silence) */ |
| |
| case 15: |
| frameSize = 0; |
| break; /* No data */ |
| |
| default: |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intGetFrameSize_AMRNB(): Corrupted AMR frame! returning 0."); |
| return 0; |
| } |
| |
| return (1 + (( frameSize + 7) / 8)); |
| } |
| |
| /** |
| ****************************************************************************** |
| * M4OSA_UInt32 M4VSS3GPP_intGetFrameSize_EVRC() |
| * @brief Return the length, in bytes, of the EVRC frame contained in the given buffer |
| * @note |
| * 0 1 2 3 |
| * +-+-+-+-+ |
| * |fr type| RFC 3558 |
| * +-+-+-+-+ |
| * |
| * Frame Type: 4 bits |
| * The frame type indicates the type of the corresponding codec data |
| * frame in the RTP packet. |
| * |
| * For EVRC and SMV codecs, the frame type values and size of the |
| * associated codec data frame are described in the table below: |
| * |
| * Value Rate Total codec data frame size (in octets) |
| * --------------------------------------------------------- |
| * 0 Blank 0 (0 bit) |
| * 1 1/8 2 (16 bits) |
| * 2 1/4 5 (40 bits; not valid for EVRC) |
| * 3 1/2 10 (80 bits) |
| * 4 1 22 (171 bits; 5 padded at end with zeros) |
| * 5 Erasure 0 (SHOULD NOT be transmitted by sender) |
| * |
| * @param pCpAudioFrame (IN) EVRC frame |
| * @return M4NO_ERROR: No error |
| ****************************************************************************** |
| */ |
| M4OSA_UInt32 M4VSS3GPP_intGetFrameSize_EVRC( M4OSA_MemAddr8 pAudioFrame ) |
| { |
| M4OSA_UInt32 frameSize = 0; |
| M4OSA_UInt32 frameType = ( *pAudioFrame) &0x0F; |
| |
| switch( frameType ) |
| { |
| case 0: |
| frameSize = 0; |
| break; /* blank */ |
| |
| case 1: |
| frameSize = 16; |
| break; /* 1/8 */ |
| |
| case 2: |
| frameSize = 40; |
| break; /* 1/4 */ |
| |
| case 3: |
| frameSize = 80; |
| break; /* 1/2 */ |
| |
| case 4: |
| frameSize = 171; |
| break; /* 1 */ |
| |
| case 5: |
| frameSize = 0; |
| break; /* erasure */ |
| |
| default: |
| M4OSA_TRACE3_0( |
| "M4VSS3GPP_intGetFrameSize_EVRC(): Corrupted EVRC frame! returning 0."); |
| return 0; |
| } |
| |
| return (1 + (( frameSize + 7) / 8)); |
| } |
| |
| M4OSA_ERR M4VSS3GPP_intCheckAndGetCodecAacProperties( |
| M4VSS3GPP_ClipContext *pClipCtxt) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| M4AD_Buffer outputBuffer; |
| uint32_t optionValue =0; |
| |
| // Decode first audio frame from clip to get properties from codec |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctCreateAudioDec( |
| &pClipCtxt->pAudioDecCtxt, |
| pClipCtxt->pAudioStream, &(pClipCtxt->AacProperties)); |
| |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, M4AD_kOptionID_3gpReaderInterface, |
| (M4OSA_DataOption) pClipCtxt->ShellAPI.m_pReaderDataIt); |
| |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctSetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, M4AD_kOptionID_AudioAU, |
| (M4OSA_DataOption) &pClipCtxt->AudioAU); |
| |
| if( pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStartAudioDec != M4OSA_NULL ) { |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStartAudioDec( |
| pClipCtxt->pAudioDecCtxt); |
| if( M4NO_ERROR != err ) { |
| |
| M4OSA_TRACE1_1( |
| "M4VSS3GPP_intCheckAndGetCodecAacProperties: \ |
| m_pFctStartAudioDec returns 0x%x", err); |
| return err; |
| } |
| } |
| |
| /** |
| * Allocate output buffer for the audio decoder */ |
| outputBuffer.m_bufferSize = |
| pClipCtxt->pAudioStream->m_byteFrameLength |
| * pClipCtxt->pAudioStream->m_byteSampleSize |
| * pClipCtxt->pAudioStream->m_nbChannels; |
| |
| if( outputBuffer.m_bufferSize > 0 ) { |
| |
| outputBuffer.m_dataAddress = |
| (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(outputBuffer.m_bufferSize \ |
| *sizeof(short), M4VSS3GPP, (M4OSA_Char *)"outputBuffer.m_bufferSize"); |
| |
| if( M4OSA_NULL == outputBuffer.m_dataAddress ) { |
| |
| M4OSA_TRACE1_0( |
| "M4VSS3GPP_intCheckAndGetCodecAacProperties():\ |
| unable to allocate outputBuffer.m_dataAddress"); |
| return M4ERR_ALLOC; |
| } |
| } |
| |
| err = pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctStepAudioDec( |
| pClipCtxt->pAudioDecCtxt, M4OSA_NULL, &outputBuffer, M4OSA_FALSE); |
| |
| if ( err == M4WAR_INFO_FORMAT_CHANGE ) { |
| |
| // Get the properties from codec node |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctGetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, |
| M4AD_kOptionID_AudioNbChannels, (M4OSA_DataOption) &optionValue); |
| |
| pClipCtxt->AacProperties.aNumChan = optionValue; |
| // Reset Reader structure value also |
| pClipCtxt->pAudioStream->m_nbChannels = optionValue; |
| |
| pClipCtxt->ShellAPI.m_pAudioDecoder->m_pFctGetOptionAudioDec( |
| pClipCtxt->pAudioDecCtxt, |
| M4AD_kOptionID_AudioSampFrequency, (M4OSA_DataOption) &optionValue); |
| |
| pClipCtxt->AacProperties.aSampFreq = optionValue; |
| // Reset Reader structure value also |
| pClipCtxt->pAudioStream->m_samplingFrequency = optionValue; |
| |
| } else if( err != M4NO_ERROR) { |
| M4OSA_TRACE1_1("M4VSS3GPP_intCheckAndGetCodecAacProperties:\ |
| m_pFctStepAudioDec returns err = 0x%x", err); |
| } |
| |
| free(outputBuffer.m_dataAddress); |
| |
| // Reset the stream reader |
| err = pClipCtxt->ShellAPI.m_pReader->m_pFctReset( |
| pClipCtxt->pReaderContext, |
| (M4_StreamHandler *)pClipCtxt->pAudioStream); |
| |
| if (M4NO_ERROR != err) { |
| M4OSA_TRACE1_1("M4VSS3GPP_intCheckAndGetCodecAacProperties\ |
| Error in reseting reader: 0x%x", err); |
| } |
| |
| return err; |
| |
| } |
