/* * 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 M4PTO3GPP_API.c * @brief Picture to 3gpp Service implementation. * @note ****************************************************************************** */ /*16 bytes signature to be written in the generated 3gp files */ #define M4PTO3GPP_SIGNATURE "NXP-SW : PTO3GPP" /****************/ /*** Includes ***/ /****************/ /** * Our header */ #include "M4PTO3GPP_InternalTypes.h" #include "M4PTO3GPP_API.h" /** * Our errors */ #include "M4PTO3GPP_ErrorCodes.h" #ifdef M4VSS_SUPPORT_ENCODER_MPEG4 #include "VideoEditorVideoEncoder.h" #endif /** * OSAL headers */ #include "M4OSA_Memory.h" /* OSAL memory management */ #include "M4OSA_Debug.h" /* OSAL debug management */ /************************/ /*** Various Magicals ***/ /************************/ #define M4PTO3GPP_WRITER_AUDIO_STREAM_ID 1 #define M4PTO3GPP_WRITER_VIDEO_STREAM_ID 2 #define M4PTO3GPP_QUANTIZER_STEP 4 /**< Quantizer step */ #define M4PTO3GPP_WRITER_AUDIO_PROFILE_LEVEL 0xFF /**< No specific profile and level */ #define M4PTO3GPP_WRITER_AUDIO_AMR_TIME_SCALE 8000 /**< AMR */ #define M4PTO3GPP_BITRATE_REGULATION_CTS_PERIOD_IN_MS 500 /**< MAGICAL */ #define M4PTO3GPP_MARGE_OF_FILE_SIZE 25000 /**< MAGICAL */ /** ****************************************************************************** * define AMR 12.2 kbps silence frame ****************************************************************************** */ #define M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE 32 #define M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_DURATION 20 const M4OSA_UInt8 M4PTO3GPP_AMR_AU_SILENCE_122_FRAME[M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE]= { 0x3C, 0x91, 0x17, 0x16, 0xBE, 0x66, 0x78, 0x00, 0x00, 0x01, 0xE7, 0xAF, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #define M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE 13 #define M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_DURATION 20 const M4OSA_UInt8 M4PTO3GPP_AMR_AU_SILENCE_048_FRAME[M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE] = { 0x04, 0xFF, 0x18, 0xC7, 0xF0, 0x0D, 0x04, 0x33, 0xFF, 0xE0, 0x00, 0x00, 0x00 }; /***************************/ /*** "Private" functions ***/ /***************************/ static M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC); /****************************/ /*** "External" functions ***/ /****************************/ extern M4OSA_ERR M4WRITER_3GP_getInterfaces(M4WRITER_OutputFileType* pType, M4WRITER_GlobalInterface** SrcGlobalInterface, M4WRITER_DataInterface** SrcDataInterface); extern M4OSA_ERR M4READER_AMR_getInterfaces(M4READER_MediaType *pMediaType, M4READER_GlobalInterface **pRdrGlobalInterface, M4READER_DataInterface **pRdrDataInterface); extern M4OSA_ERR M4READER_3GP_getInterfaces(M4READER_MediaType *pMediaType, M4READER_GlobalInterface **pRdrGlobalInterface, M4READER_DataInterface **pRdrDataInterface); /****************************/ /*** "Static" functions ***/ /****************************/ static M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame( M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts); static M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame( M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts); /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_GetVersion(M4_VersionInfo* pVersionInfo); * @brief Get the M4PTO3GPP 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 M4PTO3GPP_GetVersion(M4_VersionInfo* pVersionInfo) /*********************************************************/ { M4OSA_TRACE3_1("M4PTO3GPP_GetVersion called with pVersionInfo=0x%x", pVersionInfo); /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL==pVersionInfo),M4ERR_PARAMETER, "M4PTO3GPP_GetVersion: pVersionInfo is M4OSA_NULL"); pVersionInfo->m_major = M4PTO3GPP_VERSION_MAJOR; pVersionInfo->m_minor = M4PTO3GPP_VERSION_MINOR; pVersionInfo->m_revision = M4PTO3GPP_VERSION_REVISION; return M4NO_ERROR; } /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_Init(M4PTO3GPP_Context* pContext); * @brief Initializes the M4PTO3GPP (allocates an execution context). * @note * @param pContext (OUT) Pointer on the M4PTO3GPP 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 (If Debug Level >= 2) * @return M4ERR_ALLOC: There is no more available memory ****************************************************************************** */ /*********************************************************/ M4OSA_ERR M4PTO3GPP_Init( M4PTO3GPP_Context* pContext, M4OSA_FileReadPointer* pFileReadPtrFct, M4OSA_FileWriterPointer* pFileWritePtrFct) /*********************************************************/ { M4PTO3GPP_InternalContext *pC; M4OSA_UInt32 i; M4OSA_TRACE3_1("M4PTO3GPP_Init called with pContext=0x%x", pContext); /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER, "M4PTO3GPP_Init: pContext is M4OSA_NULL"); /** * Allocate the M4PTO3GPP context and return it to the user */ pC = (M4PTO3GPP_InternalContext*)M4OSA_32bitAlignedMalloc(sizeof(M4PTO3GPP_InternalContext), M4PTO3GPP, (M4OSA_Char *)"M4PTO3GPP_InternalContext"); *pContext = pC; if (M4OSA_NULL == pC) { M4OSA_TRACE1_0("M4PTO3GPP_Step(): unable to allocate M4PTO3GPP_InternalContext,\ returning M4ERR_ALLOC"); return M4ERR_ALLOC; } /** * Init the context. All pointers must be initialized to M4OSA_NULL because CleanUp() can be called just after Init(). */ pC->m_State = M4PTO3GPP_kState_CREATED; pC->m_VideoState = M4PTO3GPP_kStreamState_NOSTREAM; pC->m_AudioState = M4PTO3GPP_kStreamState_NOSTREAM; /** * Reader stuff */ pC->m_pReaderAudioAU = M4OSA_NULL; pC->m_pReaderAudioStream = M4OSA_NULL; /** * Writer stuff */ pC->m_pEncoderHeader = M4OSA_NULL; pC->m_pWriterVideoStream = M4OSA_NULL; pC->m_pWriterAudioStream = M4OSA_NULL; pC->m_pWriterVideoStreamInfo= M4OSA_NULL; pC->m_pWriterAudioStreamInfo= M4OSA_NULL; /** * Contexts of the used modules */ pC->m_pAudioReaderContext = M4OSA_NULL; pC->m_p3gpWriterContext = M4OSA_NULL; pC->m_pMp4EncoderContext = M4OSA_NULL; pC->m_eEncoderState = M4PTO3GPP_kNoEncoder; /** * Interfaces of the used modules */ pC->m_pReaderGlobInt = M4OSA_NULL; pC->m_pReaderDataInt = M4OSA_NULL; pC->m_pWriterGlobInt = M4OSA_NULL; pC->m_pWriterDataInt = M4OSA_NULL; pC->m_pEncoderInt = M4OSA_NULL; pC->m_pEncoderExternalAPI = M4OSA_NULL; pC->m_pEncoderUserData = M4OSA_NULL; /** * Fill the OSAL file function set */ pC->pOsalFileRead = pFileReadPtrFct; pC->pOsalFileWrite = pFileWritePtrFct; /** * Video rate control stuff */ pC->m_mtCts = 0.0F; pC->m_mtNextCts = 0.0F; pC->m_mtAudioCts = 0.0F; pC->m_AudioOffSet = 0.0F; pC->m_dLastVideoRegulCts= 0.0F; pC->m_PrevAudioCts = 0.0F; pC->m_DeltaAudioCts = 0.0F; pC->m_MaxFileSize = 0; pC->m_CurrentFileSize = 0; pC->m_IsLastPicture = M4OSA_FALSE; pC->m_bAudioPaddingSilence = M4OSA_FALSE; pC->m_bLastInternalCallBack = M4OSA_FALSE; pC->m_NbCurrentFrame = 0; pC->pSavedPlane = M4OSA_NULL; pC->uiSavedDuration = 0; M4OSA_TRACE3_0("M4PTO3GPP_Init(): returning M4NO_ERROR"); return M4NO_ERROR; } /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams); * @brief Set the M4PTO3GPP input and output files. * @note It opens the input file, but the output file may not be created yet. * @param pContext (IN) M4PTO3GPP context * @param pParams (IN) Pointer to the parameters for the PTO3GPP. * @note The pointed structure can be de-allocated after this function returns because * it is internally copied by the PTO3GPP * @return M4NO_ERROR: No error * @return M4ERR_PARAMETER: At least one parameter is M4OSA_NULL * @return M4ERR_STATE: M4PTO3GPP is not in an appropriate state for this function to be called * @return M4ERR_ALLOC: There is no more available memory * @return ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263 The output video frame * size parameter is incompatible with H263 encoding * @return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT The output video format parameter is undefined * @return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE The output video bit-rate parameter is undefined * @return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE The output video frame size parameter is undefined * @return ERR_PTO3GPP_UNDEFINED_OUTPUT_FILE_SIZE The output file size parameter is undefined * @return ERR_PTO3GPP_UNDEFINED_AUDIO_PADDING The output audio padding parameter is undefined * @return ERR_PTO3GPP_UNHANDLED_AUDIO_TRACK_INPUT_FILE The input audio file contains a track format not handled by PTO3GPP ****************************************************************************** */ /*********************************************************/ M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams) /*********************************************************/ { M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext); M4OSA_ERR err = M4NO_ERROR; M4READER_MediaFamily mediaFamily; M4_StreamHandler* pStreamHandler; M4READER_MediaType readerMediaType; M4OSA_TRACE2_2("M4PTO3GPP_Open called with pContext=0x%x, pParams=0x%x", pContext, pParams); /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER, \ "M4PTO3GPP_Open: pContext is M4OSA_NULL"); M4OSA_DEBUG_IF2((M4OSA_NULL == pParams), M4ERR_PARAMETER, \ "M4PTO3GPP_Open: pParams is M4OSA_NULL"); /** * Check parameters correctness */ M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pPictureCallbackFct), M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pPictureCallbackFct is M4OSA_NULL"); M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pPictureCallbackCtxt), M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pPictureCallbackCtxt is M4OSA_NULL"); M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pOutput3gppFile), M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pOutput3gppFile is M4OSA_NULL"); M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pTemporaryFile), M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pTemporaryFile is M4OSA_NULL"); /** * Video Format */ if( (M4VIDEOEDITING_kH263 != pParams->OutputVideoFormat) && (M4VIDEOEDITING_kMPEG4 != pParams->OutputVideoFormat) && (M4VIDEOEDITING_kH264 != pParams->OutputVideoFormat)) { M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video format"); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT; } /** * Video Bitrate */ if(!((M4VIDEOEDITING_k16_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k24_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k32_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k48_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k64_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k96_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k128_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k192_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k256_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k288_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k384_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k512_KBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k800_KBPS == pParams->OutputVideoBitrate) || /*+ New Encoder bitrates */ (M4VIDEOEDITING_k2_MBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k5_MBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_k8_MBPS == pParams->OutputVideoBitrate) || (M4VIDEOEDITING_kVARIABLE_KBPS == pParams->OutputVideoBitrate))) { M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video bitrate"); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE; } /** * Video frame size */ if (!((M4VIDEOEDITING_kSQCIF == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kQQVGA == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kQCIF == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kQVGA == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kCIF == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kVGA == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kNTSC == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_kWVGA == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k640_360 == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k854_480 == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k1280_720 == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k1080_720 == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k960_720 == pParams->OutputVideoFrameSize) || (M4VIDEOEDITING_k1920_1080 == pParams->OutputVideoFrameSize))) { M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video frame size"); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE; } /** * Maximum size of the output 3GPP file */ if (!((M4PTO3GPP_k50_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k75_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k100_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k150_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k200_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k300_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k400_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_k500_KB == pParams->OutputFileMaxSize) || (M4PTO3GPP_kUNLIMITED == pParams->OutputFileMaxSize))) { M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output 3GPP file size"); return ERR_PTO3GPP_UNDEFINED_OUTPUT_FILE_SIZE; } /* Audio padding */ if (M4OSA_NULL != pParams->pInputAudioTrackFile) { if ((!( (M4PTO3GPP_kAudioPaddingMode_None == pParams->AudioPaddingMode) || (M4PTO3GPP_kAudioPaddingMode_Silence== pParams->AudioPaddingMode) || (M4PTO3GPP_kAudioPaddingMode_Loop == pParams->AudioPaddingMode)))) { M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined audio padding"); return ERR_PTO3GPP_UNDEFINED_AUDIO_PADDING; } } /**< Size check for H263 (only valid sizes are CIF, QCIF and SQCIF) */ if ((M4VIDEOEDITING_kH263 == pParams->OutputVideoFormat) && (M4VIDEOEDITING_kSQCIF != pParams->OutputVideoFrameSize) && (M4VIDEOEDITING_kQCIF != pParams->OutputVideoFrameSize) && (M4VIDEOEDITING_kCIF != pParams->OutputVideoFrameSize)) { M4OSA_TRACE1_0("M4PTO3GPP_Open():\ returning ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263"); return ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263; } /** * Check state automaton */ if (M4PTO3GPP_kState_CREATED != pC->m_State) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): Wrong State (%d), returning M4ERR_STATE", pC->m_State); return M4ERR_STATE; } /** * Copy the M4PTO3GPP_Params structure */ memcpy((void *)(&pC->m_Params), (void *)pParams, sizeof(M4PTO3GPP_Params)); M4OSA_TRACE1_1("M4PTO3GPP_Open: outputVideoBitrate = %d", pC->m_Params.OutputVideoBitrate); /***********************************/ /* Open input file with the reader */ /***********************************/ if (M4OSA_NULL != pC->m_Params.pInputAudioTrackFile) { /** * Get the reader interface according to the input audio file type */ switch(pC->m_Params.AudioFileFormat) { #ifdef M4VSS_SUPPORT_READER_AMR case M4VIDEOEDITING_kFileType_AMR: err = M4READER_AMR_getInterfaces( &readerMediaType, &pC->m_pReaderGlobInt, &pC->m_pReaderDataInt); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): M4READER_AMR_getInterfaces returns 0x%x", err); return err; } break; #endif #ifdef AAC_SUPPORTED case M4VIDEOEDITING_kFileType_3GPP: err = M4READER_3GP_getInterfaces( &readerMediaType, &pC->m_pReaderGlobInt, &pC->m_pReaderDataInt); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): M4READER_3GP_getInterfaces returns 0x%x", err); return err; } break; #endif default: return ERR_PTO3GPP_UNHANDLED_AUDIO_TRACK_INPUT_FILE; } /** * Initializes the reader shell */ err = pC->m_pReaderGlobInt->m_pFctCreate(&pC->m_pAudioReaderContext); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctCreate returns 0x%x", err); return err; } pC->m_pReaderDataInt->m_readerContext = pC->m_pAudioReaderContext; /**< Link the reader interface to the reader context */ /** * Set the reader shell file access functions */ err = pC->m_pReaderGlobInt->m_pFctSetOption(pC->m_pAudioReaderContext, M4READER_kOptionID_SetOsaFileReaderFctsPtr, (M4OSA_DataOption)pC->pOsalFileRead); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctSetOption returns 0x%x", err); return err; } /** * Open the input audio file */ err = pC->m_pReaderGlobInt->m_pFctOpen(pC->m_pAudioReaderContext, pC->m_Params.pInputAudioTrackFile); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctOpen returns 0x%x", err); pC->m_pReaderGlobInt->m_pFctDestroy(pC->m_pAudioReaderContext); pC->m_pAudioReaderContext = M4OSA_NULL; return err; } /** * Get the audio streams from the input file */ err = M4NO_ERROR; while (M4NO_ERROR == err) { err = pC->m_pReaderGlobInt->m_pFctGetNextStream(pC->m_pAudioReaderContext, &mediaFamily, &pStreamHandler); 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 an audio stream */ if ((M4READER_kMediaFamilyAudio == mediaFamily) && (M4OSA_NULL == pC->m_pReaderAudioStream)) { pC->m_pReaderAudioStream = (M4_AudioStreamHandler*)pStreamHandler; /**< Keep pointer to the audio stream */ M4OSA_TRACE3_0("M4PTO3GPP_Open(): Found an audio stream in input"); pStreamHandler->m_bStreamIsOK = M4OSA_TRUE; /** * Allocate audio AU used for read operations */ pC->m_pReaderAudioAU = (M4_AccessUnit*)M4OSA_32bitAlignedMalloc(sizeof(M4_AccessUnit), M4PTO3GPP,(M4OSA_Char *)"pReaderAudioAU"); if (M4OSA_NULL == pC->m_pReaderAudioAU) { M4OSA_TRACE1_0("M4PTO3GPP_Open(): unable to allocate pReaderAudioAU, \ returning M4ERR_ALLOC"); return M4ERR_ALLOC; } /** * Initializes an access Unit */ err = pC->m_pReaderGlobInt->m_pFctFillAuStruct(pC->m_pAudioReaderContext, pStreamHandler, pC->m_pReaderAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open():\ pReaderGlobInt->m_pFctFillAuStruct(audio)returns 0x%x", err); return err; } } else { pStreamHandler->m_bStreamIsOK = M4OSA_FALSE; } } else if (M4WAR_NO_MORE_STREAM != err) /**< Unexpected error code */ { M4OSA_TRACE1_1("M4PTO3GPP_Open():\ pReaderGlobInt->m_pFctGetNextStream returns 0x%x", err); return err; } } /* while*/ } /*if (M4OSA_NULL != pC->m_Params.pInputAudioTrackFile)*/ pC->m_VideoState = M4PTO3GPP_kStreamState_STARTED; /** * Init the audio stream */ if (M4OSA_NULL != pC->m_pReaderAudioStream) { pC->m_AudioState = M4PTO3GPP_kStreamState_STARTED; err = pC->m_pReaderGlobInt->m_pFctReset(pC->m_pAudioReaderContext, (M4_StreamHandler*)pC->m_pReaderAudioStream); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderDataInt->m_pFctReset(audio returns 0x%x", err); return err; } } /** * Update state automaton */ pC->m_State = M4PTO3GPP_kState_OPENED; /** * Get the max File size */ switch(pC->m_Params.OutputFileMaxSize) { case M4PTO3GPP_k50_KB: pC->m_MaxFileSize = 50000; break; case M4PTO3GPP_k75_KB: pC->m_MaxFileSize = 75000; break; case M4PTO3GPP_k100_KB: pC->m_MaxFileSize = 100000; break; case M4PTO3GPP_k150_KB: pC->m_MaxFileSize = 150000; break; case M4PTO3GPP_k200_KB: pC->m_MaxFileSize = 200000; break; case M4PTO3GPP_k300_KB: pC->m_MaxFileSize = 300000; break; case M4PTO3GPP_k400_KB: pC->m_MaxFileSize = 400000; break; case M4PTO3GPP_k500_KB: pC->m_MaxFileSize = 500000; break; case M4PTO3GPP_kUNLIMITED: default: break; } M4OSA_TRACE3_0("M4PTO3GPP_Open(): returning M4NO_ERROR"); return M4NO_ERROR; } /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_Step(M4PTO3GPP_Context pContext); * @brief Perform one step of trancoding. * @note * @param pContext (IN) M4PTO3GPP context * @return M4NO_ERROR No error * @return M4ERR_PARAMETER pContext is M4OSA_NULL * @return M4ERR_STATE: M4PTO3GPP is not in an appropriate state for this function * to be called * @return M4PTO3GPP_WAR_END_OF_PROCESSING Encoding completed ****************************************************************************** */ /*********************************************************/ M4OSA_ERR M4PTO3GPP_Step(M4PTO3GPP_Context pContext) /*********************************************************/ { M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext); M4OSA_ERR err = M4NO_ERROR; M4OSA_UInt32 l_uiAudioStepCount = 0; M4OSA_Int32 JumpToTime = 0; M4OSA_Time mtIncCts; /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL==pContext), M4ERR_PARAMETER, "M4PTO3GPP_Step: pContext is M4OSA_NULL"); /** * Check state automaton */ if ( !((M4PTO3GPP_kState_OPENED == pC->m_State) || (M4PTO3GPP_kState_READY == pC->m_State)) ) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): Wrong State (%d), returning M4ERR_STATE", pC->m_State); return M4ERR_STATE; } /******************************************************************/ /** * In case this is the first step, we prepare the decoder, the encoder and the writer */ if (M4PTO3GPP_kState_OPENED == pC->m_State) { M4OSA_TRACE2_0("M4PTO3GPP_Step(): This is the first step, \ calling M4PTO3GPP_Ready4Processing"); /** * Prepare the reader, the decoder, the encoder, the writer... */ err = M4PTO3GPP_Ready4Processing(pC); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): M4PTO3GPP_Ready4Processing() returns 0x%x", err); return err; } /** * Update state automaton */ pC->m_State = M4PTO3GPP_kState_READY; M4OSA_TRACE3_0("M4PTO3GPP_Step(): returning M4NO_ERROR (a)"); return M4NO_ERROR; /**< we only do that in the first step, \ first REAL step will be the next one */ } /* * Check if we reached the targeted file size. * We do that before the encoding, because the core encoder has to know if this is * the last frame to encode */ err = pC->m_pWriterGlobInt->pFctGetOption(pC->m_p3gpWriterContext, M4WRITER_kFileSizeAudioEstimated, (M4OSA_DataOption) &pC->m_CurrentFileSize); if ((0 != pC->m_MaxFileSize) && /**< Add a marge to the file size in order to never exceed the max file size */ ((pC->m_CurrentFileSize + M4PTO3GPP_MARGE_OF_FILE_SIZE) >= pC->m_MaxFileSize)) { pC->m_IsLastPicture = M4OSA_TRUE; } /****************************************************************** * At that point we are in M4PTO3GPP_kState_READY state * We perform one step of video encoding ******************************************************************/ /************* VIDEO ENCODING ***************/ if (M4PTO3GPP_kStreamState_STARTED == pC->m_VideoState) /**m_NbCurrentFrame++; /* Check if it is the last frame the to encode */ if((pC->m_Params.NbVideoFrames > 0) \ && (pC->m_NbCurrentFrame >= pC->m_Params.NbVideoFrames)) { pC->m_IsLastPicture = M4OSA_TRUE; } M4OSA_TRACE2_2("M4PTO3GPP_Step(): Calling pEncoderInt->pFctEncode with videoCts = %.2f\ nb = %lu", pC->m_mtCts, pC->m_NbCurrentFrame); err = pC->m_pEncoderInt->pFctEncode(pC->m_pMp4EncoderContext, M4OSA_NULL, /**< The input plane is null because the input Picture will be obtained by the\ VPP filter from the context */ pC->m_mtCts, (pC->m_IsLastPicture ? M4ENCODER_kLastFrame : M4ENCODER_kNormalFrame) ); /**< Last param set to M4OSA_TRUE signals that this is the last frame to be encoded,\ M4OSA_FALSE else */ M4OSA_TRACE3_2("M4PTO3GPP_Step(): pEncoderInt->pFctEncode returns 0x%x, vidFormat =0x%x", err, pC->m_Params.OutputVideoFormat); if((M4NO_ERROR == err) && (M4VIDEOEDITING_kH264 == pC->m_Params.OutputVideoFormat)) { /* Check if last frame.* * */ if(M4OSA_TRUE == pC->m_IsLastPicture) { M4OSA_TRACE3_0("M4PTO3GPP_Step(): Last picture"); pC->m_VideoState = M4PTO3GPP_kStreamState_FINISHED; } } if (M4WAR_NO_MORE_AU == err) /**< The video encoding is finished */ { M4OSA_TRACE3_0("M4PTO3GPP_Step(): pEncoderInt->pFctEncode returns M4WAR_NO_MORE_AU"); pC->m_VideoState = M4PTO3GPP_kStreamState_FINISHED; } else if (M4NO_ERROR != err) /**< Unexpected error code */ { if( (((M4OSA_UInt32)M4WAR_WRITER_STOP_REQ) == err) || (((M4OSA_UInt32)M4ERR_ALLOC) == err) ) { M4OSA_TRACE1_0("M4PTO3GPP_Step: returning ERR_PTO3GPP_ENCODER_ACCES_UNIT_ERROR"); return ERR_PTO3GPP_ENCODER_ACCES_UNIT_ERROR; } else { M4OSA_TRACE1_1("M4PTO3GPP_Step(): pEncoderInt->pFctEncode(last) (a) returns 0x%x", err); return err; } } } /**< End of video encoding */ /****** AUDIO TRANSCODING (read + null encoding + write) ******/ if (M4PTO3GPP_kStreamState_STARTED == pC->m_AudioState) { while ( (M4PTO3GPP_kStreamState_STARTED == pC->m_AudioState) && (pC->m_mtAudioCts < pC->m_mtNextCts)) { l_uiAudioStepCount++; if (M4OSA_FALSE == pC->m_bAudioPaddingSilence) { /**< Read the next audio AU in the input Audio file */ err = pC->m_pReaderDataInt->m_pFctGetNextAu(pC->m_pAudioReaderContext, (M4_StreamHandler*)pC->m_pReaderAudioStream, pC->m_pReaderAudioAU); pC->m_mtAudioCts = pC->m_pReaderAudioAU->m_CTS + pC->m_AudioOffSet; if (M4WAR_NO_MORE_AU == err) /* The audio transcoding is finished */ { M4OSA_TRACE2_0("M4PTO3GPP_Step():\ pReaderDataInt->m_pFctGetNextAu(audio) returns \ M4WAR_NO_MORE_AU"); switch(pC->m_Params.AudioPaddingMode) { case M4PTO3GPP_kAudioPaddingMode_None: pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED; break; case M4PTO3GPP_kAudioPaddingMode_Silence: if (M4DA_StreamTypeAudioAmrNarrowBand != pC->m_pReaderAudioStream->m_basicProperties.m_streamType) /**< Do nothing if the input audio file format is not AMR */ { pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED; } else { pC->m_bAudioPaddingSilence = M4OSA_TRUE; } break; case M4PTO3GPP_kAudioPaddingMode_Loop: /**< Jump to the beginning of the audio file */ err = pC->m_pReaderGlobInt->m_pFctJump(pC->m_pAudioReaderContext, (M4_StreamHandler*)pC->m_pReaderAudioStream, &JumpToTime); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): \ pReaderDataInt->m_pFctReset(audio returns 0x%x", err); return err; } if (M4DA_StreamTypeAudioAmrNarrowBand == pC->m_pReaderAudioStream->m_basicProperties.m_streamType) { pC->m_mtAudioCts += 20; /*< SEMC bug fixed at Lund */ pC->m_AudioOffSet = pC->m_mtAudioCts; /** * 'BZZZ' bug fix: * add a silence frame */ mtIncCts = (M4OSA_Time)((pC->m_mtAudioCts) * (pC->m_pWriterAudioStream->timeScale / 1000.0)); err = M4PTO3GPP_writeAmrSilence122Frame(pC->m_pWriterDataInt, pC->m_p3gpWriterContext, &pC->m_WriterAudioAU, mtIncCts); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): \ M4PTO3GPP_AddAmrSilenceSid returns 0x%x", err); return err; }/**< Add => no audio cts increment...*/ } else { pC->m_AudioOffSet = pC->m_mtAudioCts + pC->m_DeltaAudioCts; } break; } /* end of: switch */ } else if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): pReaderDataInt->m_pFctGetNextAu(Audio)\ returns 0x%x", err); return err; } else { /** * Save the delta Cts (AAC only) */ pC->m_DeltaAudioCts = pC->m_pReaderAudioAU->m_CTS - pC->m_PrevAudioCts; pC->m_PrevAudioCts = pC->m_pReaderAudioAU->m_CTS; /** * Prepare the writer AU */ err = pC->m_pWriterDataInt->pStartAU(pC->m_p3gpWriterContext, 1, &pC->m_WriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): pWriterDataInt->pStartAU(Audio)\ returns 0x%x", err); return err; } /** * Copy audio data from reader AU to writer AU */ M4OSA_TRACE2_1("M4PTO3GPP_Step(): Copying audio AU: size=%d", pC->m_pReaderAudioAU->m_size); memcpy((void *)pC->m_WriterAudioAU.dataAddress, (void *)pC->m_pReaderAudioAU->m_dataAddress, pC->m_pReaderAudioAU->m_size); pC->m_WriterAudioAU.size = pC->m_pReaderAudioAU->m_size; /** * Convert CTS unit from milliseconds to timescale */ if (M4DA_StreamTypeAudioAmrNarrowBand != pC->m_pReaderAudioStream->m_basicProperties.m_streamType) { pC->m_WriterAudioAU.CTS = (M4OSA_Time) ((pC->m_AudioOffSet + pC->m_pReaderAudioAU->m_CTS) * pC->m_pWriterAudioStream->timeScale / 1000.0); } else { pC->m_WriterAudioAU.CTS = (M4OSA_Time)(pC->m_mtAudioCts * (pC->m_pWriterAudioStream->timeScale / 1000.0)); } pC->m_WriterAudioAU.nbFrag = 0; M4OSA_TRACE2_1("M4PTO3GPP_Step(): audio AU: CTS=%d ms", pC->m_mtAudioCts /*pC->m_pReaderAudioAU->m_CTS*/); /** * Write it to the output file */ err = pC->m_pWriterDataInt->pProcessAU(pC->m_p3gpWriterContext, 1, &pC->m_WriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): pWriterDataInt->pProcessAU(Audio)\ returns 0x%x", err); return err; } } } else /**< M4OSA_TRUE == pC->m_bAudioPaddingSilence */ { if (M4DA_StreamTypeAudioAmrNarrowBand == pC->m_pReaderAudioStream->m_basicProperties.m_streamType) { /** * Fill in audio au with silence */ pC->m_mtAudioCts += 20; /** * Padd with silence */ mtIncCts = (M4OSA_Time)(pC->m_mtAudioCts * (pC->m_pWriterAudioStream->timeScale / 1000.0)); err = M4PTO3GPP_writeAmrSilence048Frame(pC->m_pWriterDataInt, pC->m_p3gpWriterContext, &pC->m_WriterAudioAU, mtIncCts); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Step(): M4PTO3GPP_AddAmrSilenceSid returns 0x%x", err); return err; } } else /**< Do nothing if the input audio file format is not AMR */ { pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED; } } } /**< while */ } /**< End of audio encoding */ pC->m_mtCts = pC->m_mtNextCts; /** * The transcoding is finished when no stream is being encoded anymore */ if (M4PTO3GPP_kStreamState_FINISHED == pC->m_VideoState) { pC->m_State = M4PTO3GPP_kState_FINISHED; M4OSA_TRACE2_0("M4PTO3GPP_Step(): transcoding finished, returning M4WAR_NO_MORE_AU"); return M4PTO3GPP_WAR_END_OF_PROCESSING; } M4OSA_TRACE3_0("M4PTO3GPP_Step(): returning M4NO_ERROR (b)"); return M4NO_ERROR; } /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_Close(M4PTO3GPP_Context pContext); * @brief Finish the M4PTO3GPP transcoding. * @note The output 3GPP file is ready to be played after this call * @param pContext (IN) M4PTO3GPP context * @return M4NO_ERROR: No error * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (If Debug Level >= 2) * @return M4ERR_STATE: M4PTO3GPP is not in an appropriate state for this function to be called ****************************************************************************** */ /*********************************************************/ M4OSA_ERR M4PTO3GPP_Close(M4PTO3GPP_Context pContext) /*********************************************************/ { M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext); M4OSA_ERR osaErr = M4NO_ERROR; M4OSA_UInt32 lastCTS; M4ENCODER_Header* encHeader; M4SYS_StreamIDmemAddr streamHeader; M4OSA_TRACE3_1("M4PTO3GPP_Close called with pContext=0x%x", pContext); /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL==pContext), M4ERR_PARAMETER, "M4PTO3GPP_Close:\ pContext is M4OSA_NULL"); /* Check state automaton */ if ((pC->m_State != M4PTO3GPP_kState_OPENED) && (pC->m_State != M4PTO3GPP_kState_READY) && (pC->m_State != M4PTO3GPP_kState_FINISHED)) { M4OSA_TRACE1_1("M4PTO3GPP_Close(): Wrong State (%d), returning M4ERR_STATE", pC->m_State); return M4ERR_STATE; } /*************************************/ /******** Finish the encoding ********/ /*************************************/ if (M4PTO3GPP_kState_READY == pC->m_State) { pC->m_State = M4PTO3GPP_kState_FINISHED; } if (M4PTO3GPP_kEncoderRunning == pC->m_eEncoderState) { if (pC->m_pEncoderInt->pFctStop != M4OSA_NULL) { osaErr = pC->m_pEncoderInt->pFctStop(pC->m_pMp4EncoderContext); if (M4NO_ERROR != osaErr) { M4OSA_TRACE1_1("M4PTO3GPP_close: m_pEncoderInt->pFctStop returns 0x%x", osaErr); /* Well... how the heck do you handle a failed cleanup? */ } } pC->m_eEncoderState = M4PTO3GPP_kEncoderStopped; } /* Has the encoder actually been opened? Don't close it if that's not the case. */ if (M4PTO3GPP_kEncoderStopped == pC->m_eEncoderState) { osaErr = pC->m_pEncoderInt->pFctClose(pC->m_pMp4EncoderContext); if (M4NO_ERROR != osaErr) { M4OSA_TRACE1_1("M4PTO3GPP_close: m_pEncoderInt->pFctClose returns 0x%x", osaErr); /* Well... how the heck do you handle a failed cleanup? */ } pC->m_eEncoderState = M4PTO3GPP_kEncoderClosed; } /*******************************/ /******** Close 3GP out ********/ /*******************************/ if (M4OSA_NULL != pC->m_p3gpWriterContext) /* happens in state _SET */ { /* HW encoder: fetch the DSI from the shell video encoder, and feed it to the writer before closing it. */ if ((M4VIDEOEDITING_kMPEG4 == pC->m_Params.OutputVideoFormat) || (M4VIDEOEDITING_kH264 == pC->m_Params.OutputVideoFormat)) { osaErr = pC->m_pEncoderInt->pFctGetOption(pC->m_pMp4EncoderContext, M4ENCODER_kOptionID_EncoderHeader, (M4OSA_DataOption)&encHeader); if ( (M4NO_ERROR != osaErr) || (M4OSA_NULL == encHeader->pBuf) ) { M4OSA_TRACE1_1("M4PTO3GPP_close: failed to get the encoder header (err 0x%x)", osaErr); /**< no return here, we still have stuff to deallocate after close, even if \ it fails. */ } else { /* set this header in the writer */ streamHeader.streamID = M4PTO3GPP_WRITER_VIDEO_STREAM_ID; streamHeader.size = encHeader->Size; streamHeader.addr = (M4OSA_MemAddr32)encHeader->pBuf; osaErr = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, M4WRITER_kDSI, &streamHeader); if (M4NO_ERROR != osaErr) { M4OSA_TRACE1_1("M4PTO3GPP_close: failed to set the DSI in the writer \ (err 0x%x) ", osaErr); } } } /* Update last Video CTS */ lastCTS = (M4OSA_UInt32)pC->m_mtCts; osaErr = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxFileDuration, &lastCTS); if (M4NO_ERROR != osaErr) { M4OSA_TRACE1_1("M4PTO3GPP_Close: SetOption(M4WRITER_kMaxFileDuration) returns 0x%x", osaErr); } /* Write and close the 3GP output file */ osaErr = pC->m_pWriterGlobInt->pFctCloseWrite(pC->m_p3gpWriterContext); if (M4NO_ERROR != osaErr) { M4OSA_TRACE1_1("M4PTO3GPP_Close: pWriterGlobInt->pFctCloseWrite returns 0x%x", osaErr); /**< don't return yet, we have to close other things */ } pC->m_p3gpWriterContext = M4OSA_NULL; } /** * State transition */ pC->m_State = M4PTO3GPP_kState_CLOSED; M4OSA_TRACE3_1("M4PTO3GPP_Close(): returning 0x%x", osaErr); return osaErr; } /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_CleanUp(M4PTO3GPP_Context pContext); * @brief Free all resources used by the M4PTO3GPP. * @note The context is no more valid after this call * @param pContext (IN) M4PTO3GPP context * @return M4NO_ERROR: No error * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (If Debug Level >= 2) ****************************************************************************** */ /*********************************************************/ M4OSA_ERR M4PTO3GPP_CleanUp(M4PTO3GPP_Context pContext) /*********************************************************/ { M4OSA_ERR err = M4NO_ERROR; M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext); M4OSA_TRACE3_1("M4PTO3GPP_CleanUp called with pContext=0x%x", pContext); /** * Check input parameters */ M4OSA_DEBUG_IF2((M4OSA_NULL==pContext),M4ERR_PARAMETER, "M4PTO3GPP_CleanUp: pContext \ is M4OSA_NULL"); /** * First call Close, if needed, to clean the video encoder */ if ((M4PTO3GPP_kState_OPENED == pC->m_State) || (M4PTO3GPP_kState_READY == pC->m_State) || (M4PTO3GPP_kState_FINISHED == pC->m_State)) { err = M4PTO3GPP_Close(pContext); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: M4PTO3GPP_Close returns 0x%x", err); /**< don't return, we have to free other components */ } } /** * Free Audio reader stuff, if needed */ if (M4OSA_NULL != pC->m_pAudioReaderContext) /**< may be M4OSA_NULL if M4PTO3GPP_Open was not\ called */ { err = pC->m_pReaderGlobInt->m_pFctClose(pC->m_pAudioReaderContext); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pReaderGlobInt->m_pFctClose returns 0x%x", err); /**< don't return, we have to free other components */ } err = pC->m_pReaderGlobInt->m_pFctDestroy(pC->m_pAudioReaderContext); pC->m_pAudioReaderContext = M4OSA_NULL; if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pReaderGlobInt->m_pFctDestroy returns 0x%x", err); /**< don't return, we have to free other components */ } } if (M4OSA_NULL != pC->m_pReaderAudioAU) { free(pC->m_pReaderAudioAU); pC->m_pReaderAudioAU = M4OSA_NULL; } /** * Free video encoder stuff, if needed */ if (M4OSA_NULL != pC->m_pMp4EncoderContext) { err = pC->m_pEncoderInt->pFctCleanup(pC->m_pMp4EncoderContext); pC->m_pMp4EncoderContext = M4OSA_NULL; if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pEncoderInt->pFctDestroy returns 0x%x", err); /**< don't return, we have to free other components */ } } if (M4OSA_NULL != pC->m_pWriterVideoStream) { free(pC->m_pWriterVideoStream); pC->m_pWriterVideoStream = M4OSA_NULL; } if (M4OSA_NULL != pC->m_pWriterAudioStream) { free(pC->m_pWriterAudioStream); pC->m_pWriterAudioStream = M4OSA_NULL; } if (M4OSA_NULL != pC->m_pWriterVideoStreamInfo) { free(pC->m_pWriterVideoStreamInfo); pC->m_pWriterVideoStreamInfo = M4OSA_NULL; } if (M4OSA_NULL != pC->m_pWriterAudioStreamInfo) { free(pC->m_pWriterAudioStreamInfo); pC->m_pWriterAudioStreamInfo = M4OSA_NULL; } /** * Free the shells interfaces */ if (M4OSA_NULL != pC->m_pReaderGlobInt) { free(pC->m_pReaderGlobInt); pC->m_pReaderGlobInt = M4OSA_NULL; } if (M4OSA_NULL != pC->m_pReaderDataInt) { free(pC->m_pReaderDataInt); pC->m_pReaderDataInt = M4OSA_NULL; } if(M4OSA_NULL != pC->m_pEncoderInt) { free(pC->m_pEncoderInt); pC->m_pEncoderInt = M4OSA_NULL; } if(M4OSA_NULL != pC->m_pWriterGlobInt) { free(pC->m_pWriterGlobInt); pC->m_pWriterGlobInt = M4OSA_NULL; } if(M4OSA_NULL != pC->m_pWriterDataInt) { free(pC->m_pWriterDataInt); pC->m_pWriterDataInt = M4OSA_NULL; } /**< Do not free pC->pOsaMemoryPtrFct and pC->pOsaMemoryPtrFct, because it's owned by the \ application */ /** * Free the context itself */ free(pC); pC = M4OSA_NULL; M4OSA_TRACE3_0("M4PTO3GPP_CleanUp(): returning M4NO_ERROR"); return M4NO_ERROR; } /********************* INTERNAL FUNCTIONS *********************/ /** ****************************************************************************** * M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC); * @brief Prepare all resources and interfaces for the transcoding. * @note It is called by the first M4OSA_Step() call * @param pC (IN) M4PTO3GPP private context * @return M4NO_ERROR: No error * @return Any error returned by an underlaying module ****************************************************************************** */ /******************************************************/ M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC) /******************************************************/ { M4OSA_ERR err = M4NO_ERROR; M4WRITER_OutputFileType outputFileType; M4OSA_UInt32 uiVersion; M4ENCODER_Format encFormat; M4ENCODER_AdvancedParams EncParams; /**< Encoder advanced parameters */ M4SYS_StreamIDValue optionValue; M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing called with pC=0x%x", pC); /******************************/ /******************************/ /********************************************/ /******** ********/ /******** Video Encoder Parames init ********/ /******** ********/ /********************************************/ /** * Get the correct encoder interface */ switch(pC->m_Params.OutputVideoFormat) { case M4VIDEOEDITING_kMPEG4: #ifdef M4VSS_SUPPORT_ENCODER_MPEG4 err = VideoEditorVideoEncoder_getInterface_MPEG4(&encFormat, &pC->m_pEncoderInt, M4ENCODER_OPEN_ADVANCED); #else /* software MPEG4 encoder not available! */ M4OSA_TRACE1_0("No MPEG4 encoder available! Did you forget to register one?"); err = M4ERR_STATE; #endif /* software MPEG4 encoder available? */ break; case M4VIDEOEDITING_kH263: #ifdef M4VSS_SUPPORT_ENCODER_MPEG4 err = VideoEditorVideoEncoder_getInterface_H263(&encFormat, &pC->m_pEncoderInt, M4ENCODER_OPEN_ADVANCED); #else /* software H263 encoder not available! */ M4OSA_TRACE1_0("No H263 encoder available! Did you forget to register one?"); err = M4ERR_STATE; #endif /* software H263 encoder available? */ break; case M4VIDEOEDITING_kH264: #ifdef M4VSS_SUPPORT_ENCODER_AVC err = VideoEditorVideoEncoder_getInterface_H264(&encFormat, &pC->m_pEncoderInt, M4ENCODER_OPEN_ADVANCED); #else /* software H264 encoder not available! */ M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing: No H264 encoder available!\ Did you forget to register one?"); err = M4ERR_STATE; #endif /* software H264 encoder available? */ break; default: M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT", pC->m_Params.OutputVideoFormat); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT; } if (M4NO_ERROR != err) { M4OSA_TRACE1_1("switch(pC->m_Params.OutputVideoFormat): getInterfaces returns 0x%x", err); return err; } /** * Fill encoder parameters according to M4PTO3GPP settings */ /** * Video frame size */ switch(pC->m_Params.OutputVideoFrameSize) { case M4VIDEOEDITING_kSQCIF : EncParams.FrameHeight = M4ENCODER_SQCIF_Height; EncParams.FrameWidth = M4ENCODER_SQCIF_Width; break; case M4VIDEOEDITING_kQQVGA : EncParams.FrameHeight = M4ENCODER_QQVGA_Height; EncParams.FrameWidth = M4ENCODER_QQVGA_Width; break; case M4VIDEOEDITING_kQCIF : EncParams.FrameHeight = M4ENCODER_QCIF_Height; EncParams.FrameWidth = M4ENCODER_QCIF_Width; break; case M4VIDEOEDITING_kQVGA : EncParams.FrameHeight = M4ENCODER_QVGA_Height; EncParams.FrameWidth = M4ENCODER_QVGA_Width; break; case M4VIDEOEDITING_kCIF : EncParams.FrameHeight = M4ENCODER_CIF_Height; EncParams.FrameWidth = M4ENCODER_CIF_Width; break; case M4VIDEOEDITING_kVGA : EncParams.FrameHeight = M4ENCODER_VGA_Height; EncParams.FrameWidth = M4ENCODER_VGA_Width; break; /* +PR LV5807 */ case M4VIDEOEDITING_kWVGA : EncParams.FrameHeight = M4ENCODER_WVGA_Height; EncParams.FrameWidth = M4ENCODER_WVGA_Width; break; case M4VIDEOEDITING_kNTSC: EncParams.FrameHeight = M4ENCODER_NTSC_Height; EncParams.FrameWidth = M4ENCODER_NTSC_Width; break; /* -PR LV5807 */ /* +CR Google */ case M4VIDEOEDITING_k640_360: EncParams.FrameHeight = M4ENCODER_640_360_Height; EncParams.FrameWidth = M4ENCODER_640_360_Width; break; case M4VIDEOEDITING_k854_480: EncParams.FrameHeight = M4ENCODER_854_480_Height; EncParams.FrameWidth = M4ENCODER_854_480_Width; break; case M4VIDEOEDITING_k1280_720: EncParams.FrameHeight = M4ENCODER_1280_720_Height; EncParams.FrameWidth = M4ENCODER_1280_720_Width; break; case M4VIDEOEDITING_k1080_720: EncParams.FrameHeight = M4ENCODER_1080_720_Height; EncParams.FrameWidth = M4ENCODER_1080_720_Width; break; case M4VIDEOEDITING_k960_720: EncParams.FrameHeight = M4ENCODER_960_720_Height; EncParams.FrameWidth = M4ENCODER_960_720_Width; break; case M4VIDEOEDITING_k1920_1080: EncParams.FrameHeight = M4ENCODER_1920_1080_Height; EncParams.FrameWidth = M4ENCODER_1920_1080_Width; break; /* -CR Google */ default : M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE", pC->m_Params.OutputVideoFrameSize); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE; } EncParams.InputFormat = M4ENCODER_kIYUV420; /** * Video bitrate */ switch(pC->m_Params.OutputVideoBitrate) { case M4VIDEOEDITING_k16_KBPS: case M4VIDEOEDITING_k24_KBPS: case M4VIDEOEDITING_k32_KBPS: case M4VIDEOEDITING_k48_KBPS: case M4VIDEOEDITING_k64_KBPS: case M4VIDEOEDITING_k96_KBPS: case M4VIDEOEDITING_k128_KBPS: case M4VIDEOEDITING_k192_KBPS: case M4VIDEOEDITING_k256_KBPS: case M4VIDEOEDITING_k288_KBPS: case M4VIDEOEDITING_k384_KBPS: case M4VIDEOEDITING_k512_KBPS: case M4VIDEOEDITING_k800_KBPS: /*+ New Encoder bitrates */ case M4VIDEOEDITING_k2_MBPS: case M4VIDEOEDITING_k5_MBPS: case M4VIDEOEDITING_k8_MBPS: /*- New Encoder bitrates */ EncParams.Bitrate = pC->m_Params.OutputVideoBitrate; break; case M4VIDEOEDITING_kVARIABLE_KBPS: /*+ New Encoder bitrates */ EncParams.Bitrate = M4VIDEOEDITING_k8_MBPS; /*- New Encoder bitrates */ break; default : M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE", pC->m_Params.OutputVideoBitrate); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE; } /** * Video format */ switch(pC->m_Params.OutputVideoFormat) { case M4VIDEOEDITING_kMPEG4 : EncParams.Format = M4ENCODER_kMPEG4; break; case M4VIDEOEDITING_kH263 : EncParams.Format = M4ENCODER_kH263; break; case M4VIDEOEDITING_kH264: EncParams.Format = M4ENCODER_kH264; break; default : M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT", pC->m_Params.OutputVideoFormat); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT; } /** * Video frame rate (set it to max = 30 fps) */ EncParams.uiTimeScale = 30; EncParams.uiRateFactor = 1; EncParams.FrameRate = M4ENCODER_k30_FPS; /******************************/ /******** 3GP out init ********/ /******************************/ /* Get the 3GPP writer interface */ err = M4WRITER_3GP_getInterfaces(&outputFileType, &pC->m_pWriterGlobInt, &pC->m_pWriterDataInt); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4WRITER_3GP_getInterfaces: M4WRITER_3GP_getInterfaces returns 0x%x", err); return err; } /* Init the 3GPP writer */ err = pC->m_pWriterGlobInt->pFctOpen(&pC->m_p3gpWriterContext, pC->m_Params.pOutput3gppFile, pC->pOsalFileWrite, pC->m_Params.pTemporaryFile, pC->pOsalFileRead); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctOpen returns 0x%x", err); return err; } /** * Link to the writer context in the writer interface */ pC->m_pWriterDataInt->pWriterContext = pC->m_p3gpWriterContext; /** * Set the product description string in the written file */ err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, M4WRITER_kEmbeddedString, (M4OSA_DataOption)M4PTO3GPP_SIGNATURE); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: \ pWriterGlobInt->pFctSetOption(M4WRITER_kEmbeddedString) returns 0x%x", err); return err; } /** * Set the product version in the written file */ uiVersion = M4VIDEOEDITING_VERSION_MAJOR*100 + M4VIDEOEDITING_VERSION_MINOR*10 + M4VIDEOEDITING_VERSION_REVISION; err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, M4WRITER_kEmbeddedVersion, (M4OSA_DataOption)&uiVersion); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: \ pWriterGlobInt->pFctSetOption(M4WRITER_kEmbeddedVersion) returns 0x%x", err); return err; } /** * Allocate and fill the video stream structures for the writer */ pC->m_pWriterVideoStream = (M4SYS_StreamDescription*)M4OSA_32bitAlignedMalloc(sizeof(M4SYS_StreamDescription), M4PTO3GPP, (M4OSA_Char *)"pWriterVideoStream"); if (M4OSA_NULL == pC->m_pWriterVideoStream) { M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterVideoStream, \ returning M4ERR_ALLOC"); return M4ERR_ALLOC; } pC->m_pWriterVideoStreamInfo = (M4WRITER_StreamVideoInfos*)M4OSA_32bitAlignedMalloc(sizeof(M4WRITER_StreamVideoInfos), M4PTO3GPP, (M4OSA_Char *)"pWriterVideoStreamInfo"); if (M4OSA_NULL == pC->m_pWriterVideoStreamInfo) { M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterVideoStreamInfo,\ returning M4ERR_ALLOC"); return M4ERR_ALLOC; } /** * Fill Video properties structure for the AddStream method */ pC->m_pWriterVideoStreamInfo->height = EncParams.FrameHeight; pC->m_pWriterVideoStreamInfo->width = EncParams.FrameWidth; pC->m_pWriterVideoStreamInfo->fps = 0; /**< Not used by the core writer */ pC->m_pWriterVideoStreamInfo->Header.pBuf = M4OSA_NULL; /** No header, will be set by setOption */ pC->m_pWriterVideoStreamInfo->Header.Size = 0; /** * Fill Video stream description structure for the AddStream method */ pC->m_pWriterVideoStream->streamID = M4PTO3GPP_WRITER_VIDEO_STREAM_ID; /** * Video format */ switch(pC->m_Params.OutputVideoFormat) { case M4VIDEOEDITING_kMPEG4: pC->m_pWriterVideoStream->streamType = M4SYS_kMPEG_4; break; case M4VIDEOEDITING_kH263: pC->m_pWriterVideoStream->streamType = M4SYS_kH263; break; case M4VIDEOEDITING_kH264: pC->m_pWriterVideoStream->streamType = M4SYS_kH264; break; default : M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT", pC->m_Params.OutputVideoFormat); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT; } /** * Video bitrate */ switch(pC->m_Params.OutputVideoBitrate) { case M4VIDEOEDITING_k16_KBPS: case M4VIDEOEDITING_k24_KBPS: case M4VIDEOEDITING_k32_KBPS: case M4VIDEOEDITING_k48_KBPS: case M4VIDEOEDITING_k64_KBPS: case M4VIDEOEDITING_k96_KBPS: case M4VIDEOEDITING_k128_KBPS: case M4VIDEOEDITING_k192_KBPS: case M4VIDEOEDITING_k256_KBPS: case M4VIDEOEDITING_k288_KBPS: case M4VIDEOEDITING_k384_KBPS: case M4VIDEOEDITING_k512_KBPS: case M4VIDEOEDITING_k800_KBPS: /*+ New Encoder bitrates */ case M4VIDEOEDITING_k2_MBPS: case M4VIDEOEDITING_k5_MBPS: case M4VIDEOEDITING_k8_MBPS: /*- New Encoder bitrates */ pC->m_pWriterVideoStream->averageBitrate = pC->m_Params.OutputVideoBitrate; break; case M4VIDEOEDITING_kVARIABLE_KBPS : pC->m_pWriterVideoStream->averageBitrate = 0; break; default : M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\ ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE", pC->m_Params.OutputVideoBitrate); return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE; } pC->m_pWriterVideoStream->duration = 0; /**< Duration is not known */ pC->m_pWriterVideoStream->timeScale = 0; /**< Not used by the core writer */ pC->m_pWriterVideoStream->maxBitrate = pC->m_pWriterVideoStream->averageBitrate; pC->m_pWriterVideoStream->profileLevel = 0; /**< Not used by the core writer */ pC->m_pWriterVideoStream->decoderSpecificInfo = (M4OSA_MemAddr32) (pC->m_pWriterVideoStreamInfo); pC->m_pWriterVideoStream->decoderSpecificInfoSize = sizeof(M4WRITER_StreamVideoInfos); /** * Update AU properties for video stream */ pC->m_WriterVideoAU.CTS = pC->m_WriterVideoAU.DTS = 0; /** Reset time */ pC->m_WriterVideoAU.size = 0; pC->m_WriterVideoAU.frag = M4OSA_NULL; pC->m_WriterVideoAU.nbFrag = 0; /** No fragment */ pC->m_WriterVideoAU.stream = pC->m_pWriterVideoStream; pC->m_WriterVideoAU.attribute = AU_RAP; pC->m_WriterVideoAU.dataAddress = M4OSA_NULL; /** * If there is an audio input, allocate and fill the audio stream structures for the writer */ if(M4OSA_NULL != pC->m_pReaderAudioStream) { pC->m_pWriterAudioStream = (M4SYS_StreamDescription*)M4OSA_32bitAlignedMalloc(sizeof(M4SYS_StreamDescription), M4PTO3GPP, (M4OSA_Char *)"pWriterAudioStream"); if (M4OSA_NULL == pC->m_pWriterAudioStream) { M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterAudioStream, \ returning M4ERR_ALLOC"); return M4ERR_ALLOC; } pC->m_pWriterAudioStreamInfo = (M4WRITER_StreamAudioInfos*)M4OSA_32bitAlignedMalloc(sizeof(M4WRITER_StreamAudioInfos), M4PTO3GPP, (M4OSA_Char *)"pWriterAudioStreamInfo"); if (M4OSA_NULL == pC->m_pWriterAudioStreamInfo) { M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate \ pWriterAudioStreamInfo, returning M4ERR_ALLOC"); return M4ERR_ALLOC; } pC->m_pWriterAudioStreamInfo->nbSamplesPerSec = 0; /**< unused by our shell writer */ pC->m_pWriterAudioStreamInfo->nbBitsPerSample = 0; /**< unused by our shell writer */ pC->m_pWriterAudioStreamInfo->nbChannels = 1; /**< unused by our shell writer */ if( (M4OSA_NULL != pC->m_pReaderAudioStream) && /* audio could have been discarded */ (M4OSA_NULL != pC->m_pReaderAudioStream->m_basicProperties.m_pDecoderSpecificInfo) ) { /* If we copy the stream from the input, we copy its DSI */ pC->m_pWriterAudioStreamInfo->Header.Size = pC->m_pReaderAudioStream->m_basicProperties.m_decoderSpecificInfoSize; pC->m_pWriterAudioStreamInfo->Header.pBuf = (M4OSA_MemAddr8)pC->m_pReaderAudioStream->m_basicProperties.m_pDecoderSpecificInfo; } else { /* Writer will put a default DSI */ pC->m_pWriterAudioStreamInfo->Header.Size = 0; pC->m_pWriterAudioStreamInfo->Header.pBuf = M4OSA_NULL; } /** * Add the audio stream */ switch (pC->m_pReaderAudioStream->m_basicProperties.m_streamType) { case M4DA_StreamTypeAudioAmrNarrowBand: pC->m_pWriterAudioStream->streamType = M4SYS_kAMR; break; case M4DA_StreamTypeAudioAac: pC->m_pWriterAudioStream->streamType = M4SYS_kAAC; break; case M4DA_StreamTypeAudioEvrc: pC->m_pWriterAudioStream->streamType = M4SYS_kEVRC; break; default: M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unhandled audio format (0x%x),\ returning ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE", pC->m_pReaderAudioStream->m_basicProperties.m_streamType); return ERR_PTO3GPP_UNDEFINED_OUTPUT_AUDIO_FORMAT; } /* * Fill Audio stream description structure for the AddStream method */ pC->m_pWriterAudioStream->streamID = M4PTO3GPP_WRITER_AUDIO_STREAM_ID; pC->m_pWriterAudioStream->duration = 0;/**< Duration is not known yet */ pC->m_pWriterAudioStream->timeScale = M4PTO3GPP_WRITER_AUDIO_AMR_TIME_SCALE; pC->m_pWriterAudioStream->profileLevel = M4PTO3GPP_WRITER_AUDIO_PROFILE_LEVEL; pC->m_pWriterAudioStream->averageBitrate = pC->m_pReaderAudioStream->m_basicProperties.m_averageBitRate; pC->m_pWriterAudioStream->maxBitrate = pC->m_pWriterAudioStream->averageBitrate; /** * Our writer shell interface is a little tricky: we put M4WRITER_StreamAudioInfos \ in the DSI pointer... */ pC->m_pWriterAudioStream->decoderSpecificInfo = (M4OSA_MemAddr32)pC->m_pWriterAudioStreamInfo; /** * Update AU properties for audio stream */ pC->m_WriterAudioAU.CTS = pC->m_WriterAudioAU.DTS = 0; /** Reset time */ pC->m_WriterAudioAU.size = 0; pC->m_WriterAudioAU.frag = M4OSA_NULL; pC->m_WriterAudioAU.nbFrag = 0; /** No fragment */ pC->m_WriterAudioAU.stream = pC->m_pWriterAudioStream; pC->m_WriterAudioAU.attribute = AU_RAP; pC->m_WriterAudioAU.dataAddress = M4OSA_NULL; } /************************************/ /******** Video Encoder Init ********/ /************************************/ /** * PTO uses its own bitrate regulation, not the "true" core regulation */ EncParams.bInternalRegulation = M4OSA_TRUE; //M4OSA_FALSE; EncParams.uiStartingQuantizerValue = M4PTO3GPP_QUANTIZER_STEP; EncParams.videoProfile = pC->m_Params.videoProfile; EncParams.videoLevel = pC->m_Params.videoLevel; /** * Other encoder settings */ EncParams.uiHorizontalSearchRange = 0; /* use default */ EncParams.uiVerticalSearchRange = 0; /* use default */ EncParams.bErrorResilience = M4OSA_FALSE; /* no error resilience */ EncParams.uiIVopPeriod = 15; /* use default */ EncParams.uiMotionEstimationTools = 0; /* M4V_MOTION_EST_TOOLS_ALL */ EncParams.bAcPrediction = M4OSA_TRUE; /* use AC prediction */ EncParams.bDataPartitioning = M4OSA_FALSE; /* no data partitioning */ /** * Create video encoder */ err = pC->m_pEncoderInt->pFctInit(&pC->m_pMp4EncoderContext, pC->m_pWriterDataInt, M4PTO3GPP_applyVPP, pC, pC->m_pEncoderExternalAPI, pC->m_pEncoderUserData); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctInit returns 0x%x", err); return err; } pC->m_eEncoderState = M4PTO3GPP_kEncoderClosed; err = pC->m_pEncoderInt->pFctOpen(pC->m_pMp4EncoderContext, &pC->m_WriterVideoAU, &EncParams); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctOpen returns 0x%x", err); return err; } pC->m_eEncoderState = M4PTO3GPP_kEncoderStopped; if (M4OSA_NULL != pC->m_pEncoderInt->pFctStart) { err = pC->m_pEncoderInt->pFctStart(pC->m_pMp4EncoderContext); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctStart returns 0x%x", err); return err; } } pC->m_eEncoderState = M4PTO3GPP_kEncoderRunning; /** * No more setoption on "M4ENCODER_kVideoFragmentSize" here. * It is now automaticly and "smartly" set in the encoder shell. */ /**************************************/ /******** 3GP out add streams ********/ /**************************************/ err = pC->m_pWriterGlobInt->pFctAddStream(pC->m_p3gpWriterContext, pC->m_pWriterVideoStream); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctAddStream(video) returns\ 0x%x", err); return err; } /** * Set video max au size */ optionValue.streamID = M4PTO3GPP_WRITER_VIDEO_STREAM_ID; optionValue.value = (M4OSA_UInt32)(1.5F * (M4OSA_Float)(pC->m_pWriterVideoStreamInfo->width * pC->m_pWriterVideoStreamInfo->height) * M4PTO3GPP_VIDEO_MIN_COMPRESSION_RATIO); M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing,M4WRITER_kMaxAUSize: %u",optionValue.value); err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxAUSize,(M4OSA_DataOption) &optionValue); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(video,\ M4WRITER_kMaxAUSize) returns 0x%x", err); return err; } /** * Set video max chunck size */ optionValue.value = (M4OSA_UInt32)((M4OSA_Float)optionValue.value * M4PTO3GPP_VIDEO_AU_SIZE_TO_CHUNCK_SIZE_RATIO); M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing,M4WRITER_kMaxChunckSize: %u",optionValue.value); err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxChunckSize,(M4OSA_DataOption) &optionValue); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(video,\ M4WRITER_kMaxChunckSize) returns 0x%x", err); return err; } if (M4OSA_NULL != pC->m_pReaderAudioStream) { err = pC->m_pWriterGlobInt->pFctAddStream(pC->m_p3gpWriterContext, pC->m_pWriterAudioStream); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctAddStream(audio) \ returns 0x%x", err); return err; } /** * Set audio max au size */ optionValue.value = M4PTO3GPP_AUDIO_MAX_AU_SIZE; optionValue.streamID = M4PTO3GPP_WRITER_AUDIO_STREAM_ID; err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxAUSize,(M4OSA_DataOption) &optionValue); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(audio,\ M4WRITER_kMaxAUSize) returns 0x%x", err); return err; } /** * Set audio max chunck size */ optionValue.value = M4PTO3GPP_AUDIO_MAX_CHUNK_SIZE; /**< Magical */ err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, (M4OSA_UInt32)M4WRITER_kMaxChunckSize,(M4OSA_DataOption) &optionValue); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(audio,\ M4WRITER_kMaxChunckSize) returns 0x%x", err); return err; } } /* * Close the stream registering in order to be ready to write data */ err = pC->m_pWriterGlobInt->pFctStartWriting(pC->m_p3gpWriterContext); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctStartWriting returns 0x%x", err); return err; } M4OSA_TRACE3_0("M4PTO3GPP_Ready4Processing: returning M4NO_ERROR"); return M4NO_ERROR; } /** ****************************************************************************** M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame(M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts) * @brief Write an AMR 12.2kbps silence FRAME into the writer * @note Mainly used to fix the 'bzz' bug... * @param pWriterDataIntInterface (IN) writer data interfaces * pWriterContext (IN/OUT)writer context * pWriterAudioAU (OUT) writer audio access unit * mtIncCts (IN) writer CTS * @return M4NO_ERROR: No error ****************************************************************************** */ static M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame(M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts) { M4OSA_ERR err; err = pWriterDataIntInterface->pStartAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID, pWriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence122Frame: pWriterDataInt->pStartAU(audio) returns \ 0x%x!", err); return err; } memcpy((void *)pWriterAudioAU->dataAddress, (void *)M4PTO3GPP_AMR_AU_SILENCE_122_FRAME, M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE); pWriterAudioAU->size = M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE; pWriterAudioAU->CTS = mtIncCts; pWriterAudioAU->nbFrag = 0; err = pWriterDataIntInterface->pProcessAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID, pWriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence122Frame: pWriterDataInt->pProcessAU(silence) \ returns 0x%x!", err); return err; } return M4NO_ERROR; } /** ****************************************************************************** M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts) * @brief Write an AMR 12.2kbps silence FRAME into the writer * @note Mainly used to fix the 'bzz' bug... * @param pWriterDataIntInterface (IN) writer data interfaces * pWriterContext (IN/OUT)writer context * pWriterAudioAU (OUT) writer audio access unit * mtIncCts (IN) writer CTS * @return M4NO_ERROR: No error ****************************************************************************** */ static M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(M4WRITER_DataInterface* pWriterDataIntInterface, M4WRITER_Context* pWriterContext, M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts) { M4OSA_ERR err; err = pWriterDataIntInterface->pStartAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID, pWriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence048Frame: pWriterDataInt->pStartAU(audio)\ returns 0x%x!", err); return err; } memcpy((void *)pWriterAudioAU->dataAddress, (void *)M4PTO3GPP_AMR_AU_SILENCE_048_FRAME, M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE); pWriterAudioAU->size = M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE; pWriterAudioAU->CTS = mtIncCts; pWriterAudioAU->nbFrag = 0; err = pWriterDataIntInterface->pProcessAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID, pWriterAudioAU); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence048Frame: \ pWriterDataInt->pProcessAU(silence) returns 0x%x!", err); return err; } return M4NO_ERROR; }