| /* |
| * 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_InternalTypes.h |
| * @brief This file contains all enum and types not visible to the external world. |
| * @note |
| ****************************************************************************** |
| */ |
| |
| |
| #ifndef __M4VSS3GPP_INTERNALTYPES_H__ |
| #define __M4VSS3GPP_INTERNALTYPES_H__ |
| |
| #define M4VSS_VERSION_MAJOR 3 |
| #define M4VSS_VERSION_MINOR 2 |
| #define M4VSS_VERSION_REVISION 5 |
| |
| #include "NXPSW_CompilerSwitches.h" |
| |
| /** |
| * VSS public API and types */ |
| #include "M4VSS3GPP_API.h" |
| |
| /** |
| * Internally used modules */ |
| #include "M4READER_Common.h" /**< Reader common interface */ |
| #include "M4WRITER_common.h" /**< Writer common interface */ |
| #include "M4DECODER_Common.h" /**< Decoder common interface */ |
| #include "M4ENCODER_common.h" /**< Encoder common interface */ |
| #include "M4VIFI_FiltersAPI.h" /**< Image planes definition */ |
| #include "M4READER_3gpCom.h" /**< Read 3GPP file */ |
| #include "M4AD_Common.h" /**< Decoder audio */ |
| #include "M4ENCODER_AudioCommon.h" /**< Encode audio */ |
| |
| |
| #include "SSRC.h" /**< SSRC */ |
| #include "From2iToMono_16.h" /**< Stereo to Mono */ |
| #include "MonoTo2I_16.h" /**< Mono to Stereo */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #define WINDOW_SIZE 10 |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_EditState |
| * @brief Main state machine of the VSS 3GPP edit operation. |
| ****************************************************************************** |
| */ |
| |
| typedef enum |
| { |
| M4VSS3GPP_kEditState_CREATED = 0, /**< M4VSS3GPP_editInit has been called */ |
| M4VSS3GPP_kEditState_VIDEO = 1, /**< Processing video track */ |
| M4VSS3GPP_kEditState_AUDIO = 2, /**< Processing audio track */ |
| M4VSS3GPP_kEditState_MP3 = 3, /**< Processing MP3 audio track */ |
| M4VSS3GPP_kEditState_MP3_JUMP = 4, /**< Processing a jump in a MP3 audio track */ |
| M4VSS3GPP_kEditState_FINISHED = 5, /**< Processing done, VSS 3GPP can be closed */ |
| M4VSS3GPP_kEditState_CLOSED = 6 /**< Output file has been closed, |
| VSS 3GPP can be destroyed */ |
| } |
| M4VSS3GPP_EditState; |
| |
| typedef enum |
| { |
| /**< Doing Read/Write operation. This operation will have no processing |
| * on input frames. Only time stamp manipulations in output file. */ |
| M4VSS3GPP_kEditVideoState_READ_WRITE = 10, |
| /**< Decode encode to create an I frame. This is done for a single frame |
| * to create a new reference frame. */ |
| M4VSS3GPP_kEditVideoState_BEGIN_CUT = 11, |
| /**< Doing Read->Decode->Filter->Encode->Write operation on the input file |
| * to create the output file. */ |
| M4VSS3GPP_kEditVideoState_DECODE_ENCODE = 12, |
| /**< Applied when Transition is active and blending of two videos is |
| * required. */ |
| M4VSS3GPP_kEditVideoState_TRANSITION = 13, |
| /**< Special Read/Write mode used after BEGIN_CUT state. The frame |
| * is already coded as I frame in BEGIN_CUT state; so skip it. */ |
| M4VSS3GPP_kEditVideoState_AFTER_CUT = 14 |
| } |
| M4VSS3GPP_EditVideoState; |
| |
| typedef enum |
| { |
| M4VSS3GPP_kEditAudioState_READ_WRITE = 20, /**< Doing Read/Write operation |
| (no decoding/encoding) */ |
| M4VSS3GPP_kEditAudioState_DECODE_ENCODE = 21, /**< Doing Read-Decode/Filter/ |
| Encode-Write operation */ |
| M4VSS3GPP_kEditAudioState_TRANSITION = 22 /**< Transition; blending of two audio */ |
| } |
| M4VSS3GPP_EditAudioState; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_ClipStatus |
| * @brief Status of the clip. |
| ****************************************************************************** |
| */ |
| typedef enum |
| { |
| M4VSS3GPP_kClipStatus_READ = 0, /**< The clip is currently ready for reading */ |
| M4VSS3GPP_kClipStatus_DECODE = 1, /**< The clip is currently ready for decoding */ |
| M4VSS3GPP_kClipStatus_DECODE_UP_TO = 2 /**< The clip is currently in splitted |
| decodeUpTo() processing */ |
| } |
| M4VSS3GPP_ClipStatus; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_ClipCurrentEffect |
| * @brief Current effect applied to the clip. |
| ****************************************************************************** |
| */ |
| typedef enum |
| { |
| M4VSS3GPP_kClipCurrentEffect_NONE = 0, /**< None */ |
| M4VSS3GPP_kClipCurrentEffect_BEGIN = 1, /**< Begin effect currently applied */ |
| M4VSS3GPP_kClipCurrentEffect_END = 2 /**< End effect currently applied */ |
| } |
| M4VSS3GPP_ClipCurrentEffect; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_AudioMixingState |
| * @brief Main state machine of the VSS audio mixing operation. |
| ****************************************************************************** |
| */ |
| typedef enum |
| { |
| M4VSS3GPP_kAudioMixingState_VIDEO = 0, /**< Video is being processed */ |
| M4VSS3GPP_kAudioMixingState_AUDIO_FIRST_SEGMENT, /**< Audio is being processed */ |
| M4VSS3GPP_kAudioMixingState_AUDIO_SECOND_SEGMENT, /**< Audio is being processed */ |
| M4VSS3GPP_kAudioMixingState_AUDIO_THIRD_SEGMENT, /**< Audio is being processed */ |
| M4VSS3GPP_kAudioMixingState_FINISHED /**< Processing finished, user must now |
| call M4VSS3GPP_audioMixingCleanUp*/ |
| } |
| M4VSS3GPP_AudioMixingState; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_ExtractPictureState |
| * @brief Main state machine of the VSS picture extraction. |
| ****************************************************************************** |
| */ |
| typedef enum |
| { |
| M4VSS3GPP_kExtractPictureState_OPENED = 0, /**< Video clip is opened and ready to be read |
| until the RAP before the picture to extract */ |
| M4VSS3GPP_kExtractPictureState_PROCESS = 1, /**< Video is decoded from the previous RAP |
| to the picture to extract */ |
| M4VSS3GPP_kExtractPictureState_EXTRACTED= 2 /**< Video AU has been decoded, user must now |
| call M4VSS3GPP_extractPictureCleanUp */ |
| } |
| M4VSS3GPP_ExtractPictureState; |
| |
| |
| /** |
| ****************************************************************************** |
| * @brief Codecs registration same as in VPS and VES, so less mapping |
| * is required toward VSS api types |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| M4WRITER_GlobalInterface* pGlobalFcts; /**< open, close, setoption,etc... functions */ |
| M4WRITER_DataInterface* pDataFcts; /**< data manipulation functions */ |
| } M4VSS3GPP_WriterInterface; |
| /** |
| ****************************************************************************** |
| * struct AAC_DEC_STREAM_PROPS |
| * @brief AAC Stream properties |
| * @Note aNoChan and aSampFreq are used for parsing even the user parameters |
| * are different. User parameters will be input for the output behaviour |
| * of the decoder whereas for parsing bitstream properties are used. |
| ****************************************************************************** |
| */ |
| typedef struct { |
| M4OSA_Int32 aAudioObjectType; /**< Audio object type of the stream - in fact |
| the type found in the Access Unit parsed */ |
| M4OSA_Int32 aNumChan; /**< number of channels (=1(mono) or =2(stereo)) |
| as indicated by input bitstream*/ |
| M4OSA_Int32 aSampFreq; /**< sampling frequency in Hz */ |
| M4OSA_Int32 aExtensionSampFreq; /**< extended sampling frequency in Hz, = 0 is |
| no extended frequency */ |
| M4OSA_Int32 aSBRPresent; /**< presence=1/absence=0 of SBR */ |
| M4OSA_Int32 aPSPresent; /**< presence=1/absence=0 of PS */ |
| M4OSA_Int32 aMaxPCMSamplesPerCh; /**< max number of PCM samples per channel */ |
| } AAC_DEC_STREAM_PROPS; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum M4VSS3GPP_MediaAndCodecCtxt |
| * @brief Filesystem and codec registration function pointers |
| ****************************************************************************** |
| */ |
| typedef struct { |
| /** |
| * Media and Codec registration */ |
| /**< Table of M4VES_WriterInterface structures for avalaible Writers list */ |
| M4VSS3GPP_WriterInterface WriterInterface[M4WRITER_kType_NB]; |
| /**< open, close, setoption,etc... functions of the used writer*/ |
| M4WRITER_GlobalInterface* pWriterGlobalFcts; |
| /**< data manipulation functions of the used writer */ |
| M4WRITER_DataInterface* pWriterDataFcts; |
| |
| /**< Table of M4ENCODER_GlobalInterface structures for avalaible encoders list */ |
| M4ENCODER_GlobalInterface* pVideoEncoderInterface[M4ENCODER_kVideo_NB]; |
| /**< Functions of the used encoder */ |
| M4ENCODER_GlobalInterface* pVideoEncoderGlobalFcts; |
| |
| M4OSA_Void* pVideoEncoderExternalAPITable[M4ENCODER_kVideo_NB]; |
| M4OSA_Void* pCurrentVideoEncoderExternalAPI; |
| M4OSA_Void* pVideoEncoderUserDataTable[M4ENCODER_kVideo_NB]; |
| M4OSA_Void* pCurrentVideoEncoderUserData; |
| |
| /**< Table of M4ENCODER_AudioGlobalInterface structures for avalaible encoders list */ |
| M4ENCODER_AudioGlobalInterface* pAudioEncoderInterface[M4ENCODER_kAudio_NB]; |
| /**< Table of internal/external flags for avalaible encoders list */ |
| M4OSA_Bool pAudioEncoderFlag[M4ENCODER_kAudio_NB]; |
| /**< Functions of the used encoder */ |
| M4ENCODER_AudioGlobalInterface* pAudioEncoderGlobalFcts; |
| |
| M4READER_GlobalInterface* m_pReaderGlobalItTable[M4READER_kMediaType_NB]; |
| M4READER_DataInterface* m_pReaderDataItTable[M4READER_kMediaType_NB]; |
| M4READER_GlobalInterface* m_pReader; |
| M4READER_DataInterface* m_pReaderDataIt; |
| M4OSA_UInt8 m_uiNbRegisteredReaders; |
| |
| M4DECODER_VideoInterface* m_pVideoDecoder; |
| M4DECODER_VideoInterface* m_pVideoDecoderItTable[M4DECODER_kVideoType_NB]; |
| M4OSA_UInt8 m_uiNbRegisteredVideoDec; |
| #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS |
| M4OSA_Void* m_pCurrentVideoDecoderUserData; |
| M4OSA_Void* m_pVideoDecoderUserDataTable[M4DECODER_kVideoType_NB]; |
| #endif |
| |
| M4AD_Interface* m_pAudioDecoder; |
| M4AD_Interface* m_pAudioDecoderItTable[M4AD_kType_NB]; |
| /**< store indices of external decoders */ |
| M4OSA_Bool m_pAudioDecoderFlagTable[M4AD_kType_NB]; |
| |
| M4OSA_Void* pAudioEncoderUserDataTable[M4ENCODER_kAudio_NB]; |
| M4OSA_Void* pCurrentAudioEncoderUserData; |
| |
| M4OSA_Void* pAudioDecoderUserDataTable[M4AD_kType_NB]; |
| M4OSA_Void* pCurrentAudioDecoderUserData; |
| |
| #ifdef M4VSS_SUPPORT_OMX_CODECS |
| /* boolean to tell whether registered external OMX codecs should be freed during cleanup |
| or new codec registration*/ |
| M4OSA_Bool bAllowFreeingOMXCodecInterface; |
| #endif |
| |
| |
| } M4VSS3GPP_MediaAndCodecCtxt; |
| |
| |
| /** |
| ****************************************************************************** |
| * structure M4VSS3GPP_ClipContext |
| * @brief This structure contains informations related to one 3GPP clip (private) |
| * @note This structure is used to store the context related to one clip |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| M4VSS3GPP_ClipSettings* pSettings; /**< Pointer to the clip settings |
| (not possessed) */ |
| |
| M4VSS3GPP_ClipStatus Vstatus; /**< Video status of the clip reading */ |
| M4VSS3GPP_ClipStatus Astatus; /**< Audio status of the clip reading */ |
| |
| M4OSA_Int32 iVoffset; /**< [Milliseconds] Offset between the |
| clip and the output video stream |
| (begin cut taken into account) */ |
| M4OSA_Int32 iAoffset; /**< [Timescale] Offset between the clip |
| and the output audio stream (begin |
| cut taken into account) */ |
| |
| /** |
| * 3GPP reader Stuff */ |
| M4OSA_FileReadPointer* pFileReadPtrFct; |
| M4OSA_Context pReaderContext; /**< Context of the 3GPP reader module */ |
| M4_VideoStreamHandler* pVideoStream; /**< Description of the read video stream */ |
| M4_AudioStreamHandler* pAudioStream; /**< Description of the read audio stream */ |
| M4_AccessUnit VideoAU; /**< Read video access unit (we do not use a |
| pointer to allocate later, because |
| most of the time we will need it) */ |
| M4_AccessUnit AudioAU; /**< Read audio access unit (we do not use a |
| pointer to allocate later, because most |
| of the time we will need it) */ |
| M4OSA_Bool bVideoAuAvailable; /**< Tell if a video AU is available |
| (previously read) */ |
| /**< Boolean only used to fix the BZZ bug... */ |
| M4OSA_Bool bFirstAuWritten; |
| |
| /** |
| * Video decoder stuff */ |
| M4OSA_Context pViDecCtxt; /**< Video decoder context */ |
| M4OSA_Int32 iVideoDecCts; /**< [Milliseconds] For video decodeUpTo(), |
| the actual reached cts */ |
| M4OSA_Int32 iVideoRenderCts; /**< [Milliseconds] For video render(), |
| the actual reached cts */ |
| M4OSA_Bool isRenderDup; /**< To handle duplicate frame rendering in |
| case of external decoding */ |
| M4VIFI_ImagePlane* lastDecodedPlane; /**< Last decoded plane */ |
| |
| /** |
| * MPEG4 time info stuff at clip level */ |
| M4OSA_Bool bMpeg4GovState; /**< Namely, update or initialization */ |
| M4OSA_UInt32 uiMpeg4PrevGovValueGet; /**< Previous Gov value read (in second) */ |
| M4OSA_UInt32 uiMpeg4PrevGovValueSet; /**< Previous Gov value write (in second) */ |
| |
| /** |
| * Time-line stuff */ |
| /**< [Milliseconds] CTS at which the video clip actually starts */ |
| M4OSA_Int32 iActualVideoBeginCut; |
| /**< [Milliseconds] CTS at which the audio clip actually starts */ |
| M4OSA_Int32 iActualAudioBeginCut; |
| /**< [Milliseconds] Time at which the clip must end */ |
| M4OSA_Int32 iEndTime; |
| |
| /** |
| * Audio decoder stuff */ |
| M4OSA_Context pAudioDecCtxt; /**< Context of the AMR decoder */ |
| M4AD_Buffer AudioDecBufferIn; /**< Input structure for the audio decoder */ |
| M4AD_Buffer AudioDecBufferOut; /**< Buffer for the decoded PCM data */ |
| AAC_DEC_STREAM_PROPS AacProperties; /**< Structure for new api to get AAC |
| properties */ |
| |
| /** |
| * Audio AU to Frame split stuff */ |
| M4OSA_Bool bAudioFrameAvailable; /**< True if an audio frame is available */ |
| M4OSA_MemAddr8 pAudioFramePtr; /**< Pointer to the Audio frame */ |
| M4OSA_UInt32 uiAudioFrameSize; /**< Size of the audio frame available */ |
| M4OSA_Int32 iAudioFrameCts; /**< [Timescale] CTS of the audio frame |
| available */ |
| |
| /** |
| * Silence frame stuff */ |
| /**< Size to reserve to store a pcm full of zeros compatible with master clip stream type */ |
| M4OSA_UInt32 uiSilencePcmSize; |
| /**< Pointer to silence frame data compatible with master clip stream type */ |
| M4OSA_UInt8* pSilenceFrameData; |
| /**< Size of silence frame data compatible with master clip stream type */ |
| M4OSA_UInt32 uiSilenceFrameSize; |
| /**< [Timescale] Duration of silence frame data compatible with master clip stream type */ |
| M4OSA_Int32 iSilenceFrameDuration; |
| M4OSA_Double scale_audio; /**< frequency / 1000.0 */ |
| |
| /** |
| * Interfaces of the used modules */ |
| /**< Filesystem and shell reader, decoder functions */ |
| M4VSS3GPP_MediaAndCodecCtxt ShellAPI; |
| M4VIFI_ImagePlane *pPlaneYuv; /* YUV420 image plane, converted from ARGB888 */ |
| M4VIFI_ImagePlane* m_pPreResizeFrame; /* The decoded image before resize |
| (allocated only if resize needed)*/ |
| M4VIFI_ImagePlane *pPlaneYuvWithEffect; /* YUV420 image plane, with color effect */ |
| M4OSA_Bool bGetYuvDataFromDecoder; /* Boolean used to get YUV data from dummy video decoder only for first time */ |
| } M4VSS3GPP_ClipContext; |
| |
| |
| /** |
| ****************************************************************************** |
| * enum anonymous enum |
| * @brief enum to keep track of the encoder state |
| ****************************************************************************** |
| */ |
| enum |
| { |
| M4VSS3GPP_kNoEncoder, |
| M4VSS3GPP_kEncoderClosed, |
| M4VSS3GPP_kEncoderStopped, |
| M4VSS3GPP_kEncoderRunning |
| }; |
| |
| /** |
| ****************************************************************************** |
| * structure M4VSS3GPP_AudioVideoContext |
| * @brief This structure defines the audio video context (private) |
| * @note This structure is used for all audio/video, encoding/writing operations. |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| /** |
| * Timing Stuff */ |
| // Decorrelate input and output encoding timestamp to handle encoder prefetch |
| /**< [Milliseconds] Duration of the output file, used for progress computation */ |
| M4OSA_Double dInputVidCts; |
| /**< [Milliseconds] Current CTS of the video output stream */ |
| M4OSA_Double dOutputVidCts; |
| /**< [Milliseconds] Current CTS of the audio output stream */ |
| M4OSA_Double dATo; |
| /**< [Milliseconds] Duration of the output file, used for progress computation */ |
| M4OSA_Int32 iOutputDuration; |
| |
| /** |
| * Output Video Stream Stuff */ |
| M4SYS_StreamType VideoStreamType; /**< Output video codec */ |
| M4OSA_Int32 outputVideoProfile; /**< Output video profile */ |
| M4OSA_Int32 outputVideoLevel; /**< Output video level */ |
| M4OSA_UInt32 uiVideoBitrate; /**< Average video bitrate of the output file, |
| computed from input bitrates, durations, |
| transitions and cuts */ |
| M4OSA_UInt32 uiVideoWidth; /**< Output image width */ |
| M4OSA_UInt32 uiVideoHeight; /**< Output image height */ |
| M4OSA_UInt32 uiVideoTimeScale; /**< Time scale to use for the encoding |
| of the transition (if MPEG-4) */ |
| M4OSA_Bool bVideoDataPartitioning; /**< Data partitioning to use for the |
| encoding of the transition |
| (if MPEG-4) */ |
| M4OSA_MemAddr8 pVideoOutputDsi; /**< Decoder Specific Info of the output |
| MPEG-4 track */ |
| M4OSA_UInt16 uiVideoOutputDsiSize; /**< Size of the Decoder Specific Info |
| of the output MPEG-4 track */ |
| /** |
| * Output Audio Stream Stuff */ |
| M4SYS_StreamType AudioStreamType; /**< Type of the output audio stream */ |
| M4OSA_UInt32 uiNbChannels; /**< Number of channels in the output |
| stream (1=mono, 2=stereo) */ |
| M4OSA_UInt32 uiAudioBitrate; /**< Audio average bitrate (in bps) */ |
| M4OSA_UInt32 uiSamplingFrequency; /**< Sampling audio frequency (8000 for |
| amr, 16000 or more for aac) */ |
| M4OSA_MemAddr8 pAudioOutputDsi; /**< Decoder Specific Info of the |
| output audio track */ |
| M4OSA_UInt16 uiAudioOutputDsiSize; /**< Size of the Decoder Specific Info |
| of the output audio track */ |
| |
| /** |
| * Audio Encoder stuff */ |
| M4OSA_Context pAudioEncCtxt; /**< Context of the audio encoder */ |
| M4ENCODER_AudioDecSpecificInfo pAudioEncDSI; /**< Decoder specific info built by the |
| encoder */ |
| M4ENCODER_AudioParams AudioEncParams; /**< Config of the audio encoder */ |
| |
| /** |
| * Silence frame stuff */ |
| M4OSA_UInt32 uiSilencePcmSize; /**< Size to reserve to store a pcm full |
| of zeros compatible with master clip |
| stream type */ |
| M4OSA_UInt8* pSilenceFrameData; /**< Pointer to silence frame data |
| compatible with master clip |
| stream type */ |
| M4OSA_UInt32 uiSilenceFrameSize; /**< Size of silence frame data compatible |
| with master clip stream type */ |
| M4OSA_Int32 iSilenceFrameDuration; /**< [Timescale] Duration of silence frame |
| data compatible with master clip |
| stream type */ |
| M4OSA_Double scale_audio; /**< frequency / 1000.0 */ |
| |
| /** |
| * Video Encoder stuff */ |
| M4ENCODER_Context pEncContext; /**< Context of the encoder */ |
| M4WRITER_DataInterface OurWriterDataInterface; /**< Our own implementation of the |
| writer interface, to give to |
| the encoder shell */ |
| M4OSA_MemAddr32 pDummyAuBuffer; /**< Buffer given to the encoder for |
| it to write AUs we don't want |
| in the output */ |
| M4OSA_Int32 iMpeg4GovOffset; /**< Clip GOV offset in ms between |
| video and system time */ |
| M4OSA_ERR VppError; /**< Error for VPP are masked by Video |
| Encoder, so we must remember it */ |
| M4OSA_UInt32 encoderState; |
| |
| /** |
| * Writer stuff */ |
| M4WRITER_Context p3gpWriterContext; /**< Context of the 3GPP writer module */ |
| M4SYS_StreamDescription WriterVideoStream; /**< Description of the written |
| video stream */ |
| M4SYS_StreamDescription WriterAudioStream; /**< Description of the written |
| audio stream */ |
| M4WRITER_StreamVideoInfos WriterVideoStreamInfo; /**< Video properties of the written |
| video stream */ |
| M4WRITER_StreamAudioInfos WriterAudioStreamInfo; /**< Audio properties of the written |
| audio stream */ |
| M4SYS_AccessUnit WriterVideoAU; /**< Written video access unit */ |
| M4SYS_AccessUnit WriterAudioAU; /**< Written audio access unit */ |
| M4OSA_UInt32 uiVideoMaxAuSize; /**< Max AU size set to the writer |
| for the video */ |
| M4OSA_UInt32 uiAudioMaxAuSize; /**< Max AU size set to the writer |
| for the audio */ |
| M4OSA_UInt32 uiOutputAverageVideoBitrate; /**< Average video bitrate of the |
| output file, computed from |
| input bitrates, durations, |
| transitions and cuts */ |
| |
| } M4VSS3GPP_EncodeWriteContext; |
| |
| |
| /** |
| ****************************************************************************** |
| * structure M4VSS3GPP_InternalEditContext |
| * @brief This structure defines the edit VSS context (private) |
| * @note This structure is used for all VSS edit operations to store the context |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| /** |
| * VSS 3GPP main variables */ |
| M4VSS3GPP_EditState State; /**< VSS internal state */ |
| M4VSS3GPP_EditVideoState Vstate; |
| M4VSS3GPP_EditAudioState Astate; |
| |
| /** |
| * User Settings (copied, thus owned by VSS3GPP) */ |
| M4OSA_UInt8 uiClipNumber; /**< Number of element of the clip |
| list pClipList. */ |
| M4VSS3GPP_ClipSettings *pClipList; /**< List of the input clips settings |
| Array of uiClipNumber clip settings */ |
| M4VSS3GPP_TransitionSettings *pTransitionList; /**< List of the transition settings. |
| Array of uiClipNumber-1 transition settings */ |
| M4VSS3GPP_EffectSettings *pEffectsList; /**< List of the effects settings. |
| Array of nbEffects RC */ |
| M4OSA_UInt8 *pActiveEffectsList; /**< List of the active effects |
| settings. Array of nbEffects RC */ |
| M4OSA_UInt8 nbEffects; /**< Numbers of effects RC */ |
| M4OSA_UInt8 nbActiveEffects; /**< Numbers of active effects RC */ |
| |
| /** |
| * Input Stuff */ |
| M4OSA_UInt8 uiCurrentClip; /**< Index of the current clip 1 in |
| the input clip list */ |
| M4VSS3GPP_ClipContext* pC1; /**< Context of the current clip 1 */ |
| M4VSS3GPP_ClipContext* pC2; /**< Context of the current clip 2 */ |
| |
| /** |
| * Decoder stuff */ |
| M4OSA_Double dOutputFrameDuration; /**< [Milliseconds] directly related to |
| output frame rate */ |
| M4VIFI_ImagePlane yuv1[3]; /**< First temporary YUV420 image plane */ |
| M4VIFI_ImagePlane yuv2[3]; /**< Second temporary YUV420 image plane */ |
| M4VIFI_ImagePlane yuv3[3]; /**< Third temporary YUV420 image plane RC */ |
| M4VIFI_ImagePlane yuv4[3]; /**< Fourth temporary YUV420 image plane RC */ |
| |
| /** |
| * Effect stuff */ |
| M4OSA_Bool bClip1AtBeginCut; /**< [Milliseconds] The clip1 is at |
| its begin cut */ |
| M4OSA_Int8 iClip1ActiveEffect; /**< The index of the active effect |
| on Clip1 (<0 means none) |
| (used for video and audio but |
| not simultaneously) */ |
| M4OSA_Int8 iClip2ActiveEffect; /**< The index of the active effect |
| on Clip2 (<0 means none) |
| (used for video and audio but |
| not simultaneously) */ |
| M4OSA_Bool bTransitionEffect; /**< True if the transition effect |
| must be applied at the current |
| time */ |
| |
| /** |
| * Encoding and Writing operations */ |
| M4OSA_Bool bSupportSilence; /**< Flag to know if the output stream can |
| support silence (even if not editable, |
| for example AAC+, but not EVRC) */ |
| M4VSS3GPP_EncodeWriteContext ewc; /**< Audio and video encode/write stuff */ |
| M4OSA_Bool bIsMMS; /**< Boolean used to know if we are |
| processing a file with an output |
| size constraint */ |
| M4OSA_UInt32 uiMMSVideoBitrate; /**< If in MMS mode, |
| targeted video bitrate */ |
| M4VIDEOEDITING_VideoFramerate MMSvideoFramerate; /**< If in MMS mode, |
| targeted video framerate */ |
| |
| /** |
| * Filesystem functions */ |
| M4OSA_FileReadPointer* pOsaFileReadPtr; /**< OSAL file read functions, |
| to be provided by user */ |
| M4OSA_FileWriterPointer* pOsaFileWritPtr; /**< OSAL file write functions, |
| to be provided by user */ |
| |
| /** |
| * Interfaces of the used modules */ |
| M4VSS3GPP_MediaAndCodecCtxt ShellAPI; /**< Filesystem and shell reader, |
| decoder functions */ |
| M4OSA_Bool bIssecondClip; |
| M4OSA_UInt8 *pActiveEffectsList1; /**< List of the active effects settings. Array of nbEffects RC */ |
| M4OSA_UInt8 nbActiveEffects1; /**< Numbers of active effects RC */ |
| M4OSA_Bool m_bClipExternalHasStarted; /**< Flag to indicate that an |
| external effect is active */ |
| M4OSA_Int32 iInOutTimeOffset; |
| M4OSA_Bool bEncodeTillEoF; |
| M4xVSS_EditSettings xVSS; |
| M4OSA_Context m_air_context; |
| |
| M4OSA_Bool bClip1ActiveFramingEffect; /**< Overlay flag for clip1 */ |
| M4OSA_Bool bClip2ActiveFramingEffect; /**< Overlay flag for clip2, used in transition */ |
| } M4VSS3GPP_InternalEditContext; |
| |
| |
| /** |
| ****************************************************************************** |
| * structure M4VSS3GPP_InternalAudioMixingContext |
| * @brief This structure defines the audio mixing VSS 3GPP context (private) |
| * @note This structure is used for all VSS 3GPP audio mixing operations to store |
| * the context |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| /** |
| * VSS main variables */ |
| M4VSS3GPP_AudioMixingState State; /**< VSS audio mixing internal state */ |
| |
| /** |
| * Internal copy of the input settings */ |
| M4OSA_Int32 iAddCts; /**< [Milliseconds] Time, in milliseconds, |
| at which the added audio track is |
| inserted */ |
| M4OSA_UInt32 uiBeginLoop; /**< Describes in milli-second the |
| start time of the loop */ |
| M4OSA_UInt32 uiEndLoop; /**< Describes in milli-second the end |
| time of the loop (0 means no loop) */ |
| M4OSA_Bool bRemoveOriginal; /**< If true, the original audio track |
| is not taken into account */ |
| |
| /** |
| * Input audio/video file */ |
| M4VSS3GPP_ClipSettings InputClipSettings; /**< Structure internally used to |
| manage the input 3GPP settings */ |
| M4VSS3GPP_ClipContext* pInputClipCtxt; /**< Context of the input 3GPP clip */ |
| |
| /** |
| * Added audio file stuff */ |
| M4VSS3GPP_ClipSettings AddedClipSettings; /**< Structure internally used to |
| manage the added settings */ |
| M4VSS3GPP_ClipContext* pAddedClipCtxt; /**< Context of the added 3GPP clip */ |
| |
| /** |
| * Audio stuff */ |
| M4OSA_Float fOrigFactor; /**< Factor to apply to the original |
| audio track for the mixing */ |
| M4OSA_Float fAddedFactor; /**< Factor to apply to the added |
| audio track for the mixing */ |
| M4OSA_Bool bSupportSilence; /**< Flag to know if the output stream can |
| support silence (even if not editable, |
| for example AAC+, but not EVRC) */ |
| M4OSA_Bool bHasAudio; /**< Flag to know if we have to delete |
| audio track */ |
| M4OSA_Bool bAudioMixingIsNeeded; /**< Flag to know if we have to do mixing */ |
| |
| /** |
| * Encoding and Writing operations */ |
| M4VSS3GPP_EncodeWriteContext ewc; /**< Audio and video encode/write stuff */ |
| |
| /** |
| * Filesystem functions */ |
| M4OSA_FileReadPointer* pOsaFileReadPtr; /**< OSAL file read functions, |
| to be provided by user */ |
| M4OSA_FileWriterPointer* pOsaFileWritPtr; /**< OSAL file write functions, |
| to be provided by user */ |
| |
| /** |
| * Interfaces of the used modules */ |
| M4VSS3GPP_MediaAndCodecCtxt ShellAPI; /**< Filesystem and shell reader, |
| decoder functions */ |
| |
| /** |
| * Sample Rate Convertor (SSRC) stuff (needed in case of mixing with != ASF/nb of channels) */ |
| M4OSA_Bool b_SSRCneeded; /**< If true, SSRC is needed |
| (!= ASF or nb of channels) */ |
| M4OSA_UInt8 ChannelConversion; /**< 1=Conversion from Mono to Stereo |
| 2=Stereo to Mono, 0=no conversion */ |
| SSRC_Instance_t SsrcInstance; /**< Context of the Ssrc */ |
| SSRC_Scratch_t* SsrcScratch; /**< Working memory of the Ssrc */ |
| short iSsrcNbSamplIn; /**< Number of sample the Ssrc needs as input */ |
| short iSsrcNbSamplOut; /**< Number of sample the Ssrc outputs */ |
| M4OSA_MemAddr8 pSsrcBufferIn; /**< Input of the SSRC */ |
| M4OSA_MemAddr8 pSsrcBufferOut; /**< Output of the SSRC */ |
| M4OSA_MemAddr8 pPosInSsrcBufferIn; /**< Position into the SSRC in buffer */ |
| M4OSA_MemAddr8 pPosInSsrcBufferOut;/**< Position into the SSRC out buffer */ |
| M4OSA_MemAddr8 pTempBuffer; /**< Temporary buffer */ |
| M4OSA_MemAddr8 pPosInTempBuffer; /**< Position in temporary buffer */ |
| M4OSA_UInt32 minimumBufferIn; /**< Minimum amount of decoded data to be |
| processed by SSRC and channel |
| convertor */ |
| M4OSA_Bool b_DuckingNeedeed; |
| M4OSA_Int32 InDucking_threshold; /**< Threshold value at which background |
| music shall duck */ |
| M4OSA_Float InDucking_lowVolume; /**< lower the background track to this |
| factor and increase the primary |
| track to inverse of this factor */ |
| M4OSA_Float lowVolume; |
| M4OSA_Int32 audioVolumeArray[WINDOW_SIZE]; // store peak audio vol. level |
| // for duration for WINDOW_SIZE |
| M4OSA_Int32 audVolArrIndex; |
| M4OSA_Float duckingFactor ; /**< multiply by this factor to bring |
| FADE IN/FADE OUT effect */ |
| M4OSA_Float fBTVolLevel; |
| M4OSA_Float fPTVolLevel; |
| M4OSA_Bool bDoDucking; |
| M4OSA_Bool bLoop; |
| M4OSA_Bool bNoLooping; |
| M4OSA_Context pLVAudioResampler; |
| M4OSA_Bool bjumpflag; |
| |
| } M4VSS3GPP_InternalAudioMixingContext; |
| |
| |
| /** |
| ****************************************************************************** |
| * structure M4VSS3GPP_InternalExtractPictureContext |
| * @brief This structure defines the extract picture VSS context (private) |
| * @note This structure is used for all VSS picture extractions to store the context |
| ****************************************************************************** |
| */ |
| typedef struct |
| { |
| /** |
| * VSS main variables */ |
| M4VSS3GPP_ExtractPictureState State; /**< VSS extract pictureinternal state */ |
| |
| /** |
| * Input files */ |
| M4VSS3GPP_ClipSettings ClipSettings; /**< Structure internally used to |
| manage the input 3FPP settings */ |
| M4VSS3GPP_ClipContext* pInputClipCtxt; /**< Context of the input 3GPP clip */ |
| |
| /** |
| * Settings */ |
| M4OSA_Int32 iExtractCts; /**< [Milliseconds] Cts of the AU |
| to be extracted */ |
| |
| /** |
| * Video stuff */ |
| M4VIFI_ImagePlane decPlanes[3]; /**< Decoded YUV420 picture plane */ |
| M4OSA_UInt32 uiVideoWidth; /**< Decoded image width */ |
| M4OSA_UInt32 uiVideoHeight; /**< Decoded image height */ |
| |
| /* |
| * Decoder info */ |
| M4OSA_Int32 iDecCts; /**< [Milliseconds] Decoded AU Cts */ |
| M4OSA_Bool bJumpFlag; /**< 1 if a jump has been made */ |
| M4OSA_Int32 iDeltaTime; /**< [Milliseconds] Time between previous RAP and |
| picture to extract */ |
| M4OSA_Int32 iGap; /**< [Milliseconds] Time between jump AU and |
| extraction time */ |
| M4OSA_UInt32 uiStep; /**< [Milliseconds] Progress bar time increment */ |
| |
| /** |
| * Filesystem functions */ |
| /**< OSAL file read functions, to be provided by user */ |
| M4OSA_FileReadPointer* pOsaFileReadPtr; |
| /**< OSAL file write functions, to be provided by user */ |
| M4OSA_FileWriterPointer* pOsaFileWritPtr; |
| |
| M4OSA_Bool bClipOpened; |
| } M4VSS3GPP_InternalExtractPictureContext; |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* __M4VSS3GPP_INTERNALTYPES_H__ */ |
| |
