blob: df8b7d5f5de8664f2ffc66fc4235860e97b4729a [file] [log] [blame]
/*
* 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_Edit.c
* @brief Video Studio Service 3GPP edit API implementation.
* @note
******************************************************************************
*/
/****************/
/*** Includes ***/
/****************/
#include "NXPSW_CompilerSwitches.h"
/**
* Our headers */
#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 */
#include "M4OSA_CharStar.h" /**< OSAL string management */
#ifdef WIN32
#include "string.h" /**< for strcpy (Don't want to get dependencies
with M4OSA_String...) */
#endif /* WIN32 */
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
#include "M4VD_EXTERNAL_Interface.h"
#endif
/************************************************************************/
/* Static local functions */
/************************************************************************/
static M4OSA_ERR M4VSS3GPP_intClipSettingsSanityCheck(
M4VSS3GPP_ClipSettings *pClip );
static M4OSA_ERR M4VSS3GPP_intTransitionSettingsSanityCheck(
M4VSS3GPP_TransitionSettings *pTransition );
static M4OSA_Void M4VSS3GPP_intFreeSettingsList(
M4VSS3GPP_InternalEditContext *pC );
static M4OSA_ERR
M4VSS3GPP_intCreateMP3OutputFile( M4VSS3GPP_InternalEditContext *pC,
M4OSA_Void *pOutputFile );
static M4OSA_ERR M4VSS3GPP_intSwitchToNextClip(
M4VSS3GPP_InternalEditContext *pC );
static M4OSA_ERR
M4VSS3GPP_intComputeOutputVideoAndAudioDsi( M4VSS3GPP_InternalEditContext *pC,
M4OSA_UInt8 uiMasterClip );
static M4OSA_Void M4VSS3GPP_intComputeOutputAverageVideoBitrate(
M4VSS3GPP_InternalEditContext *pC );
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_GetVersion()
* @brief Get the VSS 3GPP version.
* @note Can be called anytime. Do not need any context.
* @param pVersionInfo (OUT) Pointer to a version info structure
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pVersionInfo is M4OSA_NULL (If Debug Level >= 2)
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_GetVersion( M4_VersionInfo *pVersionInfo )
{
M4OSA_TRACE3_1("M4VSS3GPP_GetVersion called with pVersionInfo=0x%x",
pVersionInfo);
/**
* Check input parameters */
M4OSA_DEBUG_IF2((M4OSA_NULL == pVersionInfo), M4ERR_PARAMETER,
"M4VSS3GPP_GetVersion: pVersionInfo is M4OSA_NULL");
pVersionInfo->m_major = M4VSS_VERSION_MAJOR;
pVersionInfo->m_minor = M4VSS_VERSION_MINOR;
pVersionInfo->m_revision = M4VSS_VERSION_REVISION;
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editInit()
* @brief Initializes the VSS 3GPP edit operation (allocates an execution context).
* @note
* @param pContext (OUT) Pointer on the VSS 3GPP edit context to allocate
* @param pFileReadPtrFct (IN) Pointer to OSAL file reader functions
* @param pFileWritePtrFct (IN) Pointer to OSAL file writer functions
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: At least one parameter is M4OSA_NULL
* @return M4ERR_ALLOC: There is no more available memory
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editInit( M4VSS3GPP_EditContext *pContext,
M4OSA_FileReadPointer *pFileReadPtrFct,
M4OSA_FileWriterPointer *pFileWritePtrFct )
{
M4VSS3GPP_InternalEditContext *pC;
M4OSA_ERR err;
M4OSA_UInt32 i;
M4OSA_TRACE3_3(
"M4VSS3GPP_editInit called with pContext=0x%x, \
pFileReadPtrFct=0x%x, pFileWritePtrFct=0x%x",
pContext, pFileReadPtrFct, pFileWritePtrFct);
/**
* Check input parameters */
M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
"M4VSS3GPP_editInit: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pFileReadPtrFct), M4ERR_PARAMETER,
"M4VSS3GPP_editInit: pFileReadPtrFct is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pFileWritePtrFct), M4ERR_PARAMETER,
"M4VSS3GPP_editInit: pFileWritePtrFct is M4OSA_NULL");
/**
* Allocate the VSS context and return it to the user */
pC = (M4VSS3GPP_InternalEditContext
*)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_InternalEditContext),
M4VSS3GPP, (M4OSA_Char *)"M4VSS3GPP_InternalContext");
*pContext = pC;
/* Inialization of context Variables */
memset((void *)pC, 0,sizeof(M4VSS3GPP_InternalEditContext));
if( M4OSA_NULL == pC )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editInit(): unable to allocate M4VSS3GPP_InternalContext,\
returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
/* Init the context. */
pC->uiClipNumber = 0;
pC->pClipList = M4OSA_NULL;
pC->pTransitionList = M4OSA_NULL;
pC->pEffectsList = M4OSA_NULL;
pC->pActiveEffectsList = M4OSA_NULL;
pC->pActiveEffectsList1 = M4OSA_NULL;
pC->bClip1ActiveFramingEffect = M4OSA_FALSE;
pC->bClip2ActiveFramingEffect = M4OSA_FALSE;
pC->uiCurrentClip = 0;
pC->pC1 = M4OSA_NULL;
pC->pC2 = M4OSA_NULL;
pC->yuv1[0].pac_data = pC->yuv1[1].pac_data = pC->
yuv1[2].pac_data = M4OSA_NULL;
pC->yuv2[0].pac_data = pC->yuv2[1].pac_data = pC->
yuv2[2].pac_data = M4OSA_NULL;
pC->yuv3[0].pac_data = pC->yuv3[1].pac_data = pC->
yuv3[2].pac_data = M4OSA_NULL;
pC->yuv4[0].pac_data = pC->yuv4[1].pac_data = pC->
yuv4[2].pac_data = M4OSA_NULL;
pC->bClip1AtBeginCut = M4OSA_FALSE;
pC->iClip1ActiveEffect = 0;
pC->iClip2ActiveEffect = 0;
pC->bTransitionEffect = M4OSA_FALSE;
pC->bSupportSilence = M4OSA_FALSE;
/**
* Init PC->ewc members */
// Decorrelate input and output encoding timestamp to handle encoder prefetch
pC->ewc.dInputVidCts = 0.0;
pC->ewc.dOutputVidCts = 0.0;
pC->ewc.dATo = 0.0;
pC->ewc.iOutputDuration = 0;
pC->ewc.VideoStreamType = M4SYS_kVideoUnknown;
pC->ewc.uiVideoBitrate = 0;
pC->ewc.uiVideoWidth = 0;
pC->ewc.uiVideoHeight = 0;
pC->ewc.uiVideoTimeScale = 0;
pC->ewc.bVideoDataPartitioning = M4OSA_FALSE;
pC->ewc.pVideoOutputDsi = M4OSA_NULL;
pC->ewc.uiVideoOutputDsiSize = 0;
pC->ewc.AudioStreamType = M4SYS_kAudioUnknown;
pC->ewc.uiNbChannels = 1;
pC->ewc.uiAudioBitrate = 0;
pC->ewc.uiSamplingFrequency = 0;
pC->ewc.pAudioOutputDsi = M4OSA_NULL;
pC->ewc.uiAudioOutputDsiSize = 0;
pC->ewc.pAudioEncCtxt = M4OSA_NULL;
pC->ewc.pAudioEncDSI.infoSize = 0;
pC->ewc.pAudioEncDSI.pInfo = M4OSA_NULL;
pC->ewc.uiSilencePcmSize = 0;
pC->ewc.pSilenceFrameData = M4OSA_NULL;
pC->ewc.uiSilenceFrameSize = 0;
pC->ewc.iSilenceFrameDuration = 0;
pC->ewc.scale_audio = 0.0;
pC->ewc.pEncContext = M4OSA_NULL;
pC->ewc.pDummyAuBuffer = M4OSA_NULL;
pC->ewc.iMpeg4GovOffset = 0;
pC->ewc.VppError = 0;
pC->ewc.encoderState = M4VSS3GPP_kNoEncoder;
pC->ewc.p3gpWriterContext = M4OSA_NULL;
pC->ewc.uiVideoMaxAuSize = 0;
pC->ewc.uiAudioMaxAuSize = 0;
/**
* Keep the OSAL file functions pointer set in our context */
pC->pOsaFileReadPtr = pFileReadPtrFct;
pC->pOsaFileWritPtr = pFileWritePtrFct;
/*
* Reset pointers for media and codecs interfaces */
err = M4VSS3GPP_clearInterfaceTables(&pC->ShellAPI);
M4ERR_CHECK_RETURN(err);
/*
* Call the media and codecs subscription module */
err = M4VSS3GPP_subscribeMediaAndCodec(&pC->ShellAPI);
M4ERR_CHECK_RETURN(err);
/**
* Update main state automaton */
pC->State = M4VSS3GPP_kEditState_CREATED;
pC->Vstate = M4VSS3GPP_kEditVideoState_READ_WRITE;
pC->Astate = M4VSS3GPP_kEditAudioState_READ_WRITE;
/* The flag is set to false at the beginning of every clip */
pC->m_bClipExternalHasStarted = M4OSA_FALSE;
pC->bIsMMS = M4OSA_FALSE;
pC->iInOutTimeOffset = 0;
pC->bEncodeTillEoF = M4OSA_FALSE;
pC->nbActiveEffects = 0;
pC->nbActiveEffects1 = 0;
pC->bIssecondClip = M4OSA_FALSE;
pC->m_air_context = M4OSA_NULL;
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editInit(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editCreateClipSettings()
* @brief Allows filling a clip settings structure with default values
*
* @note WARNING: pClipSettings->Effects[ ] will be allocated in this function.
* pClipSettings->pFile will be allocated in this function.
*
* @param pClipSettings (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
* @param pFile (IN) Clip file name
* @param filePathSize (IN) Clip path size (needed for UTF 16 conversion)
* @param nbEffects (IN) Nb of effect settings to allocate
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pClipSettings is M4OSA_NULL (debug only)
******************************************************************************
*/
M4OSA_ERR
M4VSS3GPP_editCreateClipSettings( M4VSS3GPP_ClipSettings *pClipSettings,
M4OSA_Void *pFile, M4OSA_UInt32 filePathSize,
M4OSA_UInt8 nbEffects )
{
M4OSA_UInt8 uiFx;
M4OSA_TRACE3_1(
"M4VSS3GPP_editCreateClipSettings called with pClipSettings=0x%p",
pClipSettings);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettings), M4ERR_PARAMETER,
"M4VSS3GPP_editCreateClipSettings: pClipSettings is NULL");
/**
* Set the clip settings to default */
pClipSettings->pFile = M4OSA_NULL; /**< no file */
pClipSettings->FileType =
M4VIDEOEDITING_kFileType_Unsupported; /**< undefined */
if( M4OSA_NULL != pFile )
{
//pClipSettings->pFile = (M4OSA_Char*) M4OSA_32bitAlignedMalloc(strlen(pFile)+1, M4VSS3GPP,
// "pClipSettings->pFile");
/*FB: add clip path size because of utf 16 conversion*/
pClipSettings->pFile =
(M4OSA_Void *)M4OSA_32bitAlignedMalloc(filePathSize + 1, M4VSS3GPP,
(M4OSA_Char *)"pClipSettings->pFile");
if( M4OSA_NULL == pClipSettings->pFile )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editCreateClipSettings : ERROR allocating filename");
return M4ERR_ALLOC;
}
//memcpy(pClipSettings->pFile, pFile, strlen(pFile)+1);
/*FB: add clip path size because of utf 16 conversion*/
memcpy((void *)pClipSettings->pFile, (void *)pFile, filePathSize + 1);
}
/*FB: add file path size to support UTF16 conversion*/
pClipSettings->filePathSize = filePathSize + 1;
/**/
pClipSettings->ClipProperties.bAnalysed = M4OSA_FALSE;
pClipSettings->ClipProperties.FileType = 0;
pClipSettings->ClipProperties.Version[0] = 0;
pClipSettings->ClipProperties.Version[1] = 0;
pClipSettings->ClipProperties.Version[2] = 0;
pClipSettings->ClipProperties.uiClipDuration = 0;
pClipSettings->uiBeginCutTime = 0; /**< no begin cut */
pClipSettings->uiEndCutTime = 0; /**< no end cut */
pClipSettings->ClipProperties.bSetImageData = M4OSA_FALSE;
/**
* Reset video characteristics */
pClipSettings->ClipProperties.VideoStreamType = M4VIDEOEDITING_kNoneVideo;
pClipSettings->ClipProperties.uiClipVideoDuration = 0;
pClipSettings->ClipProperties.uiVideoBitrate = 0;
pClipSettings->ClipProperties.uiVideoMaxAuSize = 0;
pClipSettings->ClipProperties.uiVideoWidth = 0;
pClipSettings->ClipProperties.uiVideoHeight = 0;
pClipSettings->ClipProperties.uiVideoTimeScale = 0;
pClipSettings->ClipProperties.fAverageFrameRate = 0.0;
pClipSettings->ClipProperties.uiVideoProfile =
M4VIDEOEDITING_VIDEO_UNKNOWN_PROFILE;
pClipSettings->ClipProperties.uiVideoLevel =
M4VIDEOEDITING_VIDEO_UNKNOWN_LEVEL;
pClipSettings->ClipProperties.bMPEG4dataPartition = M4OSA_FALSE;
pClipSettings->ClipProperties.bMPEG4rvlc = M4OSA_FALSE;
pClipSettings->ClipProperties.bMPEG4resynchMarker = M4OSA_FALSE;
/**
* Reset audio characteristics */
pClipSettings->ClipProperties.AudioStreamType = M4VIDEOEDITING_kNoneAudio;
pClipSettings->ClipProperties.uiClipAudioDuration = 0;
pClipSettings->ClipProperties.uiAudioBitrate = 0;
pClipSettings->ClipProperties.uiAudioMaxAuSize = 0;
pClipSettings->ClipProperties.uiNbChannels = 0;
pClipSettings->ClipProperties.uiSamplingFrequency = 0;
pClipSettings->ClipProperties.uiExtendedSamplingFrequency = 0;
pClipSettings->ClipProperties.uiDecodedPcmSize = 0;
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editSetDefaultSettings(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editDuplicateClipSettings()
* @brief Duplicates a clip settings structure, performing allocations if required
*
* @param pClipSettingsDest (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
* @param pClipSettingsOrig (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
* @param bCopyEffects (IN) Flag to know if we have to duplicate effects
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pClipSettings is M4OSA_NULL (debug only)
******************************************************************************
*/
M4OSA_ERR
M4VSS3GPP_editDuplicateClipSettings( M4VSS3GPP_ClipSettings *pClipSettingsDest,
M4VSS3GPP_ClipSettings *pClipSettingsOrig,
M4OSA_Bool bCopyEffects )
{
M4OSA_UInt8 uiFx;
M4OSA_TRACE3_2(
"M4VSS3GPP_editDuplicateClipSettings called with dest=0x%p src=0x%p",
pClipSettingsDest, pClipSettingsOrig);
/* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettingsDest), M4ERR_PARAMETER,
"M4VSS3GPP_editDuplicateClipSettings: pClipSettingsDest is NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettingsOrig), M4ERR_PARAMETER,
"M4VSS3GPP_editDuplicateClipSettings: pClipSettingsOrig is NULL");
/* Copy plain structure */
memcpy((void *)pClipSettingsDest,
(void *)pClipSettingsOrig, sizeof(M4VSS3GPP_ClipSettings));
/* Duplicate filename */
if( M4OSA_NULL != pClipSettingsOrig->pFile )
{
//pClipSettingsDest->pFile =
// (M4OSA_Char*) M4OSA_32bitAlignedMalloc(strlen(pClipSettingsOrig->pFile)+1, M4VSS3GPP,
// "pClipSettingsDest->pFile");
/*FB: clip path size is needed for utf 16 conversion*/
/*FB 2008/10/16: bad allocation size which raises a crash*/
pClipSettingsDest->pFile =
(M4OSA_Char *)M4OSA_32bitAlignedMalloc(pClipSettingsOrig->filePathSize + 1,
M4VSS3GPP, (M4OSA_Char *)"pClipSettingsDest->pFile");
if( M4OSA_NULL == pClipSettingsDest->pFile )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editDuplicateClipSettings : ERROR allocating filename");
return M4ERR_ALLOC;
}
/*FB: clip path size is needed for utf 16 conversion*/
//memcpy(pClipSettingsDest->pFile, pClipSettingsOrig->pFile,
// strlen(pClipSettingsOrig->pFile)+1);
/*FB 2008/10/16: bad allocation size which raises a crash*/
memcpy((void *)pClipSettingsDest->pFile, (void *)pClipSettingsOrig->pFile,
pClipSettingsOrig->filePathSize/*+1*/);
( (M4OSA_Char
*)pClipSettingsDest->pFile)[pClipSettingsOrig->filePathSize] = '\0';
}
/* Duplicate effects */
/* Return with no error */
M4OSA_TRACE3_0(
"M4VSS3GPP_editDuplicateClipSettings(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editFreeClipSettings()
* @brief Free the pointers allocated in the ClipSetting structure (pFile, Effects).
*
* @param pClipSettings (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pClipSettings is M4OSA_NULL (debug only)
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editFreeClipSettings(
M4VSS3GPP_ClipSettings *pClipSettings )
{
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettings), M4ERR_PARAMETER,
"M4VSS3GPP_editFreeClipSettings: pClipSettings is NULL");
/* free filename */
if( M4OSA_NULL != pClipSettings->pFile )
{
free(pClipSettings->pFile);
pClipSettings->pFile = M4OSA_NULL;
}
/* free effects settings */
/* if(M4OSA_NULL != pClipSettings->Effects)
{
free(pClipSettings->Effects);
pClipSettings->Effects = M4OSA_NULL;
pClipSettings->nbEffects = 0;
} RC */
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editOpen()
* @brief Set the VSS input and output files.
* @note It opens the input file, but the output file may not be created yet.
* @param pContext (IN) VSS edit context
* @param pSettings (IN) Edit settings
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: At least one parameter is M4OSA_NULL (debug only)
* @return M4ERR_STATE: VSS is not in an appropriate state for this function to be called
* @return M4ERR_ALLOC: There is no more available memory
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editOpen( M4VSS3GPP_EditContext pContext,
M4VSS3GPP_EditSettings *pSettings )
{
M4VSS3GPP_InternalEditContext *pC =
(M4VSS3GPP_InternalEditContext *)pContext;
M4OSA_ERR err;
M4OSA_Int32 i;
M4VIDEOEDITING_FileType outputFileType =
M4VIDEOEDITING_kFileType_Unsupported; /**< 3GPP or MP3 (we don't do AMR output) */
M4OSA_UInt32 uiC1duration, uiC2duration;
M4OSA_TRACE3_2(
"M4VSS3GPP_editOpen called with pContext=0x%x, pSettings=0x%x",
pContext, pSettings);
/**
* Check input parameters */
M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
"M4VSS3GPP_editOpen: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pSettings), M4ERR_PARAMETER,
"M4VSS3GPP_editOpen: pSettings is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pSettings->pClipList), M4ERR_PARAMETER,
"M4VSS3GPP_editOpen: pSettings->pClipList is M4OSA_NULL");
M4OSA_DEBUG_IF2(( pSettings->uiClipNumber > 1)
&& (M4OSA_NULL == pSettings->pTransitionList), M4ERR_PARAMETER,
"M4VSS3GPP_editOpen: pSettings->pTransitionList is M4OSA_NULL");
/**
* Check state automaton */
if( ( pC->State != M4VSS3GPP_kEditState_CREATED)
&& (pC->State != M4VSS3GPP_kEditState_CLOSED) )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: State error (0x%x)! Returning M4ERR_STATE",
pC->State);
return M4ERR_STATE;
}
/**
* Free any previously allocated internal settings list */
M4VSS3GPP_intFreeSettingsList(pC);
/**
* Copy the user settings in our context */
pC->uiClipNumber = pSettings->uiClipNumber;
/**
* Copy the clip list */
pC->pClipList =
(M4VSS3GPP_ClipSettings *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_ClipSettings)
* pC->uiClipNumber, M4VSS3GPP, (M4OSA_Char *)"pC->pClipList");
if( M4OSA_NULL == pC->pClipList )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen: unable to allocate pC->Settings.pClipList,\
returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
for ( i = 0; i < pSettings->uiClipNumber; i++ )
{
M4VSS3GPP_editDuplicateClipSettings(&(pC->pClipList[i]),
pSettings->pClipList[i], M4OSA_TRUE);
}
/**
* Copy effects list RC */
/*FB bug fix 19.03.2008 if the number of effects is 0 -> crash*/
if( pSettings->nbEffects > 0 )
{
pC->nbEffects = pSettings->nbEffects;
pC->pEffectsList = (M4VSS3GPP_EffectSettings
*)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_EffectSettings) * pC->nbEffects,
M4VSS3GPP, (M4OSA_Char *)"pC->pEffectsList");
if( M4OSA_NULL == pC->pEffectsList )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen: unable to allocate pC->pEffectsList, returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
for ( i = 0; i < pC->nbEffects; i++ )
{
memcpy((void *) &(pC->pEffectsList[i]),
(void *) &(pSettings->Effects[i]),
sizeof(M4VSS3GPP_EffectSettings));
}
/**
* Allocate active effects list RC */
pC->pActiveEffectsList =
(M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(sizeof(M4OSA_UInt8) * pC->nbEffects,
M4VSS3GPP, (M4OSA_Char *)"pC->pActiveEffectsList");
if( M4OSA_NULL == pC->pActiveEffectsList )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen: unable to allocate pC->pActiveEffectsList,\
returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
/**
* Allocate active effects list */
pC->pActiveEffectsList1 =
(M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(sizeof(M4OSA_UInt8) * pC->nbEffects,
M4VSS3GPP, (M4OSA_Char *)"pC->pActiveEffectsList");
if (M4OSA_NULL == pC->pActiveEffectsList1)
{
M4OSA_TRACE1_0("M4VSS3GPP_editOpen: unable to allocate pC->pActiveEffectsList, \
returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
}
else
{
pC->nbEffects = 0;
pC->nbActiveEffects = 0;
pC->nbActiveEffects1 = 0;
pC->pEffectsList = M4OSA_NULL;
pC->pActiveEffectsList = M4OSA_NULL;
pC->pActiveEffectsList1 = M4OSA_NULL;
pC->bClip1ActiveFramingEffect = M4OSA_FALSE;
pC->bClip2ActiveFramingEffect = M4OSA_FALSE;
}
/**
* Test the clip analysis data, if it is not provided, analyse the clips by ourselves. */
for ( i = 0; i < pC->uiClipNumber; i++ )
{
if( M4OSA_FALSE == pC->pClipList[i].ClipProperties.bAnalysed )
{
/**< Analysis not provided by the integrator */
err = M4VSS3GPP_editAnalyseClip(pC->pClipList[i].pFile,
pC->pClipList[i].FileType, &pC->pClipList[i].ClipProperties,
pC->pOsaFileReadPtr);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_editAnalyseClip returns 0x%x!",
err);
return err;
}
}
}
/**
* Check clip compatibility */
for ( i = 0; i < pC->uiClipNumber; i++ )
{
if (pC->pClipList[i].FileType !=M4VIDEOEDITING_kFileType_ARGB8888) {
/**
* Check all the clips are compatible with VSS 3GPP */
err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(
&pC->pClipList[i].ClipProperties);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_2(
"M4VSS3GPP_editOpen:\
M4VSS3GPP_intCheckClipCompatibleWithVssEditing(%d) returns 0x%x!",
i, err);
return err;
}
}
/**
* Check the master clip versus all the other ones.
(including master clip with itself, else variables for master clip
are not properly setted) */
if(pC->pClipList[i].FileType != M4VIDEOEDITING_kFileType_ARGB8888) {
err = M4VSS3GPP_editCheckClipCompatibility(
&pC->pClipList[pSettings->uiMasterClip].ClipProperties,
&pC->pClipList[i].ClipProperties);
/* in case of warning regarding audio incompatibility,
editing continues */
if( M4OSA_ERR_IS_ERROR(err) )
{
M4OSA_TRACE1_2(
"M4VSS3GPP_editOpen: M4VSS3GPP_editCheckClipCompatibility \
(%d) returns 0x%x!", i, err);
return err;
}
} else {
pC->pClipList[i].ClipProperties.bAudioIsCompatibleWithMasterClip =
M4OSA_FALSE;
}
}
/* Search audio tracks that cannot be edited :
* - delete all audio effects for the clip
* - if master clip is editable let the transition
(bad track will be replaced later with silence)
* - if master clip is not editable switch to a dummy transition (only copy/paste) */
for ( i = 0; i < pC->uiClipNumber; i++ )
{
if( M4OSA_FALSE == pC->pClipList[i].ClipProperties.bAudioIsEditable )
{
M4OSA_UInt8 uiFx;
for ( uiFx = 0; uiFx < pC->nbEffects; uiFx++ )
{
pC->pEffectsList[uiFx].AudioEffectType
= M4VSS3GPP_kAudioEffectType_None;
}
if( ( i < (pC->uiClipNumber - 1))
&& (M4OSA_NULL != pSettings->pTransitionList[i])
&& (M4OSA_FALSE == pC->pClipList[pSettings->
uiMasterClip].ClipProperties.bAudioIsEditable) )
{
pSettings->pTransitionList[i]->AudioTransitionType
= M4VSS3GPP_kAudioTransitionType_None;
}
}
}
/**
* We add a transition of duration 0 at the end of the last clip.
* It will suppress a whole bunch a test latter in the processing... */
pC->pTransitionList = (M4VSS3GPP_TransitionSettings
*)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_TransitionSettings)
* (pC->uiClipNumber), M4VSS3GPP, (M4OSA_Char *)"pC->pTransitionList");
if( M4OSA_NULL == pC->pTransitionList )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen: unable to allocate pC->Settings.pTransitionList,\
returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
/**< copy transition settings */
for ( i = 0; i < (pSettings->uiClipNumber - 1); i++ )
{
memcpy((void *) &(pC->pTransitionList[i]),
(void *)pSettings->pTransitionList[i],
sizeof(M4VSS3GPP_TransitionSettings));
}
/**< We fill the last "dummy" transition */
pC->pTransitionList[pC->uiClipNumber - 1].uiTransitionDuration = 0;
pC->pTransitionList[pC->uiClipNumber
- 1].VideoTransitionType = M4VSS3GPP_kVideoTransitionType_None;
pC->pTransitionList[pC->uiClipNumber
- 1].AudioTransitionType = M4VSS3GPP_kAudioTransitionType_None;
/**
* Avoid weird clip settings */
for ( i = 0; i < pSettings->uiClipNumber; i++ )
{
if (pC->pClipList[i].FileType !=M4VIDEOEDITING_kFileType_ARGB8888) {
err = M4VSS3GPP_intClipSettingsSanityCheck(&pC->pClipList[i]);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intClipSettingsSanityCheck returns 0x%x!",
err);
return err;
}
}
}
for ( i = 0; i < (pSettings->uiClipNumber - 1); i++ )
{
if (pC->pTransitionList[i].uiTransitionDuration != 0) {
if (pC->pClipList[i].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
pC->pClipList[i].uiBeginCutTime = 0;
pC->pClipList[i].uiEndCutTime =
pC->pTransitionList[i].uiTransitionDuration;
}
if (pC->pClipList[i+1].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
pC->pClipList[i+1].uiBeginCutTime = 0;
pC->pClipList[i+1].uiEndCutTime =
pC->pTransitionList[i].uiTransitionDuration;
}
} else {
if (pC->pClipList[i].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
pC->pClipList[i].uiEndCutTime =
pC->pClipList[i].uiEndCutTime - pC->pClipList[i].uiBeginCutTime;
pC->pClipList[i].uiBeginCutTime = 0;
}
if (pC->pClipList[i+1].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
pC->pClipList[i+1].uiEndCutTime =
pC->pClipList[i+1].uiEndCutTime - pC->pClipList[i+1].uiBeginCutTime;
pC->pClipList[i+1].uiBeginCutTime = 0;
}
}
/**
* Maximum transition duration between clip n and clip n+1 is the duration
* of the shortest clip */
if( 0 == pC->pClipList[i].uiEndCutTime )
{
uiC1duration = pC->pClipList[i].ClipProperties.uiClipVideoDuration;
}
else
{
/**< duration of clip n is the end cut time */
uiC1duration = pC->pClipList[i].uiEndCutTime;
}
/**< Substract begin cut */
uiC1duration -= pC->pClipList[i].uiBeginCutTime;
/**< Check that the transition is shorter than clip n */
if( pC->pTransitionList[i].uiTransitionDuration > uiC1duration )
{
pC->pTransitionList[i].uiTransitionDuration = uiC1duration - 1;
}
if( 0 == pC->pClipList[i + 1].uiEndCutTime )
{
uiC2duration =
pC->pClipList[i + 1].ClipProperties.uiClipVideoDuration;
}
else
{
/**< duration of clip n+1 is the end cut time */
uiC2duration = pC->pClipList[i + 1].uiEndCutTime;
}
/**< Substract begin cut */
uiC2duration -= pC->pClipList[i + 1].uiBeginCutTime;
/**< Check that the transition is shorter than clip n+1 */
if( pC->pTransitionList[i].uiTransitionDuration > uiC2duration )
{
pC->pTransitionList[i].uiTransitionDuration = uiC2duration - 1;
}
/**
* Avoid weird transition settings */
err =
M4VSS3GPP_intTransitionSettingsSanityCheck(&pC->pTransitionList[i]);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intClipSettingsSanityCheck returns 0x%x!",
err);
return err;
}
/**
* Check that two transitions are not overlapping
(no overlapping possible for first clip) */
if( i > 0 )
{
/**
* There is a transition overlap if the sum of the duration of
two consecutive transitions
* is higher than the duration of the clip in-between. */
if( ( pC->pTransitionList[i - 1].uiTransitionDuration
+ pC->pTransitionList[i].uiTransitionDuration) >= uiC1duration )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: Overlapping transitions on clip %d,\
returning M4VSS3GPP_ERR_OVERLAPPING_TRANSITIONS",
i);
return M4VSS3GPP_ERR_OVERLAPPING_TRANSITIONS;
}
}
}
/**
* Output clip duration */
for ( i = 0; i < pC->uiClipNumber; i++ )
{
/**
* Compute the sum of the clip duration */
if( 0 == pC->pClipList[i].uiEndCutTime )
{
pC->ewc.iOutputDuration +=
pC->
pClipList[
i].ClipProperties.
uiClipVideoDuration; /* Only video track duration is important to
avoid deviation if audio track is longer */
}
else
{
pC->ewc.iOutputDuration +=
pC->pClipList[i].uiEndCutTime; /**< Add end cut */
}
pC->ewc.iOutputDuration -=
pC->pClipList[i].uiBeginCutTime; /**< Remove begin cut */
/**
* Remove the duration of the transition (it is counted twice) */
pC->ewc.iOutputDuration -= pC->pTransitionList[i].uiTransitionDuration;
}
/* Get video properties from output properties */
/* Get output width and height */
switch(pC->xVSS.outputVideoSize) {
case M4VIDEOEDITING_kSQCIF:
pC->ewc.uiVideoWidth = 128;
pC->ewc.uiVideoHeight = 96;
break;
case M4VIDEOEDITING_kQQVGA:
pC->ewc.uiVideoWidth = 160;
pC->ewc.uiVideoHeight = 120;
break;
case M4VIDEOEDITING_kQCIF:
pC->ewc.uiVideoWidth = 176;
pC->ewc.uiVideoHeight = 144;
break;
case M4VIDEOEDITING_kQVGA:
pC->ewc.uiVideoWidth = 320;
pC->ewc.uiVideoHeight = 240;
break;
case M4VIDEOEDITING_kCIF:
pC->ewc.uiVideoWidth = 352;
pC->ewc.uiVideoHeight = 288;
break;
case M4VIDEOEDITING_kVGA:
pC->ewc.uiVideoWidth = 640;
pC->ewc.uiVideoHeight = 480;
break;
/* +PR LV5807 */
case M4VIDEOEDITING_kWVGA:
pC->ewc.uiVideoWidth = 800;
pC->ewc.uiVideoHeight = 480;
break;
case M4VIDEOEDITING_kNTSC:
pC->ewc.uiVideoWidth = 720;
pC->ewc.uiVideoHeight = 480;
break;
/* -PR LV5807 */
/* +CR Google */
case M4VIDEOEDITING_k640_360:
pC->ewc.uiVideoWidth = 640;
pC->ewc.uiVideoHeight = 360;
break;
case M4VIDEOEDITING_k854_480:
pC->ewc.uiVideoWidth = M4ENCODER_854_480_Width;
pC->ewc.uiVideoHeight = 480;
break;
case M4VIDEOEDITING_k1280_720:
pC->ewc.uiVideoWidth = 1280;
pC->ewc.uiVideoHeight = 720;
break;
case M4VIDEOEDITING_k1080_720:
pC->ewc.uiVideoWidth = M4ENCODER_1080_720_Width;
pC->ewc.uiVideoHeight = 720;
break;
case M4VIDEOEDITING_k960_720:
pC->ewc.uiVideoWidth = 960;
pC->ewc.uiVideoHeight = 720;
break;
case M4VIDEOEDITING_k1920_1080:
pC->ewc.uiVideoWidth = 1920;
pC->ewc.uiVideoHeight = 1088; // need to be multiples of 16
break;
default: /* If output video size is not given, we take QCIF size */
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen: no output video size given, default to QCIF!");
pC->ewc.uiVideoWidth = 176;
pC->ewc.uiVideoHeight = 144;
pC->xVSS.outputVideoSize = M4VIDEOEDITING_kQCIF;
break;
}
pC->ewc.uiVideoTimeScale = 30;
pC->ewc.bVideoDataPartitioning = 0;
/* Set output video profile and level */
pC->ewc.outputVideoProfile = pC->xVSS.outputVideoProfile;
pC->ewc.outputVideoLevel = pC->xVSS.outputVideoLevel;
switch(pC->xVSS.outputVideoFormat) {
case M4VIDEOEDITING_kH263:
pC->ewc.VideoStreamType = M4SYS_kH263;
break;
case M4VIDEOEDITING_kMPEG4:
pC->ewc.VideoStreamType = M4SYS_kMPEG_4;
break;
case M4VIDEOEDITING_kH264:
pC->ewc.VideoStreamType = M4SYS_kH264;
break;
default:
pC->ewc.VideoStreamType = M4SYS_kVideoUnknown;
break;
}
/**
* Copy the audio properties of the master clip to the output properties */
pC->ewc.uiNbChannels =
pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiNbChannels;
pC->ewc.uiAudioBitrate =
pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiAudioBitrate;
pC->ewc.uiSamplingFrequency = pC->pClipList[pSettings->
uiMasterClip].ClipProperties.uiSamplingFrequency;
pC->ewc.uiSilencePcmSize =
pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiDecodedPcmSize;
pC->ewc.scale_audio = pC->ewc.uiSamplingFrequency / 1000.0;
switch( pC->pClipList[pSettings->uiMasterClip].ClipProperties.AudioStreamType )
{
case M4VIDEOEDITING_kAMR_NB:
pC->ewc.AudioStreamType = M4SYS_kAMR;
pC->ewc.pSilenceFrameData =
(M4OSA_UInt8 *)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048;
pC->ewc.uiSilenceFrameSize =
M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE;
pC->ewc.iSilenceFrameDuration =
M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_DURATION;
pC->bSupportSilence = M4OSA_TRUE;
break;
case M4VIDEOEDITING_kAAC:
case M4VIDEOEDITING_kAACplus:
case M4VIDEOEDITING_keAACplus:
pC->ewc.AudioStreamType = M4SYS_kAAC;
if( pC->ewc.uiNbChannels == 1 )
{
pC->ewc.pSilenceFrameData =
(M4OSA_UInt8 *)M4VSS3GPP_AAC_AU_SILENCE_MONO;
pC->ewc.uiSilenceFrameSize = M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE;
pC->bSupportSilence = M4OSA_TRUE;
}
else
{
pC->ewc.pSilenceFrameData =
(M4OSA_UInt8 *)M4VSS3GPP_AAC_AU_SILENCE_STEREO;
pC->ewc.uiSilenceFrameSize =
M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE;
pC->bSupportSilence = M4OSA_TRUE;
}
pC->ewc.iSilenceFrameDuration =
1024; /* AAC is always 1024/Freq sample duration */
break;
case M4VIDEOEDITING_kMP3:
pC->ewc.AudioStreamType = M4SYS_kMP3;
pC->ewc.pSilenceFrameData = M4OSA_NULL;
pC->ewc.uiSilenceFrameSize = 0;
pC->ewc.iSilenceFrameDuration = 0;
/* Special case, mp3 core reader return a time in ms */
pC->ewc.scale_audio = 1.0;
break;
case M4VIDEOEDITING_kEVRC:
pC->ewc.AudioStreamType = M4SYS_kEVRC;
pC->ewc.pSilenceFrameData = M4OSA_NULL;
pC->ewc.uiSilenceFrameSize = 0;
pC->ewc.iSilenceFrameDuration = 160; /* EVRC frames are 20 ms at 8000 Hz
(makes it easier to factorize amr and evrc code) */
break;
default:
pC->ewc.AudioStreamType = M4SYS_kAudioUnknown;
break;
}
for (i=0; i<pC->uiClipNumber; i++) {
if (pC->pClipList[i].bTranscodingRequired == M4OSA_FALSE) {
/** If not transcoded in Analysis phase, check
* if transcoding required now
*/
if ((pC->pClipList[i].ClipProperties.VideoStreamType !=
pC->xVSS.outputVideoFormat)||
(pC->pClipList[i].ClipProperties.uiVideoWidth !=
pC->ewc.uiVideoWidth) ||
(pC->pClipList[i].ClipProperties.uiVideoHeight !=
pC->ewc.uiVideoHeight) ||
(pC->pClipList[i].ClipProperties.VideoStreamType ==
M4VIDEOEDITING_kH264) ||
(pC->pClipList[i].ClipProperties.VideoStreamType ==
M4VIDEOEDITING_kMPEG4 &&
pC->pClipList[i].ClipProperties.uiVideoTimeScale !=
pC->ewc.uiVideoTimeScale)) {
pC->pClipList[i].bTranscodingRequired = M4OSA_TRUE;
}
} else {
/** If bTranscodingRequired is true, it means the clip has
* been transcoded in Analysis phase.
*/
pC->pClipList[i].bTranscodingRequired = M4OSA_FALSE;
}
}
/**
* We produce a 3gpp file, unless it is mp3 */
if( M4VIDEOEDITING_kMP3 == pC->
pClipList[pSettings->uiMasterClip].ClipProperties.AudioStreamType )
outputFileType = M4VIDEOEDITING_kFileType_MP3;
else
outputFileType = M4VIDEOEDITING_kFileType_3GPP;
/**
* Beware, a null duration would lead to a divide by zero error (better safe than sorry...) */
if( 0 == pC->ewc.iOutputDuration )
{
pC->ewc.iOutputDuration = 1;
}
/**
* Open first clip */
pC->uiCurrentClip = 0;
// Decorrelate input and output encoding timestamp to handle encoder prefetch
pC->ewc.dInputVidCts = 0.0;
pC->ewc.dOutputVidCts = 0.0;
pC->ewc.dATo = 0.0;
err = M4VSS3GPP_intSwitchToNextClip(pC);
/* RC: to know when a file has been processed */
if( M4NO_ERROR != err && err != M4VSS3GPP_WAR_SWITCH_CLIP )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intSwitchToNextClip() returns 0x%x!",
err);
return err;
}
/**
* Do the video stuff in 3GPP Audio/Video case */
if( M4VIDEOEDITING_kFileType_3GPP == outputFileType )
{
/**
* Compute the Decoder Specific Info for the output video and audio streams */
err = M4VSS3GPP_intComputeOutputVideoAndAudioDsi(pC,
pSettings->uiMasterClip);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intComputeOutputVideoAndAudioDsi() returns 0x%x!",
err);
return err;
}
/**
* Compute the time increment for the transition file */
switch( pSettings->videoFrameRate )
{
case M4VIDEOEDITING_k5_FPS:
pC->dOutputFrameDuration = 1000.0 / 5.0;
break;
case M4VIDEOEDITING_k7_5_FPS:
pC->dOutputFrameDuration = 1000.0 / 7.5;
break;
case M4VIDEOEDITING_k10_FPS:
pC->dOutputFrameDuration = 1000.0 / 10.0;
break;
case M4VIDEOEDITING_k12_5_FPS:
pC->dOutputFrameDuration = 1000.0 / 12.5;
break;
case M4VIDEOEDITING_k15_FPS:
pC->dOutputFrameDuration = 1000.0 / 15.0;
break;
case M4VIDEOEDITING_k20_FPS:
pC->dOutputFrameDuration = 1000.0 / 20.0;
break;
case M4VIDEOEDITING_k25_FPS:
pC->dOutputFrameDuration = 1000.0 / 25.0;
break;
case M4VIDEOEDITING_k30_FPS:
pC->dOutputFrameDuration = 1000.0 / 30.0;
break;
default:
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen(): invalid videoFrameRate (0x%x),\
returning M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE",
pSettings->videoFrameRate);
return M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE;
}
if( M4SYS_kMPEG_4 == pC->ewc.VideoStreamType )
{
M4OSA_UInt32 uiAlpha;
/**
* MPEG-4 case.
* Time scale of the transition encoder must be the same than the
* timescale of the input files.
* So the frame duration must be compatible with this time scale,
* but without beeing too short.
* For that, we must compute alpha (integer) so that:
* (alpha x 1000)/EncoderTimeScale > MinFrameDuration
**/
uiAlpha = (M4OSA_UInt32)(( pC->dOutputFrameDuration
* pC->ewc.uiVideoTimeScale) / 1000.0 + 0.5);
if( uiAlpha > 0 )
{
pC->dOutputFrameDuration =
( uiAlpha * 1000.0) / pC->ewc.uiVideoTimeScale;
}
}
else if( M4SYS_kH263 == pC->ewc.VideoStreamType )
{
switch( pSettings->videoFrameRate )
{
case M4VIDEOEDITING_k12_5_FPS:
case M4VIDEOEDITING_k20_FPS:
case M4VIDEOEDITING_k25_FPS:
M4OSA_TRACE1_0(
"M4VSS3GPP_editOpen(): invalid videoFrameRate for H263,\
returning M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE");
return M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE;
default:
break;
}
}
}
/**
* Create the MP3 output file */
if( M4VIDEOEDITING_kFileType_MP3 == outputFileType )
{
M4READER_Buffer mp3tagBuffer;
err = M4VSS3GPP_intCreateMP3OutputFile(pC, pSettings->pOutputFile);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intCreateMP3OutputFile returns 0x%x",
err);
return err;
}
/* The ID3v2 tag could be at any place in the mp3 file */
/* The mp3 reader only checks few bytes in the beginning of
stream to look for a ID3v2 tag */
/* It means that if the ID3v2 tag is not at the beginning of the file the reader do
as there is no these metadata */
/* Retrieve the data of the ID3v2 Tag */
err = pC->pC1->ShellAPI.m_pReader->m_pFctGetOption(
pC->pC1->pReaderContext, M4READER_kOptionID_Mp3Id3v2Tag,
(M4OSA_DataOption) &mp3tagBuffer);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1("M4VSS3GPP_editOpen: M4MP3R_getOption returns 0x%x",
err);
return err;
}
/* Write the data of the ID3v2 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_editOpen: WriteData(ID3v2Tag) returns 0x%x",
err);
return err;
}
mp3tagBuffer.m_uiBufferSize = 0;
mp3tagBuffer.m_pData = M4OSA_NULL;
}
}
/**
* Create the 3GPP output file */
else if( M4VIDEOEDITING_kFileType_3GPP == outputFileType )
{
pC->ewc.uiVideoBitrate = pSettings->xVSS.outputVideoBitrate;
/**
* 11/12/2008 CR3283 MMS use case in VideoArtist: Set max output file size if needed */
if( pC->bIsMMS == M4OSA_TRUE )
{
err = M4VSS3GPP_intCreate3GPPOutputFile(&pC->ewc, &pC->ShellAPI,
pC->pOsaFileWritPtr, pSettings->pOutputFile,
pC->pOsaFileReadPtr, pSettings->pTemporaryFile,
pSettings->xVSS.outputFileSize);
}
else
{
err = M4VSS3GPP_intCreate3GPPOutputFile(&pC->ewc, &pC->ShellAPI,
pC->pOsaFileWritPtr, pSettings->pOutputFile,
pC->pOsaFileReadPtr, pSettings->pTemporaryFile, 0);
}
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: M4VSS3GPP_intCreate3GPPOutputFile returns 0x%x",
err);
return err;
}
}
/**
* Default error case */
else
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editOpen: invalid outputFileType = 0x%x,\
returning M4VSS3GPP_ERR_OUTPUT_FILE_TYPE_ERROR",
outputFileType);
return
M4VSS3GPP_ERR_OUTPUT_FILE_TYPE_ERROR; /**< this is an internal error code
unknown to the user */
}
/**
* Initialize state */
if( M4SYS_kMP3 == pC->ewc.AudioStreamType )
{
/**
* In the MP3 case we use a special audio state */
pC->State = M4VSS3GPP_kEditState_MP3_JUMP;
}
else
{
/**
* We start with the video processing */
pC->State = M4VSS3GPP_kEditState_VIDEO;
}
/**
* Initialize state.
* The first clip is independant to the "virtual previous clips",
* so it's like if we where in Read/Write mode before it. */
pC->Vstate = M4VSS3GPP_kEditVideoState_READ_WRITE;
pC->Astate = M4VSS3GPP_kEditAudioState_READ_WRITE;
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editOpen(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editStep()
* @brief Perform one step of editing.
* @note
* @param pContext (IN) VSS 3GPP edit context
* @param pProgress (OUT) Progress percentage (0 to 100) of the editing operation
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return M4ERR_STATE: VSS 3GPP is not in an appropriate state for this
* function to be called
* @return M4VSS3GPP_WAR_EDITING_DONE: Edition is done, user should now call
* M4VSS3GPP_editClose()
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editStep( M4VSS3GPP_EditContext pContext,
M4OSA_UInt8 *pProgress )
{
M4VSS3GPP_InternalEditContext *pC =
(M4VSS3GPP_InternalEditContext *)pContext;
M4OSA_UInt32 uiProgressAudio, uiProgressVideo, uiProgress;
M4OSA_ERR err;
M4OSA_TRACE3_1("M4VSS3GPP_editStep called with pContext=0x%x", pContext);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
"M4VSS3GPP_editStep: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pProgress), M4ERR_PARAMETER,
"M4VSS3GPP_editStep: pProgress is M4OSA_NULL");
/**
* Check state automaton and select correct processing */
switch( pC->State )
{
case M4VSS3GPP_kEditState_VIDEO:
err = M4VSS3GPP_intEditStepVideo(pC);
break;
case M4VSS3GPP_kEditState_AUDIO:
err = M4VSS3GPP_intEditStepAudio(pC);
break;
case M4VSS3GPP_kEditState_MP3:
err = M4VSS3GPP_intEditStepMP3(pC);
break;
case M4VSS3GPP_kEditState_MP3_JUMP:
err = M4VSS3GPP_intEditJumpMP3(pC);
break;
default:
M4OSA_TRACE1_0(
"M4VSS3GPP_editStep(): invalid internal state (0x%x), returning M4ERR_STATE");
return M4ERR_STATE;
}
/**
* Compute progress.
* We do the computing with 32bits precision because in some (very) extreme case, we may get
* values higher than 256 (...) */
uiProgressAudio =
( (M4OSA_UInt32)(pC->ewc.dATo * 100)) / pC->ewc.iOutputDuration;
// Decorrelate input and output encoding timestamp to handle encoder prefetch
uiProgressVideo = ((M4OSA_UInt32)(pC->ewc.dInputVidCts * 100)) / pC->ewc.iOutputDuration;
uiProgress = uiProgressAudio + uiProgressVideo;
if( ( pC->ewc.AudioStreamType != M4SYS_kAudioUnknown)
&& (pC->ewc.VideoStreamType != M4SYS_kVideoUnknown) )
uiProgress /= 2;
/**
* Sanity check */
if( uiProgress > 100 )
{
*pProgress = 100;
}
else
{
*pProgress = (M4OSA_UInt8)uiProgress;
}
/**
* Return the error */
M4OSA_TRACE3_1("M4VSS3GPP_editStep(): returning 0x%x", err);
return err;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editClose()
* @brief Finish the VSS edit operation.
* @note The output 3GPP file is ready to be played after this call
* @param pContext (IN) VSS edit context
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return M4ERR_STATE: VSS is not in an appropriate state for this function to be called
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editClose( M4VSS3GPP_EditContext pContext )
{
M4VSS3GPP_InternalEditContext *pC =
(M4VSS3GPP_InternalEditContext *)pContext;
M4OSA_ERR err;
M4OSA_ERR returnedError = M4NO_ERROR;
M4OSA_UInt32 lastCTS;
M4OSA_TRACE3_1("M4VSS3GPP_editClose called with pContext=0x%x", pContext);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
"M4VSS3GPP_editClose: pContext is M4OSA_NULL");
/**
* Check state automaton.
* In "theory", we should not authorize closing if we are in CREATED state.
* But in practice, in case the opening failed, it may have been partially done.
* In that case we have to free some opened ressources by calling Close. */
if( M4VSS3GPP_kEditState_CLOSED == pC->State )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: Wrong state (0x%x), returning M4ERR_STATE",
pC->State);
return M4ERR_STATE;
}
/**
* There may be an encoder to destroy */
err = M4VSS3GPP_intDestroyVideoEncoder(pC);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: M4VSS3GPP_editDestroyVideoEncoder() returns 0x%x!",
err);
/**< We do not return the error here because we still have stuff to free */
returnedError = err;
}
/**
* Close the output file */
if( M4SYS_kMP3 == pC->ewc.AudioStreamType )
{
/**
* MP3 case */
if( M4OSA_NULL != pC->ewc.p3gpWriterContext )
{
err = pC->pOsaFileWritPtr->closeWrite(pC->ewc.p3gpWriterContext);
pC->ewc.p3gpWriterContext = M4OSA_NULL;
}
}
else
{
/**
* Close the output 3GPP clip, if it has been opened */
if( M4OSA_NULL != pC->ewc.p3gpWriterContext )
{
/* Update last Video CTS */
lastCTS = pC->ewc.iOutputDuration;
err = pC->ShellAPI.pWriterGlobalFcts->pFctSetOption(
pC->ewc.p3gpWriterContext,
(M4OSA_UInt32)M4WRITER_kMaxFileDuration, &lastCTS);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: SetOption(M4WRITER_kMaxFileDuration) returns 0x%x",
err);
}
err = pC->ShellAPI.pWriterGlobalFcts->pFctCloseWrite(
pC->ewc.p3gpWriterContext);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: pFctCloseWrite(OUT) returns 0x%x!",
err);
/**< We do not return the error here because we still have stuff to free */
if( M4NO_ERROR
== returnedError ) /**< we return the first error that happened */
{
returnedError = err;
}
}
pC->ewc.p3gpWriterContext = M4OSA_NULL;
}
}
/**
* Free the output video DSI, if it has been created */
if( M4OSA_NULL != pC->ewc.pVideoOutputDsi )
{
free(pC->ewc.pVideoOutputDsi);
pC->ewc.pVideoOutputDsi = M4OSA_NULL;
}
/**
* Free the output audio DSI, if it has been created */
if( M4OSA_NULL != pC->ewc.pAudioOutputDsi )
{
free(pC->ewc.pAudioOutputDsi);
pC->ewc.pAudioOutputDsi = M4OSA_NULL;
}
/**
* Close clip1, if needed */
if( M4OSA_NULL != pC->pC1 )
{
err = M4VSS3GPP_intClipCleanUp(pC->pC1);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: M4VSS3GPP_intClipCleanUp(C1) returns 0x%x!",
err);
/**< We do not return the error here because we still have stuff to free */
if( M4NO_ERROR
== returnedError ) /**< we return the first error that happened */
{
returnedError = err;
}
}
pC->pC1 = M4OSA_NULL;
}
/**
* Close clip2, if needed */
if( M4OSA_NULL != pC->pC2 )
{
err = M4VSS3GPP_intClipCleanUp(pC->pC2);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editClose: M4VSS3GPP_intClipCleanUp(C2) returns 0x%x!",
err);
/**< We do not return the error here because we still have stuff to free */
if( M4NO_ERROR
== returnedError ) /**< we return the first error that happened */
{
returnedError = err;
}
}
pC->pC2 = M4OSA_NULL;
}
/**
* Free the temporary YUV planes */
if( M4OSA_NULL != pC->yuv1[0].pac_data )
{
free(pC->yuv1[0].pac_data);
pC->yuv1[0].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv1[1].pac_data )
{
free(pC->yuv1[1].pac_data);
pC->yuv1[1].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv1[2].pac_data )
{
free(pC->yuv1[2].pac_data);
pC->yuv1[2].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv2[0].pac_data )
{
free(pC->yuv2[0].pac_data);
pC->yuv2[0].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv2[1].pac_data )
{
free(pC->yuv2[1].pac_data);
pC->yuv2[1].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv2[2].pac_data )
{
free(pC->yuv2[2].pac_data);
pC->yuv2[2].pac_data = M4OSA_NULL;
}
/* RC */
if( M4OSA_NULL != pC->yuv3[0].pac_data )
{
free(pC->yuv3[0].pac_data);
pC->yuv3[0].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv3[1].pac_data )
{
free(pC->yuv3[1].pac_data);
pC->yuv3[1].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv3[2].pac_data )
{
free(pC->yuv3[2].pac_data);
pC->yuv3[2].pac_data = M4OSA_NULL;
}
/* RC */
if( M4OSA_NULL != pC->yuv4[0].pac_data )
{
free(pC->yuv4[0].pac_data);
pC->yuv4[0].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv4[1].pac_data )
{
free(pC->yuv4[1].pac_data);
pC->yuv4[1].pac_data = M4OSA_NULL;
}
if( M4OSA_NULL != pC->yuv4[2].pac_data )
{
free(pC->yuv4[2].pac_data);
pC->yuv4[2].pac_data = M4OSA_NULL;
}
/**
* RC Free effects list */
if( pC->pEffectsList != M4OSA_NULL )
{
free(pC->pEffectsList);
pC->pEffectsList = M4OSA_NULL;
}
/**
* RC Free active effects list */
if( pC->pActiveEffectsList != M4OSA_NULL )
{
free(pC->pActiveEffectsList);
pC->pActiveEffectsList = M4OSA_NULL;
}
/**
* Free active effects list */
if(pC->pActiveEffectsList1 != M4OSA_NULL)
{
free(pC->pActiveEffectsList1);
pC->pActiveEffectsList1 = M4OSA_NULL;
}
if(pC->m_air_context != M4OSA_NULL) {
free(pC->m_air_context);
pC->m_air_context = M4OSA_NULL;
}
/**
* Update state automaton */
pC->State = M4VSS3GPP_kEditState_CLOSED;
/**
* Return with no error */
M4OSA_TRACE3_1("M4VSS3GPP_editClose(): returning 0x%x", returnedError);
return returnedError;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_editCleanUp()
* @brief Free all resources used by the VSS edit operation.
* @note The context is no more valid after this call
* @param pContext (IN) VSS edit context
* @return M4NO_ERROR: No error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_editCleanUp( M4VSS3GPP_EditContext pContext )
{
M4OSA_ERR err;
M4VSS3GPP_InternalEditContext *pC =
(M4VSS3GPP_InternalEditContext *)pContext;
M4OSA_TRACE3_1("M4VSS3GPP_editCleanUp called with pContext=0x%x", pContext);
/**
* Check input parameter */
if( M4OSA_NULL == pContext )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_editCleanUp(): pContext is M4OSA_NULL, returning M4ERR_PARAMETER");
return M4ERR_PARAMETER;
}
/**
* Close, if needed.
* In "theory", we should not close if we are in CREATED state.
* But in practice, in case the opening failed, it may have been partially done.
* In that case we have to free some opened ressources by calling Close. */
if( M4VSS3GPP_kEditState_CLOSED != pC->State )
{
M4OSA_TRACE3_0("M4VSS3GPP_editCleanUp(): calling M4VSS3GPP_editClose");
err = M4VSS3GPP_editClose(pC);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editCleanUp(): M4VSS3GPP_editClose returns 0x%x",
err);
}
}
/**
* Free the video encoder dummy AU */
if( M4OSA_NULL != pC->ewc.pDummyAuBuffer )
{
free(pC->ewc.pDummyAuBuffer);
pC->ewc.pDummyAuBuffer = M4OSA_NULL;
}
/**
* Free the Audio encoder context */
if( M4OSA_NULL != pC->ewc.pAudioEncCtxt )
{
err = pC->ShellAPI.pAudioEncoderGlobalFcts->pFctClose(
pC->ewc.pAudioEncCtxt);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_editCleanUp: 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_editCleanUp: pAudioEncoderGlobalFcts->pFctCleanUp returns 0x%x",
err);
/**< don't return, we still have stuff to free */
}
pC->ewc.pAudioEncCtxt = M4OSA_NULL;
}
/**
* Free the shells interfaces */
M4VSS3GPP_unRegisterAllWriters(&pC->ShellAPI);
M4VSS3GPP_unRegisterAllEncoders(&pC->ShellAPI);
M4VSS3GPP_unRegisterAllReaders(&pC->ShellAPI);
M4VSS3GPP_unRegisterAllDecoders(&pC->ShellAPI);
/**
* Free the settings copied in the internal context */
M4VSS3GPP_intFreeSettingsList(pC);
/**
* Finally, Free context */
free(pC);
pC = M4OSA_NULL;
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editCleanUp(): returning M4NO_ERROR");
return M4NO_ERROR;
}
#ifdef WIN32
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_GetErrorMessage()
* @brief Return a string describing the given error code
* @note The input string must be already allocated (and long enough!)
* @param err (IN) Error code to get the description from
* @param sMessage (IN/OUT) Allocated string in which the description will be copied
* @return M4NO_ERROR: Input error is from the VSS3GPP module
* @return M4ERR_PARAMETER:Input error is not from the VSS3GPP module
******************************************************************************
*/
M4OSA_ERR M4VSS3GPP_GetErrorMessage( M4OSA_ERR err, M4OSA_Char *sMessage )
{
switch( err )
{
case M4VSS3GPP_WAR_EDITING_DONE:
strcpy(sMessage, "M4VSS3GPP_WAR_EDITING_DONE");
break;
case M4VSS3GPP_WAR_END_OF_AUDIO_MIXING:
strcpy(sMessage, "M4VSS3GPP_WAR_END_OF_AUDIO_MIXING");
break;
case M4VSS3GPP_WAR_END_OF_EXTRACT_PICTURE:
strcpy(sMessage, "M4VSS3GPP_WAR_END_OF_EXTRACT_PICTURE");
break;
case M4VSS3GPP_ERR_INVALID_FILE_TYPE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_FILE_TYPE");
break;
case M4VSS3GPP_ERR_INVALID_EFFECT_KIND:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_EFFECT_KIND");
break;
case M4VSS3GPP_ERR_INVALID_VIDEO_EFFECT_TYPE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_VIDEO_EFFECT_TYPE");
break;
case M4VSS3GPP_ERR_INVALID_AUDIO_EFFECT_TYPE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_AUDIO_EFFECT_TYPE");
break;
case M4VSS3GPP_ERR_INVALID_VIDEO_TRANSITION_TYPE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_VIDEO_TRANSITION_TYPE");
break;
case M4VSS3GPP_ERR_INVALID_AUDIO_TRANSITION_TYPE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_AUDIO_TRANSITION_TYPE");
break;
case M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_VIDEO_ENCODING_FRAME_RATE");
break;
case M4VSS3GPP_ERR_EXTERNAL_EFFECT_NULL:
strcpy(sMessage, "M4VSS3GPP_ERR_EXTERNAL_EFFECT_NULL");
break;
case M4VSS3GPP_ERR_EXTERNAL_TRANSITION_NULL:
strcpy(sMessage, "M4VSS3GPP_ERR_EXTERNAL_TRANSITION_NULL");
break;
case M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_DURATION:
strcpy(sMessage, "M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_DURATION");
break;
case M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_END_CUT:
strcpy(sMessage, "M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_END_CUT");
break;
case M4VSS3GPP_ERR_OVERLAPPING_TRANSITIONS:
strcpy(sMessage, "M4VSS3GPP_ERR_OVERLAPPING_TRANSITIONS");
break;
case M4VSS3GPP_ERR_INVALID_3GPP_FILE:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_3GPP_FILE");
break;
case M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT");
break;
case M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT");
break;
case M4VSS3GPP_ERR_AMR_EDITING_UNSUPPORTED:
strcpy(sMessage, "M4VSS3GPP_ERR_AMR_EDITING_UNSUPPORTED");
break;
case M4VSS3GPP_ERR_INPUT_VIDEO_AU_TOO_LARGE:
strcpy(sMessage, "M4VSS3GPP_ERR_INPUT_VIDEO_AU_TOO_LARGE");
break;
case M4VSS3GPP_ERR_INPUT_AUDIO_AU_TOO_LARGE:
strcpy(sMessage, "M4VSS3GPP_ERR_INPUT_AUDIO_AU_TOO_LARGE");
break;
case M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AU:
strcpy(sMessage, "M4VSS3GPP_ERR_INPUT_AUDIO_CORRUPTED_AU");
break;
case M4VSS3GPP_ERR_ENCODER_ACCES_UNIT_ERROR:
strcpy(sMessage, "M4VSS3GPP_ERR_ENCODER_ACCES_UNIT_ERROR");
break;
case M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT");
break;
case M4VSS3GPP_ERR_EDITING_UNSUPPORTED_H263_PROFILE:
strcpy(sMessage, "M4VSS3GPP_ERR_EDITING_UNSUPPORTED_H263_PROFILE");
break;
case M4VSS3GPP_ERR_EDITING_UNSUPPORTED_MPEG4_PROFILE:
strcpy(sMessage, "M4VSS3GPP_ERR_EDITING_UNSUPPORTED_MPEG4_PROFILE");
break;
case M4VSS3GPP_ERR_EDITING_UNSUPPORTED_MPEG4_RVLC:
strcpy(sMessage, "M4VSS3GPP_ERR_EDITING_UNSUPPORTED_MPEG4_RVLC");
break;
case M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT");
break;
case M4VSS3GPP_ERR_EDITING_NO_SUPPORTED_STREAM_IN_FILE:
strcpy(sMessage,
"M4VSS3GPP_ERR_EDITING_NO_SUPPORTED_STREAM_IN_FILE");
break;
case M4VSS3GPP_ERR_EDITING_NO_SUPPORTED_VIDEO_STREAM_IN_FILE:
strcpy(sMessage,
"M4VSS3GPP_ERR_EDITING_NO_SUPPORTED_VIDEO_STREAM_IN_FILE");
break;
case M4VSS3GPP_ERR_INVALID_CLIP_ANALYSIS_VERSION:
strcpy(sMessage, "M4VSS3GPP_ERR_INVALID_CLIP_ANALYSIS_VERSION");
break;
case M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FORMAT");
break;
case M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FRAME_SIZE:
strcpy(sMessage, "M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FRAME_SIZE");
break;
case M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_TIME_SCALE:
strcpy(sMessage, "M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_TIME_SCALE");
break;
case M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_DATA_PARTITIONING:
strcpy(sMessage,
"M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_DATA_PARTITIONING");
break;
case M4VSS3GPP_ERR_UNSUPPORTED_MP3_ASSEMBLY:
strcpy(sMessage, "M4VSS3GPP_ERR_UNSUPPORTED_MP3_ASSEMBLY");
break;
case M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_STREAM_TYPE:
strcpy(sMessage, "M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_STREAM_TYPE");
break;
case M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_NB_OF_CHANNELS:
strcpy(sMessage, "M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_NB_OF_CHANNELS");
break;
case M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_SAMPLING_FREQUENCY:
strcpy(sMessage,
"M4VSS3GPP_WAR_INCOMPATIBLE_AUDIO_SAMPLING_FREQUENCY");
break;
case M4VSS3GPP_ERR_NO_SUPPORTED_STREAM_IN_FILE:
strcpy(sMessage, "M4VSS3GPP_ERR_NO_SUPPORTED_STREAM_IN_FILE");
break;
case M4VSS3GPP_ERR_ADDVOLUME_EQUALS_ZERO:
strcpy(sMessage, "M4VSS3GPP_ERR_ADDVOLUME_EQUALS_ZERO");
break;
case M4VSS3GPP_ERR_ADDCTS_HIGHER_THAN_VIDEO_DURATION:
strcpy(sMessage, "M4VSS3GPP_ERR_ADDCTS_HIGHER_THAN_VIDEO_DURATION");
break;
case M4VSS3GPP_ERR_UNDEFINED_AUDIO_TRACK_FILE_FORMAT:
strcpy(sMessage, "M4VSS3GPP_ERR_UNDEFINED_AUDIO_TRACK_FILE_FORMAT");
break;
case M4VSS3GPP_ERR_UNSUPPORTED_ADDED_AUDIO_STREAM:
strcpy(sMessage, "M4VSS3GPP_ERR_UNSUPPORTED_ADDED_AUDIO_STREAM");
break;
case M4VSS3GPP_ERR_AUDIO_MIXING_UNSUPPORTED:
strcpy(sMessage, "M4VSS3GPP_ERR_AUDIO_MIXING_UNSUPPORTED");
break;
case M4VSS3GPP_ERR_FEATURE_UNSUPPORTED_WITH_AUDIO_TRACK:
strcpy(sMessage,
"M4VSS3GPP_ERR_FEATURE_UNSUPPORTED_WITH_AUDIO_TRACK");
break;
case M4VSS3GPP_ERR_AUDIO_CANNOT_BE_MIXED:
strcpy(sMessage, "M4VSS3GPP_ERR_AUDIO_CANNOT_BE_MIXED");
break;
case M4VSS3GPP_ERR_INPUT_CLIP_IS_NOT_A_3GPP:
strcpy(sMessage, "M4VSS3GPP_ERR_INPUT_CLIP_IS_NOT_A_3GPP");
break;
case M4VSS3GPP_ERR_BEGINLOOP_HIGHER_ENDLOOP:
strcpy(sMessage, "M4VSS3GPP_ERR_BEGINLOOP_HIGHER_ENDLOOP");
break;
case M4VSS3GPP_ERR_H263_PROFILE_NOT_SUPPORTED:
strcpy(sMessage, "M4VSS3GPP_ERR_H263_PROFILE_NOT_SUPPORTED");
break;
case M4VSS3GPP_ERR_NO_SUPPORTED_VIDEO_STREAM_IN_FILE:
strcpy(sMessage, "M4VSS3GPP_ERR_NO_SUPPORTED_VIDEO_STREAM_IN_FILE");
break;
default: /**< Not a VSS3GPP error */
strcpy(sMessage, "");
return M4ERR_PARAMETER;
}
return M4NO_ERROR;
}
#endif /* WIN32 */
/********************************************************/
/********************************************************/
/********************************************************/
/**************** STATIC FUNCTIONS ******************/
/********************************************************/
/********************************************************/
/********************************************************/
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intClipSettingsSanityCheck()
* @brief Simplify the given clip settings
* @note This function may modify the given structure
* @param pClip (IN/OUT) Clip settings
* @return M4NO_ERROR: No error
* @return M4VSS3GPP_ERR_EXTERNAL_EFFECT_NULL:
******************************************************************************
*/
static M4OSA_ERR M4VSS3GPP_intClipSettingsSanityCheck(
M4VSS3GPP_ClipSettings *pClip )
{
M4OSA_UInt8 uiFx;
M4OSA_UInt32
uiClipActualDuration; /**< the clip duration once the cuts are done */
M4OSA_UInt32 uiDuration;
M4VSS3GPP_EffectSettings *pFx;
/**
* If begin cut is too far, return an error */
uiDuration = pClip->ClipProperties.uiClipDuration;
if( pClip->uiBeginCutTime > uiDuration )
{
M4OSA_TRACE1_2(
"M4VSS3GPP_intClipSettingsSanityCheck: %d > %d,\
returning M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_DURATION",
pClip->uiBeginCutTime, uiDuration);
return M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_DURATION;
}
/**
* If end cut is too far, set to zero (it means no end cut) */
if( pClip->uiEndCutTime > uiDuration )
{
pClip->uiEndCutTime = 0;
}
/**
* Compute actual clip duration (once cuts are done) */
if( 0 == pClip->uiEndCutTime )
{
/**
* No end cut */
uiClipActualDuration = uiDuration - pClip->uiBeginCutTime;
}
else
{
if( pClip->uiBeginCutTime >= pClip->uiEndCutTime )
{
M4OSA_TRACE1_2(
"M4VSS3GPP_intClipSettingsSanityCheck: %d > %d,\
returning M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_END_CUT",
pClip->uiBeginCutTime, pClip->uiEndCutTime);
return M4VSS3GPP_ERR_BEGIN_CUT_LARGER_THAN_END_CUT;
}
uiClipActualDuration = pClip->uiEndCutTime - pClip->uiBeginCutTime;
}
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intTransitionSettingsSanityCheck()
* @brief Simplify the given transition settings
* @note This function may modify the given structure
* @param pTransition (IN/OUT) Transition settings
* @return M4NO_ERROR: No error
* @return M4VSS3GPP_ERR_EXTERNAL_TRANSITION_NULL:
******************************************************************************
*/
static M4OSA_ERR M4VSS3GPP_intTransitionSettingsSanityCheck(
M4VSS3GPP_TransitionSettings *pTransition )
{
/**
* No transition */
if( 0 == pTransition->uiTransitionDuration )
{
pTransition->VideoTransitionType = M4VSS3GPP_kVideoTransitionType_None;
pTransition->AudioTransitionType = M4VSS3GPP_kAudioTransitionType_None;
}
else if( ( M4VSS3GPP_kVideoTransitionType_None
== pTransition->VideoTransitionType)
&& (M4VSS3GPP_kAudioTransitionType_None
== pTransition->AudioTransitionType) )
{
pTransition->uiTransitionDuration = 0;
}
/**
* Check external transition function is set */
if( ( pTransition->VideoTransitionType
>= M4VSS3GPP_kVideoTransitionType_External)
&& (M4OSA_NULL == pTransition->ExtVideoTransitionFct) )
{
return M4VSS3GPP_ERR_EXTERNAL_TRANSITION_NULL;
}
/**
* Set minimal transition duration */
if( ( pTransition->uiTransitionDuration > 0)
&& (pTransition->uiTransitionDuration
< M4VSS3GPP_MINIMAL_TRANSITION_DURATION) )
{
pTransition->uiTransitionDuration =
M4VSS3GPP_MINIMAL_TRANSITION_DURATION;
}
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intFreeSettingsList()
* @brief Free the settings copied in the internal context
* @param pC (IN/OUT) Internal edit context
******************************************************************************
*/
static M4OSA_Void M4VSS3GPP_intFreeSettingsList(
M4VSS3GPP_InternalEditContext *pC )
{
M4OSA_UInt32 i;
/**
* Free the settings list */
if( M4OSA_NULL != pC->pClipList )
{
for ( i = 0; i < pC->uiClipNumber; i++ )
{
M4VSS3GPP_editFreeClipSettings(&(pC->pClipList[i]));
}
free(pC->pClipList);
pC->pClipList = M4OSA_NULL;
}
/**
* Free the transition list */
if( M4OSA_NULL != pC->pTransitionList )
{
free(pC->pTransitionList);
pC->pTransitionList = M4OSA_NULL;
}
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intCreateMP3OutputFile()
* @brief Creates and prepare the output MP file
* @param pC (IN/OUT) Internal edit context
******************************************************************************
*/
static M4OSA_ERR
M4VSS3GPP_intCreateMP3OutputFile( M4VSS3GPP_InternalEditContext *pC,
M4OSA_Void *pOutputFile )
{
M4OSA_ERR err;
err =
pC->pOsaFileWritPtr->openWrite(&pC->ewc.p3gpWriterContext, pOutputFile,
M4OSA_kFileWrite);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreateMP3OutputFile: WriteOpen returns 0x%x!", err);
return err;
}
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intCreate3GPPOutputFile()
* @brief Creates and prepare the output MP3 file
* @note Creates the writer, Creates the output file, Adds the streams,
Readies the writing process
* @param pC (IN/OUT) Internal edit context
******************************************************************************
*/
M4OSA_ERR
M4VSS3GPP_intCreate3GPPOutputFile( M4VSS3GPP_EncodeWriteContext *pC_ewc,
M4VSS3GPP_MediaAndCodecCtxt *pC_ShellAPI,
M4OSA_FileWriterPointer *pOsaFileWritPtr,
M4OSA_Void *pOutputFile,
M4OSA_FileReadPointer *pOsaFileReadPtr,
M4OSA_Void *pTempFile,
M4OSA_UInt32 maxOutputFileSize )
{
M4OSA_ERR err;
M4OSA_UInt32 uiVersion;
M4SYS_StreamIDValue temp;
M4OSA_TRACE3_2(
"M4VSS3GPP_intCreate3GPPOutputFile called with pC_ewc=0x%x, pOutputFile=0x%x",
pC_ewc, pOutputFile);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == pC_ewc), M4ERR_PARAMETER,
"M4VSS3GPP_intCreate3GPPOutputFile: pC_ewc is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pOutputFile), M4ERR_PARAMETER,
"M4VSS3GPP_intCreate3GPPOutputFile: pOutputFile is M4OSA_NULL");
/* Set writer */
err =
M4VSS3GPP_setCurrentWriter(pC_ShellAPI, M4VIDEOEDITING_kFileType_3GPP);
M4ERR_CHECK_RETURN(err);
/**
* Create the output file */
err = pC_ShellAPI->pWriterGlobalFcts->pFctOpen(&pC_ewc->p3gpWriterContext,
pOutputFile, pOsaFileWritPtr, pTempFile, pOsaFileReadPtr);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile: pWriterGlobalFcts->pFctOpen returns 0x%x!",
err);
return err;
}
/**
* Set the signature option of the writer */
err =
pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(pC_ewc->p3gpWriterContext,
M4WRITER_kEmbeddedString, (M4OSA_DataOption)"NXP-SW : VSS ");
if( ( M4NO_ERROR != err) && (((M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
!= err) ) /* this option may not be implemented by some writers */
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kEmbeddedString) returns 0x%x!",
err);
return err;
}
/*11/12/2008 CR3283 MMS use case for VideoArtist:
Set the max output file size option in the writer so that the output file will be
smaller than the given file size limitation*/
if( maxOutputFileSize > 0 )
{
err = pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(
pC_ewc->p3gpWriterContext,
M4WRITER_kMaxFileSize, &maxOutputFileSize);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
writer set option M4WRITER_kMaxFileSize returns 0x%x",
err);
return err;
}
}
/**
* Set the version option of the writer */
uiVersion =
(M4VIDEOEDITING_VERSION_MAJOR * 100 + M4VIDEOEDITING_VERSION_MINOR * 10
+ M4VIDEOEDITING_VERSION_REVISION);
err =
pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(pC_ewc->p3gpWriterContext,
M4WRITER_kEmbeddedVersion, (M4OSA_DataOption) &uiVersion);
if( ( M4NO_ERROR != err) && (((M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
!= err) ) /* this option may not be implemented by some writers */
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kEmbeddedVersion) returns 0x%x!",
err);
return err;
}
if( M4SYS_kVideoUnknown != pC_ewc->VideoStreamType )
{
/**
* Set the video stream properties */
pC_ewc->WriterVideoStreamInfo.height = pC_ewc->uiVideoHeight;
pC_ewc->WriterVideoStreamInfo.width = pC_ewc->uiVideoWidth;
pC_ewc->WriterVideoStreamInfo.fps =
0.0; /**< Not used by the shell/core writer */
pC_ewc->WriterVideoStreamInfo.Header.pBuf =
pC_ewc->pVideoOutputDsi; /**< Previously computed output DSI */
pC_ewc->WriterVideoStreamInfo.Header.Size = pC_ewc->
uiVideoOutputDsiSize; /**< Previously computed output DSI size */
pC_ewc->WriterVideoStream.streamType = pC_ewc->VideoStreamType;
switch( pC_ewc->VideoStreamType )
{
case M4SYS_kMPEG_4:
case M4SYS_kH263:
case M4SYS_kH264:
/**< We HAVE to put a value here... */
pC_ewc->WriterVideoStream.averageBitrate =
pC_ewc->uiVideoBitrate;
pC_ewc->WriterVideoStream.maxBitrate = pC_ewc->uiVideoBitrate;
break;
default:
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile: unknown input video format (0x%x),\
returning M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT!",
pC_ewc->VideoStreamType);
return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT;
}
pC_ewc->WriterVideoStream.streamID = M4VSS3GPP_WRITER_VIDEO_STREAM_ID;
pC_ewc->WriterVideoStream.timeScale =
0; /**< Not used by the shell/core writer */
pC_ewc->WriterVideoStream.profileLevel =
0; /**< Not used by the shell/core writer */
pC_ewc->WriterVideoStream.duration =
0; /**< Not used by the shell/core writer */
pC_ewc->WriterVideoStream.decoderSpecificInfoSize =
sizeof(M4WRITER_StreamVideoInfos);
pC_ewc->WriterVideoStream.decoderSpecificInfo =
(M4OSA_MemAddr32) &(pC_ewc->WriterVideoStreamInfo);
/**
* Add the video stream */
err = pC_ShellAPI->pWriterGlobalFcts->pFctAddStream(
pC_ewc->p3gpWriterContext, &pC_ewc->WriterVideoStream);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctAddStream(video) returns 0x%x!",
err);
return err;
}
/**
* Update AU properties for video stream */
pC_ewc->WriterVideoAU.attribute = AU_RAP;
pC_ewc->WriterVideoAU.CTS = 0;
pC_ewc->WriterVideoAU.DTS = 0; /** Reset time */
pC_ewc->WriterVideoAU.frag = M4OSA_NULL;
pC_ewc->WriterVideoAU.nbFrag = 0; /** No fragment */
pC_ewc->WriterVideoAU.size = 0;
pC_ewc->WriterVideoAU.dataAddress = M4OSA_NULL;
pC_ewc->WriterVideoAU.stream = &(pC_ewc->WriterVideoStream);
/**
* Set the writer max video AU size */
pC_ewc->uiVideoMaxAuSize = (M4OSA_UInt32)(1.5F
*(M4OSA_Float)(pC_ewc->WriterVideoStreamInfo.width
* pC_ewc->WriterVideoStreamInfo.height)
* M4VSS3GPP_VIDEO_MIN_COMPRESSION_RATIO);
temp.streamID = M4VSS3GPP_WRITER_VIDEO_STREAM_ID;
temp.value = pC_ewc->uiVideoMaxAuSize;
err = pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(
pC_ewc->p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxAUSize,
(M4OSA_DataOption) &temp);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, video) returns 0x%x!",
err);
return err;
}
/**
* Set the writer max video chunk size */
temp.streamID = M4VSS3GPP_WRITER_VIDEO_STREAM_ID;
temp.value = (M4OSA_UInt32)(pC_ewc->uiVideoMaxAuSize \
* M4VSS3GPP_VIDEO_AU_SIZE_TO_CHUNCK_SIZE_RATIO); /**< from max AU size to
max Chunck size */
err = pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(
pC_ewc->p3gpWriterContext,
(M4OSA_UInt32)M4WRITER_kMaxChunckSize,
(M4OSA_DataOption) &temp);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, video) returns 0x%x!",
err);
return err;
}
}
if( M4SYS_kAudioUnknown != pC_ewc->AudioStreamType )
{
M4WRITER_StreamAudioInfos streamAudioInfo;
streamAudioInfo.nbSamplesPerSec = 0; /**< unused by our shell writer */
streamAudioInfo.nbBitsPerSample = 0; /**< unused by our shell writer */
streamAudioInfo.nbChannels = 1; /**< unused by our shell writer */
if( pC_ewc->pAudioOutputDsi != M4OSA_NULL )
{
/* If we copy the stream from the input, we copy its DSI */
streamAudioInfo.Header.Size = pC_ewc->uiAudioOutputDsiSize;
streamAudioInfo.Header.pBuf = pC_ewc->pAudioOutputDsi;
}
else
{
/* Writer will put a default DSI */
streamAudioInfo.Header.Size = 0;
streamAudioInfo.Header.pBuf = M4OSA_NULL;
}
pC_ewc->WriterAudioStream.streamID = M4VSS3GPP_WRITER_AUDIO_STREAM_ID;
pC_ewc->WriterAudioStream.streamType = pC_ewc->AudioStreamType;
pC_ewc->WriterAudioStream.duration =
0; /**< Not used by the shell/core writer */
pC_ewc->WriterAudioStream.profileLevel =
0; /**< Not used by the shell/core writer */
pC_ewc->WriterAudioStreamInfo.nbSamplesPerSec =
pC_ewc->uiSamplingFrequency;
pC_ewc->WriterAudioStream.timeScale = pC_ewc->uiSamplingFrequency;
pC_ewc->WriterAudioStreamInfo.nbChannels =
(M4OSA_UInt16)pC_ewc->uiNbChannels;
pC_ewc->WriterAudioStreamInfo.nbBitsPerSample =
0; /**< Not used by the shell/core writer */
/**
* Add the audio stream */
switch( pC_ewc->AudioStreamType )
{
case M4SYS_kAMR:
pC_ewc->WriterAudioStream.averageBitrate =
0; /**< It is not used by the shell, the DSI is taken into account instead */
pC_ewc->WriterAudioStream.maxBitrate =
0; /**< Not used by the shell/core writer */
break;
case M4SYS_kAAC:
pC_ewc->WriterAudioStream.averageBitrate =
pC_ewc->uiAudioBitrate;
pC_ewc->WriterAudioStream.maxBitrate = pC_ewc->uiAudioBitrate;
break;
case M4SYS_kEVRC:
pC_ewc->WriterAudioStream.averageBitrate =
0; /**< It is not used by the shell, the DSI is taken into account instead */
pC_ewc->WriterAudioStream.maxBitrate =
0; /**< Not used by the shell/core writer */
break;
case M4SYS_kMP3: /**< there can't be MP3 track in 3GPP file -> error */
default:
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile: unknown output audio format (0x%x),\
returning M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT!",
pC_ewc->AudioStreamType);
return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT;
}
/**
* Our writer shell interface is a little tricky: we put M4WRITER_StreamAudioInfos
in the DSI pointer... */
pC_ewc->WriterAudioStream.decoderSpecificInfo =
(M4OSA_MemAddr32) &streamAudioInfo;
/**
* Link the AU and the stream */
pC_ewc->WriterAudioAU.stream = &(pC_ewc->WriterAudioStream);
pC_ewc->WriterAudioAU.dataAddress = M4OSA_NULL;
pC_ewc->WriterAudioAU.size = 0;
pC_ewc->WriterAudioAU.CTS =
-pC_ewc->iSilenceFrameDuration; /** Reset time */
pC_ewc->WriterAudioAU.DTS = 0;
pC_ewc->WriterAudioAU.attribute = 0;
pC_ewc->WriterAudioAU.nbFrag = 0; /** No fragment */
pC_ewc->WriterAudioAU.frag = M4OSA_NULL;
err = pC_ShellAPI->pWriterGlobalFcts->pFctAddStream(
pC_ewc->p3gpWriterContext, &pC_ewc->WriterAudioStream);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctAddStream(audio) returns 0x%x!",
err);
return err;
}
/**
* Set the writer max audio AU size */
pC_ewc->uiAudioMaxAuSize = M4VSS3GPP_AUDIO_MAX_AU_SIZE;
temp.streamID = M4VSS3GPP_WRITER_AUDIO_STREAM_ID;
temp.value = pC_ewc->uiAudioMaxAuSize;
err = pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(
pC_ewc->p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxAUSize,
(M4OSA_DataOption) &temp);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, audio) returns 0x%x!",
err);
return err;
}
/**
* Set the writer max audio chunck size */
temp.streamID = M4VSS3GPP_WRITER_AUDIO_STREAM_ID;
temp.value = M4VSS3GPP_AUDIO_MAX_CHUNCK_SIZE;
err = pC_ShellAPI->pWriterGlobalFcts->pFctSetOption(
pC_ewc->p3gpWriterContext,
(M4OSA_UInt32)M4WRITER_kMaxChunckSize,
(M4OSA_DataOption) &temp);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, audio) returns 0x%x!",
err);
return err;
}
}
/**
* All streams added, we're now ready to write */
err = pC_ShellAPI->pWriterGlobalFcts->pFctStartWriting(
pC_ewc->p3gpWriterContext);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intCreate3GPPOutputFile:\
pWriterGlobalFcts->pFctStartWriting() returns 0x%x!",
err);
return err;
}
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_intCreate3GPPOutputFile(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intComputeOutputVideoAndAudioDsi()
* @brief Generate a H263 or MPEG-4 decoder specific info compatible with all input video
* tracks. Copy audio dsi from master clip.
* @param pC (IN/OUT) Internal edit context
******************************************************************************
*/
static M4OSA_ERR
M4VSS3GPP_intComputeOutputVideoAndAudioDsi( M4VSS3GPP_InternalEditContext *pC,
M4OSA_UInt8 uiMasterClip )
{
M4OSA_Int32 iResynchMarkerDsiIndex;
M4_StreamHandler *pStreamForDsi;
M4VSS3GPP_ClipContext *pClip;
M4OSA_ERR err;
M4OSA_UInt32 i;
M4DECODER_MPEG4_DecoderConfigInfo DecConfigInfo;
M4DECODER_VideoSize dummySize;
M4OSA_Bool bGetDSiFromEncoder = M4OSA_FALSE;
M4ENCODER_Header *encHeader;
M4SYS_StreamIDmemAddr streamHeader;
pStreamForDsi = M4OSA_NULL;
pClip = M4OSA_NULL;
/**
* H263 case */
if( M4SYS_kH263 == pC->ewc.VideoStreamType )
{
/**
* H263 output DSI is always 7 bytes */
pC->ewc.uiVideoOutputDsiSize = 7;
pC->ewc.pVideoOutputDsi =
(M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->ewc.uiVideoOutputDsiSize,
M4VSS3GPP, (M4OSA_Char *)"pC->ewc.pVideoOutputDsi (H263)");
if( M4OSA_NULL == pC->ewc.pVideoOutputDsi )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi():\
unable to allocate pVideoOutputDsi (H263), returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
/**
* (We override the input vendor info.
* At least we know that nothing special will be tried with PHLP-stamped
edited streams...) */
pC->ewc.pVideoOutputDsi[0] = 'P';
pC->ewc.pVideoOutputDsi[1] = 'H';
pC->ewc.pVideoOutputDsi[2] = 'L';
pC->ewc.pVideoOutputDsi[3] = 'P';
/**
* Decoder version is 0 */
pC->ewc.pVideoOutputDsi[4] = 0;
/**
* Level is the sixth byte in the DSI */
pC->ewc.pVideoOutputDsi[5] = pC->xVSS.outputVideoLevel;
/**
* Profile is the seventh byte in the DSI*/
pC->ewc.pVideoOutputDsi[6] = pC->xVSS.outputVideoProfile;
}
/**
* MPEG-4 case */
else if( M4SYS_kMPEG_4 == pC->ewc.VideoStreamType ||
M4SYS_kH264 == pC->ewc.VideoStreamType) {
/* For MPEG4 and H.264 encoder case
* Fetch the DSI from the shell video encoder, and feed it to the writer before
closing it. */
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi: get DSI for H264 stream");
if( M4OSA_NULL == pC->ewc.pEncContext )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi: pC->ewc.pEncContext is NULL");
err = M4VSS3GPP_intCreateVideoEncoder(pC);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
M4VSS3GPP_intCreateVideoEncoder returned error 0x%x",
err);
}
}
if( M4OSA_NULL != pC->ewc.pEncContext )
{
err = pC->ShellAPI.pVideoEncoderGlobalFcts->pFctGetOption(
pC->ewc.pEncContext, M4ENCODER_kOptionID_EncoderHeader,
(M4OSA_DataOption) &encHeader);
if( ( M4NO_ERROR != err) || (M4OSA_NULL == encHeader->pBuf) )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
failed to get the encoder header (err 0x%x)",
err);
M4OSA_TRACE1_2(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi: encHeader->pBuf=0x%x, size=0x%x",
encHeader->pBuf, encHeader->Size);
}
else
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
send DSI for video stream to 3GP writer");
/**
* Allocate and copy the new DSI */
pC->ewc.pVideoOutputDsi =
(M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(encHeader->Size, M4VSS3GPP,
(M4OSA_Char *)"pC->ewc.pVideoOutputDsi (H264)");
if( M4OSA_NULL == pC->ewc.pVideoOutputDsi )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi():\
unable to allocate pVideoOutputDsi, returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
pC->ewc.uiVideoOutputDsiSize = (M4OSA_UInt16)encHeader->Size;
memcpy((void *)pC->ewc.pVideoOutputDsi, (void *)encHeader->pBuf,
encHeader->Size);
}
err = M4VSS3GPP_intDestroyVideoEncoder(pC);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
M4VSS3GPP_intDestroyVideoEncoder returned error 0x%x",
err);
}
}
else
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
pC->ewc.pEncContext is NULL, cannot get the DSI");
}
}
pStreamForDsi = M4OSA_NULL;
pClip = M4OSA_NULL;
/* Compute Audio DSI */
if( M4SYS_kAudioUnknown != pC->ewc.AudioStreamType )
{
if( uiMasterClip == 0 )
{
/* Clip is already opened */
pStreamForDsi = &(pC->pC1->pAudioStream->m_basicProperties);
}
else
{
/**
* We can use the fast open mode to get the DSI */
err = M4VSS3GPP_intClipInit(&pClip, pC->pOsaFileReadPtr);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
M4VSS3GPP_intClipInit() returns 0x%x!",
err);
if( pClip != M4OSA_NULL )
{
M4VSS3GPP_intClipCleanUp(pClip);
}
return err;
}
err = M4VSS3GPP_intClipOpen(pClip, &pC->pClipList[uiMasterClip],
M4OSA_FALSE, M4OSA_TRUE, M4OSA_TRUE);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
M4VSS3GPP_intClipOpen() returns 0x%x!",
err);
M4VSS3GPP_intClipCleanUp(pClip);
return err;
}
pStreamForDsi = &(pClip->pAudioStream->m_basicProperties);
}
/**
* Allocate and copy the new DSI */
pC->ewc.pAudioOutputDsi = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(
pStreamForDsi->m_decoderSpecificInfoSize,
M4VSS3GPP, (M4OSA_Char *)"pC->ewc.pAudioOutputDsi");
if( M4OSA_NULL == pC->ewc.pAudioOutputDsi )
{
M4OSA_TRACE1_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi():\
unable to allocate pAudioOutputDsi, returning M4ERR_ALLOC");
return M4ERR_ALLOC;
}
pC->ewc.uiAudioOutputDsiSize =
(M4OSA_UInt16)pStreamForDsi->m_decoderSpecificInfoSize;
memcpy((void *)pC->ewc.pAudioOutputDsi,
(void *)pStreamForDsi->m_pDecoderSpecificInfo,
pC->ewc.uiAudioOutputDsiSize);
/**
* If a clip has been temporarily opened to get its DSI, close it */
if( M4OSA_NULL != pClip )
{
err = M4VSS3GPP_intClipCleanUp(pClip);
if( M4NO_ERROR != err )
{
M4OSA_TRACE1_1(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi:\
M4VSS3GPP_intClipCleanUp() returns 0x%x!",
err);
return err;
}
}
}
/**
* Return with no error */
M4OSA_TRACE3_0(
"M4VSS3GPP_intComputeOutputVideoAndAudioDsi(): returning M4NO_ERROR");
return M4NO_ERROR;
}
/**
******************************************************************************
* M4OSA_ERR M4VSS3GPP_intSwitchToNextClip()
* @brief Switch from the current clip to the next one
* @param pC (IN/OUT) Internal edit context
******************************************************************************
*/
static M4OSA_ERR M4VSS3GPP_intSwitchToNextClip(
M4VSS3GPP_InternalEditContext *pC )
{
M4OSA_ERR err;
if( M4OSA_NULL != pC->pC1 )
{
if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame) {
if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[0].pac_data) {
free(pC->pC1->m_pPreResizeFrame[0].pac_data);
pC->pC1->m_pPreResizeFrame[0].pac_data = M4OSA_NULL;
}
if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[1].pac_data) {
free(pC->pC1->m_pPreResizeFrame[1].pac_data);
pC->pC1->m_pPreResizeFrame[1].pac_data = M4OSA_NULL;
}
if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[2].pac_data) {
free(pC->pC1->m_pPreResizeFrame[2].pac_data);
pC->pC1->m_pPreResizeFrame[2].pac_data = M4OSA_NULL;
}
free(pC->pC1->m_pPreResizeFrame);