Fix for 4132872 inefficient export logic.
Also fixes 3371103 Transitions between images takes a long time
to generate.
Redundant transcoding is removed. Decode encode will be done only
once per clip.
For images, conversion to 3gp clip is removed (except for generating
Kenburn image clip).
Change-Id: Id722cd0296641bd643eb5c63f4d8028716259c01
diff --git a/libvideoeditor/vss/src/Android.mk b/libvideoeditor/vss/src/Android.mk
index 55d78d3..11483fa 100755
--- a/libvideoeditor/vss/src/Android.mk
+++ b/libvideoeditor/vss/src/Android.mk
@@ -46,7 +46,8 @@
M4AMRR_CoreReader.c \
M4READER_Amr.c \
M4VD_Tools.c \
- VideoEditorResampler.cpp
+ VideoEditorResampler.cpp \
+ M4DECODER_Null.c
LOCAL_MODULE_TAGS := optional
diff --git a/libvideoeditor/vss/src/M4DECODER_Null.c b/libvideoeditor/vss/src/M4DECODER_Null.c
new file mode 100755
index 0000000..8a54f3d
--- /dev/null
+++ b/libvideoeditor/vss/src/M4DECODER_Null.c
@@ -0,0 +1,434 @@
+/*
+ * 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 M4DECODER_Null.c
+ * @brief Implementation of the Null decoder public interface
+ * @note This file implements a "null" video decoder, i.e. a decoder
+ * that does nothing
+*************************************************************************
+*/
+#include "NXPSW_CompilerSwitches.h"
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Debug.h"
+#include "M4TOOL_VersionInfo.h"
+#include "M4DA_Types.h"
+#include "M4DECODER_Common.h"
+#include "M4DECODER_Null.h"
+
+/**
+ ************************************************************************
+ * NULL Video Decoder version information
+ ************************************************************************
+*/
+/* CHANGE_VERSION_HERE */
+#define M4DECODER_NULL_MAJOR 1
+#define M4DECODER_NULL_MINOR 0
+#define M4DECODER_NULL_REVISION 0
+
+/**
+ ************************************************************************
+ * structure M4_VideoHandler_Context
+ * @brief Defines the internal context of a video decoder instance
+ * @note The context is allocated and freed by the video decoder
+ ************************************************************************
+*/
+typedef struct {
+ void* m_pLibrary; // Core library identifier
+ M4OSA_Int32 m_DecoderId; // Core decoder identifier
+ M4OSA_Int32 m_RendererId; // Core renderer identifier
+ M4_VideoStreamHandler* m_pVideoStreamhandler; // Video stream description
+ M4_AccessUnit* m_pNextAccessUnitToDecode; // Access unit used to
+ // read and decode one frame
+ void* m_pUserData; // Pointer to any user data
+ M4READER_DataInterface* m_pReader; // Reader data interface
+ M4OSA_Bool m_bDoRendering; // Decides if render required
+ M4OSA_Int32 m_structSize; // Size of the structure
+
+ M4DECODER_OutputFilter* m_pVideoFilter; // Color conversion filter
+ M4VIFI_ImagePlane *pDecYuvData; // Pointer to Yuv data plane
+ M4VIFI_ImagePlane *pDecYuvWithEffect; // Pointer to Yuv plane with color effect
+ M4OSA_Bool bYuvWithEffectSet; // Original Yuv data OR Yuv with color effect
+
+} M4_VideoHandler_Context;
+
+/***********************************************************************/
+/************** M4DECODER_VideoInterface implementation ****************/
+/***********************************************************************/
+
+/**
+ ************************************************************************
+ * @brief Creates an instance of the decoder
+ * @note Allocates the context
+ *
+ * @param pContext: (OUT) Context of the decoder
+ * @param pStreamHandler: (IN) Pointer to a video stream description
+ * @param pSrcInterface: (IN) Pointer to the M4READER_DataInterface
+ * structure that must be used by the
+ * decoder to read data from the stream
+ * @param pAccessUnit (IN) Pointer to an access unit
+ * (allocated by the caller) where decoded data
+ * are stored
+ *
+ * @return M4NO_ERROR There is no error
+ * @return M4ERR_STATE State automaton is not applied
+ * @return M4ERR_ALLOC A memory allocation has failed
+ * @return M4ERR_PARAMETER At least one input parameter is not proper
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_create(M4OSA_Context *pContext,
+ M4_StreamHandler *pStreamHandler,
+ M4READER_DataInterface *pReaderDataInterface,
+ M4_AccessUnit* pAccessUnit,
+ M4OSA_Void* pUserData) {
+
+ M4_VideoHandler_Context* pStreamContext = M4OSA_NULL;
+
+ *pContext = M4OSA_NULL;
+ pStreamContext = (M4_VideoHandler_Context*)M4OSA_32bitAlignedMalloc (
+ sizeof(M4_VideoHandler_Context), M4DECODER_MPEG4,
+ (M4OSA_Char *)"M4_VideoHandler_Context");
+ if (pStreamContext == 0) {
+ return M4ERR_ALLOC;
+ }
+
+ pStreamContext->m_structSize = sizeof(M4_VideoHandler_Context);
+ pStreamContext->m_pNextAccessUnitToDecode = M4OSA_NULL;
+ pStreamContext->m_pLibrary = M4OSA_NULL;
+ pStreamContext->m_pVideoStreamhandler = M4OSA_NULL;
+ pStreamContext->m_DecoderId = -1;
+ pStreamContext->m_RendererId = -1;
+
+ pStreamContext->m_pUserData = M4OSA_NULL;
+ pStreamContext->m_bDoRendering = M4OSA_TRUE;
+ pStreamContext->m_pVideoFilter = M4OSA_NULL;
+ pStreamContext->bYuvWithEffectSet = M4OSA_FALSE;
+
+ *pContext=pStreamContext;
+ return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief Destroy the instance of the decoder
+ * @note After this call the context is invalid
+ *
+ * @param context: (IN) Context of the decoder
+ *
+ * @return M4NO_ERROR There is no error
+ * @return M4ERR_PARAMETER The context is invalid
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_destroy(M4OSA_Context pContext) {
+
+ M4_VideoHandler_Context* pStreamContext = (M4_VideoHandler_Context*)pContext;
+
+ M4OSA_DEBUG_IF1((M4OSA_NULL == pStreamContext),
+ M4ERR_PARAMETER, "M4DECODER_NULL_destroy: invalid context pointer");
+
+ free(pStreamContext);
+
+ return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief Get an option value from the decoder
+ * @note This function allows the caller to retrieve a property value:
+ *
+ * @param context: (IN) Context of the decoder
+ * @param optionId: (IN) Indicates the option to get
+ * @param pValue: (IN/OUT) Pointer to structure or value where
+ * option is stored
+ *
+ * @return M4NO_ERROR There is no error
+ * @return M4ERR_PARAMETER The context is invalid (in DEBUG only)
+ * @return M4ERR_BAD_OPTION_ID When the option ID is not a valid one
+ * @return M4ERR_STATE State automaton is not applied
+ * @return M4ERR_NOT_IMPLEMENTED Function not implemented
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_getOption(M4OSA_Context context,
+ M4OSA_OptionID optionId,
+ M4OSA_DataOption pValue) {
+
+ return M4ERR_NOT_IMPLEMENTED;
+}
+
+/**
+ ************************************************************************
+ * @brief Set an option value of the decoder
+ * @note Allows the caller to set a property value:
+ *
+ * @param context: (IN) Context of the decoder
+ * @param optionId: (IN) Identifier indicating the option to set
+ * @param pValue: (IN) Pointer to structure or value
+ * where option is stored
+ *
+ * @return M4NO_ERROR There is no error
+ * @return M4ERR_BAD_OPTION_ID The option ID is not a valid one
+ * @return M4ERR_STATE State automaton is not applied
+ * @return M4ERR_PARAMETER The option parameter is invalid
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_setOption(M4OSA_Context context,
+ M4OSA_OptionID optionId,
+ M4OSA_DataOption pValue) {
+
+ M4DECODER_OutputFilter *pFilterOption;
+
+ M4_VideoHandler_Context *pStreamContext =
+ (M4_VideoHandler_Context*)context;
+
+ M4OSA_ERR err = M4NO_ERROR;
+ M4OSA_UInt32 height = 0;
+ M4OSA_UInt8 *p_src,*p_des;
+ M4VIFI_ImagePlane* pTempDecYuvData = M4OSA_NULL;
+
+ switch (optionId) {
+ case M4DECODER_kOptionID_DecYuvData:
+ pStreamContext->pDecYuvData = (M4VIFI_ImagePlane *)pValue;
+ break;
+
+ case M4DECODER_kOptionID_YuvWithEffectContiguous:
+ pStreamContext->pDecYuvWithEffect = (M4VIFI_ImagePlane *)pValue;
+ break;
+
+ case M4DECODER_kOptionID_EnableYuvWithEffect:
+ pStreamContext->bYuvWithEffectSet = (M4OSA_Bool)pValue;
+ break;
+
+ case M4DECODER_kOptionID_YuvWithEffectNonContiguous:
+ pTempDecYuvData = (M4VIFI_ImagePlane *)pValue;
+
+ p_des = pStreamContext->pDecYuvWithEffect[0].pac_data +
+ pStreamContext->pDecYuvWithEffect[0].u_topleft;
+ p_src = pTempDecYuvData[0].pac_data +
+ pTempDecYuvData[0].u_topleft;
+
+ for (height = 0; height<pStreamContext->pDecYuvWithEffect[0].u_height;
+ height++) {
+ memcpy((void *)p_des, (void *)p_src,
+ pStreamContext->pDecYuvWithEffect[0].u_width);
+
+ p_des += pStreamContext->pDecYuvWithEffect[0].u_stride;
+ p_src += pTempDecYuvData[0].u_stride;
+ }
+
+ p_des = pStreamContext->pDecYuvWithEffect[1].pac_data +
+ pStreamContext->pDecYuvWithEffect[1].u_topleft;
+ p_src = pTempDecYuvData[1].pac_data +
+ pTempDecYuvData[1].u_topleft;
+
+ for (height = 0; height<pStreamContext->pDecYuvWithEffect[1].u_height;
+ height++) {
+ memcpy((void *)p_des, (void *)p_src,
+ pStreamContext->pDecYuvWithEffect[1].u_width);
+
+ p_des += pStreamContext->pDecYuvWithEffect[1].u_stride;
+ p_src += pTempDecYuvData[1].u_stride;
+ }
+
+ p_des = pStreamContext->pDecYuvWithEffect[2].pac_data +
+ pStreamContext->pDecYuvWithEffect[2].u_topleft;
+ p_src = pTempDecYuvData[2].pac_data +
+ pTempDecYuvData[2].u_topleft;
+
+ for (height = 0; height<pStreamContext->pDecYuvWithEffect[2].u_height;
+ height++) {
+ memcpy((void *)p_des, (void *)p_src,
+ pStreamContext->pDecYuvWithEffect[2].u_width);
+
+ p_des += pStreamContext->pDecYuvWithEffect[2].u_stride;
+ p_src += pTempDecYuvData[2].u_stride;
+ }
+ break;
+
+ case M4DECODER_kOptionID_OutputFilter:
+ pFilterOption = (M4DECODER_OutputFilter*)pValue;
+ break;
+
+ case M4DECODER_kOptionID_DeblockingFilter:
+ err = M4ERR_BAD_OPTION_ID;
+ break;
+
+ default:
+ err = M4ERR_BAD_OPTION_ID;
+ break;
+ }
+ return err;
+}
+
+/**
+ ************************************************************************
+ * @brief Decode video Access Units up to a target time
+ * @note Parse and decode the video until it can output a decoded image
+ * for which the composition time is equal or greater to the
+ * passed targeted time.
+ * The data are read from the reader data interface passed to
+ * M4DECODER_MPEG4_create.
+ *
+ * @param context: (IN) Context of the decoder
+ * @param pTime: (IN/OUT) IN: Time to decode up to (in msec)
+ * OUT:Time of the last decoded frame (in msec)
+ * @param bJump: (IN) 0 if no jump occured just before this call
+ * 1 if a a jump has just been made
+ * @return M4NO_ERROR there is no error
+ * @return M4ERR_PARAMETER at least one parameter is not properly set
+ * @return M4WAR_NO_MORE_AU there is no more access unit to decode (EOS)
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_decode(M4OSA_Context context,
+ M4_MediaTime* pTime, M4OSA_Bool bJump) {
+
+ // Do nothing; input time stamp itself returned
+ return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief Renders the video at the specified time.
+ * @note
+ * @param context: (IN) Context of the decoder
+ * @param pTime: (IN/OUT) IN: Time to render to (in msecs)
+ * OUT:Time of the rendered frame (in ms)
+ * @param pOutputPlane:(OUT) Output plane filled with decoded data
+ * @param bForceRender:(IN) 1 if the image must be rendered even it
+ * has been rendered already
+ * 0 if not
+ *
+ * @return M4NO_ERROR There is no error
+ * @return M4ERR_PARAMETER At least one parameter is not properly set
+ * @return M4ERR_STATE State automaton is not applied
+ * @return M4ERR_ALLOC There is no more available memory
+ * @return M4WAR_VIDEORENDERER_NO_NEW_FRAME If the frame has already been rendered
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_render(M4OSA_Context context, M4_MediaTime* pTime,
+ M4VIFI_ImagePlane* pOutputPlane,
+ M4OSA_Bool bForceRender) {
+
+ M4OSA_ERR err = M4NO_ERROR;
+ M4OSA_UInt32 height;
+ M4OSA_UInt8 *p_src,*p_des;
+ M4_VideoHandler_Context* pStreamContext =
+ (M4_VideoHandler_Context*)context;
+
+ if (pStreamContext->bYuvWithEffectSet == M4OSA_TRUE) {
+
+ p_des = pOutputPlane[0].pac_data + pOutputPlane[0].u_topleft;
+ p_src = pStreamContext->pDecYuvWithEffect[0].pac_data +
+ pStreamContext->pDecYuvWithEffect[0].u_topleft;
+
+ for (height = 0; height<pOutputPlane[0].u_height; height++) {
+ memcpy((void *)p_des, (void *)p_src, pOutputPlane[0].u_width);
+ p_des += pOutputPlane[0].u_stride;
+ p_src += pStreamContext->pDecYuvWithEffect[0].u_stride;
+ }
+
+ p_des = pOutputPlane[1].pac_data + pOutputPlane[1].u_topleft;
+ p_src = pStreamContext->pDecYuvWithEffect[1].pac_data +
+ pStreamContext->pDecYuvWithEffect[1].u_topleft;
+
+ for (height = 0; height<pOutputPlane[1].u_height; height++) {
+ memcpy((void *)p_des, (void *)p_src, pOutputPlane[1].u_width);
+ p_des += pOutputPlane[1].u_stride;
+ p_src += pStreamContext->pDecYuvWithEffect[1].u_stride;
+ }
+
+ p_des = pOutputPlane[2].pac_data + pOutputPlane[2].u_topleft;
+ p_src = pStreamContext->pDecYuvWithEffect[2].pac_data +
+ pStreamContext->pDecYuvWithEffect[2].u_topleft;
+
+ for (height = 0; height<pOutputPlane[2].u_height; height++) {
+ memcpy((void *)p_des, (void *)p_src, pOutputPlane[2].u_width);
+ p_des += pOutputPlane[2].u_stride;
+ p_src += pStreamContext->pDecYuvWithEffect[2].u_stride;
+ }
+ } else {
+
+ p_des = pOutputPlane[0].pac_data + pOutputPlane[0].u_topleft;
+ p_src = pStreamContext->pDecYuvData[0].pac_data +
+ pStreamContext->pDecYuvData[0].u_topleft;
+
+ for (height = 0; height<pOutputPlane[0].u_height; height++) {
+ memcpy((void *)p_des, (void *)p_src, pOutputPlane[0].u_width);
+ p_des += pOutputPlane[0].u_stride;
+ p_src += pStreamContext->pDecYuvData[0].u_stride;
+ }
+
+ p_des = pOutputPlane[1].pac_data + pOutputPlane[1].u_topleft;
+ p_src = pStreamContext->pDecYuvData[1].pac_data +
+ pStreamContext->pDecYuvData[1].u_topleft;
+
+ for (height = 0; height<pOutputPlane[1].u_height; height++) {
+ memcpy((void *)p_des, (void *)p_src, pOutputPlane[1].u_width);
+ p_des += pOutputPlane[1].u_stride;
+ p_src += pStreamContext->pDecYuvData[1].u_stride;
+ }
+
+ p_des = pOutputPlane[2].pac_data + pOutputPlane[2].u_topleft;
+ p_src = pStreamContext->pDecYuvData[2].pac_data +
+ pStreamContext->pDecYuvData[2].u_topleft;
+
+ for (height = 0; height<pOutputPlane[2].u_height; height++) {
+ memcpy((void *)p_des,(void *)p_src,pOutputPlane[2].u_width);
+ p_des += pOutputPlane[2].u_stride;
+ p_src += pStreamContext->pDecYuvData[2].u_stride;
+ }
+ }
+ return err;
+}
+
+/**
+ ************************************************************************
+ * @brief Retrieves the interface implemented by the decoder
+ * @param pDecoderType : Pointer to a M4DECODER_VideoType
+ * (allocated by the caller)
+ * that will be filled with the decoder type
+ * @param pDecoderInterface : Address of a pointer that will be set to
+ * the interface implemented by this decoder.
+ * The interface is a structure allocated by
+ * this function and must be freed by the caller.
+ *
+ * @returns : M4NO_ERROR if OK
+ * M4ERR_ALLOC if allocation failed
+ ************************************************************************
+*/
+M4OSA_ERR M4DECODER_NULL_getInterface (M4DECODER_VideoType *pDecoderType,
+ M4DECODER_VideoInterface **pDecoderInterface) {
+
+ *pDecoderInterface =
+ (M4DECODER_VideoInterface*)M4OSA_32bitAlignedMalloc(
+ sizeof(M4DECODER_VideoInterface),
+ M4DECODER_MPEG4, (M4OSA_Char *)"M4DECODER_VideoInterface");
+
+ if (M4OSA_NULL == *pDecoderInterface) {
+ return M4ERR_ALLOC;
+ }
+
+ *pDecoderType = M4DECODER_kVideoTypeYUV420P;
+
+ (*pDecoderInterface)->m_pFctCreate = M4DECODER_NULL_create;
+ (*pDecoderInterface)->m_pFctDestroy = M4DECODER_NULL_destroy;
+ (*pDecoderInterface)->m_pFctGetOption = M4DECODER_NULL_getOption;
+ (*pDecoderInterface)->m_pFctSetOption = M4DECODER_NULL_setOption;
+ (*pDecoderInterface)->m_pFctDecode = M4DECODER_NULL_decode;
+ (*pDecoderInterface)->m_pFctRender = M4DECODER_NULL_render;
+
+ return M4NO_ERROR;
+}
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_Clip.c b/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
index 91ba966..0303877 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
@@ -119,6 +119,8 @@
/**
* Init the clip context */
+ pClipCtxt->iVoffset = 0;
+ pClipCtxt->iAoffset = 0;
pClipCtxt->Vstatus = M4VSS3GPP_kClipStatus_READ;
pClipCtxt->Astatus = M4VSS3GPP_kClipStatus_READ;
@@ -129,6 +131,11 @@
pClipCtxt->AudioAU.m_dataAddress = M4OSA_NULL;
pClipCtxt->pViDecCtxt = M4OSA_NULL;
+ pClipCtxt->iVideoDecCts = 0;
+ pClipCtxt->iVideoRenderCts = 0;
+ pClipCtxt->lastDecodedPlane = M4OSA_NULL;
+ pClipCtxt->iActualVideoBeginCut = 0;
+ pClipCtxt->iActualAudioBeginCut = 0;
pClipCtxt->bVideoAuAvailable = M4OSA_FALSE;
pClipCtxt->bFirstAuWritten = M4OSA_FALSE;
@@ -136,9 +143,16 @@
pClipCtxt->bAudioFrameAvailable = M4OSA_FALSE;
pClipCtxt->pAudioFramePtr = M4OSA_NULL;
+ pClipCtxt->iAudioFrameCts = 0;
+ pClipCtxt->pAudioDecCtxt = 0;
+ pClipCtxt->AudioDecBufferOut.m_bufferSize = 0;
pClipCtxt->AudioDecBufferOut.m_dataAddress = M4OSA_NULL;
pClipCtxt->pFileReadPtrFct = pFileReadPtrFct;
+ pClipCtxt->pPlaneYuv = M4OSA_NULL;
+ pClipCtxt->pPlaneYuvWithEffect = M4OSA_NULL;
+ pClipCtxt->m_pPreResizeFrame = M4OSA_NULL;
+ pClipCtxt->bGetYuvDataFromDecoder = M4OSA_TRUE;
/*
* Reset pointers for media and codecs interfaces */
@@ -161,6 +175,7 @@
M4OSA_ERR err;
M4READER_MediaFamily mediaFamily;
M4_StreamHandler *pStreamHandler;
+ M4_StreamHandler dummyStreamHandler;
M4OSA_Int32 iDuration;
M4OSA_Void *decoderUserData;
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
@@ -185,6 +200,29 @@
/**
* Keep a pointer to the clip settings. Remember that we don't possess it! */
pClipCtxt->pSettings = pClipSettings;
+ if(M4VIDEOEDITING_kFileType_ARGB8888 == pClipCtxt->pSettings->FileType) {
+ M4OSA_TRACE3_0("M4VSS3GPP_intClipOpen: Image stream; set current vid dec");
+ err = M4VSS3GPP_setCurrentVideoDecoder(
+ &pClipCtxt->ShellAPI, M4DA_StreamTypeVideoARGB8888);
+ M4ERR_CHECK_RETURN(err);
+
+ decoderUserData = M4OSA_NULL;
+
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctCreate(
+ &pClipCtxt->pViDecCtxt, &dummyStreamHandler,
+ pClipCtxt->ShellAPI.m_pReaderDataIt, &pClipCtxt->VideoAU,
+ decoderUserData);
+
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intClipOpen: \
+ m_pVideoDecoder->m_pFctCreate returns 0x%x", err);
+ return err;
+ }
+ M4OSA_TRACE3_1("M4VSS3GPP_intClipOpen: \
+ Vid dec started; pViDecCtxt=0x%x", pClipCtxt->pViDecCtxt);
+
+ return M4NO_ERROR;
+ }
/**
* Get the correct reader interface */
@@ -755,45 +793,46 @@
{
/**
* Jump to the previous RAP in the clip (first get the time, then jump) */
- iRapCts = iClipCts;
+ if(M4VIDEOEDITING_kFileType_ARGB8888 != pClipCtxt->pSettings->FileType) {
+ iRapCts = iClipCts;
- err = pClipCtxt->ShellAPI.m_pReader->m_pFctGetPrevRapTime(
- pClipCtxt->pReaderContext,
- (M4_StreamHandler *)pClipCtxt->pVideoStream, &iRapCts);
+ err = pClipCtxt->ShellAPI.m_pReader->m_pFctGetPrevRapTime(
+ pClipCtxt->pReaderContext,
+ (M4_StreamHandler *)pClipCtxt->pVideoStream, &iRapCts);
- if( M4WAR_READER_INFORMATION_NOT_PRESENT == err )
- {
- /* No RAP table, jump backward and predecode */
- iRapCts = iClipCts - M4VSS3GPP_NO_STSS_JUMP_POINT;
+ if( M4WAR_READER_INFORMATION_NOT_PRESENT == err )
+ {
+ /* No RAP table, jump backward and predecode */
+ iRapCts = iClipCts - M4VSS3GPP_NO_STSS_JUMP_POINT;
- if( iRapCts < 0 )
- iRapCts = 0;
+ if( iRapCts < 0 )
+ iRapCts = 0;
+ }
+ else if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intClipDecodeVideoUpToCts: m_pFctGetPrevRapTime returns 0x%x!",
+ err);
+ return err;
+ }
+
+ err =
+ pClipCtxt->ShellAPI.m_pReader->m_pFctJump(pClipCtxt->pReaderContext,
+ (M4_StreamHandler *)pClipCtxt->pVideoStream, &iRapCts);
+
+ if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intClipDecodeVideoUpToCts: m_pFctJump returns 0x%x!",
+ err);
+ return err;
+ }
+
+ /**
+ * The decoder must be told that we jumped */
+ bClipJump = M4OSA_TRUE;
+ pClipCtxt->iVideoDecCts = iRapCts;
}
- else if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intClipDecodeVideoUpToCts: m_pFctGetPrevRapTime returns 0x%x!",
- err);
- return err;
- }
-
- err =
- pClipCtxt->ShellAPI.m_pReader->m_pFctJump(pClipCtxt->pReaderContext,
- (M4_StreamHandler *)pClipCtxt->pVideoStream, &iRapCts);
-
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intClipDecodeVideoUpToCts: m_pFctJump returns 0x%x!",
- err);
- return err;
- }
-
- /**
- * The decoder must be told that we jumped */
- bClipJump = M4OSA_TRUE;
- pClipCtxt->iVideoDecCts = iRapCts;
-
/**
* Remember the clip reading state */
pClipCtxt->Vstatus = M4VSS3GPP_kClipStatus_DECODE_UP_TO;
@@ -1826,6 +1865,23 @@
pClipCtxt->pReaderContext = M4OSA_NULL;
}
+ if(pClipCtxt->pPlaneYuv != M4OSA_NULL) {
+ if(pClipCtxt->pPlaneYuv[0].pac_data != M4OSA_NULL) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ pClipCtxt->pPlaneYuv[0].pac_data = M4OSA_NULL;
+ }
+ free(pClipCtxt->pPlaneYuv);
+ pClipCtxt->pPlaneYuv = M4OSA_NULL;
+ }
+
+ if(pClipCtxt->pPlaneYuvWithEffect != M4OSA_NULL) {
+ if(pClipCtxt->pPlaneYuvWithEffect[0].pac_data != M4OSA_NULL) {
+ free(pClipCtxt->pPlaneYuvWithEffect[0].pac_data);
+ pClipCtxt->pPlaneYuvWithEffect[0].pac_data = M4OSA_NULL;
+ }
+ free(pClipCtxt->pPlaneYuvWithEffect);
+ pClipCtxt->pPlaneYuvWithEffect = M4OSA_NULL;
+ }
/**
* Free the shells interfaces */
M4VSS3GPP_unRegisterAllWriters(&pClipCtxt->ShellAPI);
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_ClipAnalysis.c b/libvideoeditor/vss/src/M4VSS3GPP_ClipAnalysis.c
index 248ab61..723c0c1 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_ClipAnalysis.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_ClipAnalysis.c
@@ -143,20 +143,21 @@
/**
* Analyse the clip */
- err = M4VSS3GPP_intBuildAnalysis(pClipContext, pClipProperties);
+ if(M4VIDEOEDITING_kFileType_ARGB8888 != pClipContext->pSettings->FileType) {
+ err = M4VSS3GPP_intBuildAnalysis(pClipContext, pClipProperties);
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editAnalyseClip: M4VSS3GPP_intBuildAnalysis() returns 0x%x!",
- err);
+ if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_editAnalyseClip: M4VSS3GPP_intBuildAnalysis() returns 0x%x!",
+ err);
- /**
- * Free the clip */
- M4VSS3GPP_intClipCleanUp(pClipContext);
- return err;
+ /**
+ * Free the clip */
+ M4VSS3GPP_intClipCleanUp(pClipContext);
+ return err;
+ }
}
-
/**
* Free the clip */
err = M4VSS3GPP_intClipClose(pClipContext);
@@ -174,17 +175,18 @@
/**
* Check the clip is compatible with VSS editing */
- err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(pClipProperties);
+ if(M4VIDEOEDITING_kFileType_ARGB8888 != ClipSettings.FileType) {
+ err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(pClipProperties);
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editAnalyseClip:\
- M4VSS3GPP_intCheckClipCompatibleWithVssEditing() returns 0x%x!",
- err);
- return err;
+ if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_editAnalyseClip:\
+ M4VSS3GPP_intCheckClipCompatibleWithVssEditing() returns 0x%x!",
+ err);
+ return err;
+ }
}
-
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editAnalyseClip(): returning M4NO_ERROR");
@@ -230,34 +232,6 @@
M4OSA_DEBUG_IF2((M4OSA_NULL == pClip2Properties), M4ERR_PARAMETER,
"M4VSS3GPP_editCheckClipCompatibility: pClip2Properties is M4OSA_NULL");
- /**
- * Check if the two clips are, alone, comptible with VSS 3GPP.
- *
- * Note: if a clip is not compatible with VSS3GPP, M4VSS3GPP_editAnalyseClip()
- * did return an error to the integrator. So he should not call
- * M4VSS3GPP_editCheckClipCompatibility
- * with the ClipAnalysis...
- * Still, I think it is good to redo the test here, to be sure.
- * M4VSS3GPP_intCheckClipCompatibleWithVssEditing is not a long function to execute.*/
- err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(pClip1Properties);
-
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editCheckClipCompatibility: Clip1 not compatible with VSS3GPP,\
- returning 0x%x", err);
- return err;
- }
- err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(pClip2Properties);
-
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editCheckClipCompatibility: Clip2 not compatible with VSS3GPP,\
- returning 0x%x", err);
- return err;
- }
-
if( ( M4VIDEOEDITING_kFileType_MP3 == pClip1Properties->FileType)
|| (M4VIDEOEDITING_kFileType_AMR == pClip1Properties->FileType) )
{
@@ -275,81 +249,6 @@
}
}
- /********** Video ************/
-
- /**
- * Check both clips have same video stream type */
- if( pClip1Properties->VideoStreamType != pClip2Properties->VideoStreamType )
- {
- M4OSA_TRACE1_0(
- "M4VSS3GPP_editCheckClipCompatibility: Clips don't have the same video format");
- video_err = M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FORMAT;
- goto audio_analysis;
- }
-
- /**
- * Check both clips have the same video frame size */
- if( ( pClip1Properties->uiVideoWidth != pClip2Properties->uiVideoWidth)
- || (pClip1Properties->uiVideoHeight
- != pClip2Properties->uiVideoHeight) )
- {
- M4OSA_TRACE1_0(
- "M4VSS3GPP_editCheckClipCompatibility: Clips don't have the same video frame size");
- video_err = M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_FRAME_SIZE;
- goto audio_analysis;
- }
-
- switch( pClip1Properties->VideoStreamType )
- {
- case M4VIDEOEDITING_kH263:
- case M4VIDEOEDITING_kH264:
- /**< nothing to check here */
- break;
-
- case M4VIDEOEDITING_kMPEG4_EMP:
- case M4VIDEOEDITING_kMPEG4:
- /**
- * Check both streams have the same time scale */
- if( pClip1Properties->uiVideoTimeScale
- != pClip2Properties->uiVideoTimeScale )
- {
- M4OSA_TRACE1_2(
- "M4VSS3GPP_editCheckClipCompatibility: Clips don't have the same video time\
- scale (%d != %d), returning M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_TIME_SCALE",
- pClip1Properties->uiVideoTimeScale,
- pClip2Properties->uiVideoTimeScale);
- video_err = M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_TIME_SCALE;
- goto audio_analysis;
- }
- /**
- * Check both streams have the same use of data partitioning */
- if( pClip1Properties->bMPEG4dataPartition
- != pClip2Properties->bMPEG4dataPartition )
- {
- M4OSA_TRACE1_2(
- "M4VSS3GPP_editCheckClipCompatibility:\
- Clips don't have the same use of data partitioning (%d != %d),\
- returning M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_DATA_PARTITIONING",
- pClip1Properties->bMPEG4dataPartition,
- pClip2Properties->bMPEG4dataPartition);
- video_err = M4VSS3GPP_ERR_INCOMPATIBLE_VIDEO_DATA_PARTITIONING;
- goto audio_analysis;
- }
- break;
-
- default:
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editCheckClipCompatibility: unknown video stream type (0x%x),\
- returning M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT",
- pClip1Properties->VideoStreamType);
- video_err =
- M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT; /**< this error should never happen,
- it's here for code safety only... */
- goto audio_analysis;
- }
-
- pClip2Properties->bVideoIsCompatibleWithMasterClip = M4OSA_TRUE;
-
/********** Audio ************/
audio_analysis:
@@ -995,20 +894,6 @@
M4OSA_UInt32 uiNbOfValidStreams = 0;
M4OSA_ERR video_err = M4NO_ERROR;
M4OSA_ERR audio_err = M4NO_ERROR;
-
- /**
- * Check that analysis has been generated by this version of the VSS3GPP library */
- if( ( pClipProperties->Version[0] != M4VIDEOEDITING_VERSION_MAJOR)
- || (pClipProperties->Version[1] != M4VIDEOEDITING_VERSION_MINOR)
- || (pClipProperties->Version[2]
- != M4VIDEOEDITING_VERSION_REVISION) )
- {
- M4OSA_TRACE1_0(
- "M4VSS3GPP_intCheckClipCompatibleWithVssEditing: The clip analysis has been generated\
- by another version, returning M4VSS3GPP_ERR_INVALID_CLIP_ANALYSIS_VERSION");
- return M4VSS3GPP_ERR_INVALID_CLIP_ANALYSIS_VERSION;
- }
-
/********* file type *********/
if( M4VIDEOEDITING_kFileType_AMR == pClipProperties->FileType )
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_Codecs.c b/libvideoeditor/vss/src/M4VSS3GPP_Codecs.c
index 10cb76e..1ced937 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_Codecs.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_Codecs.c
@@ -943,7 +943,9 @@
case M4DA_StreamTypeVideoMpeg4Avc:
decoderType = M4DECODER_kVideoTypeAVC;
break;
-
+ case M4DA_StreamTypeVideoARGB8888:
+ decoderType = M4DECODER_kVideoTypeYUV420P;
+ break;
default:
M4OSA_DEBUG_IF1(M4OSA_TRUE,
M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT,
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_Edit.c b/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
index f8d4fb6..5bde983 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
@@ -46,6 +46,9 @@
with M4OSA_String...) */
#endif /* WIN32 */
+#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
+#include "M4VD_EXTERNAL_Interface.h"
+#endif
/************************************************************************/
/* Static local functions */
@@ -148,11 +151,13 @@
/* Init the context. */
+ pC->uiClipNumber = 0;
pC->pClipList = M4OSA_NULL;
pC->pTransitionList = M4OSA_NULL;
pC->pEffectsList = M4OSA_NULL;
pC->pActiveEffectsList = M4OSA_NULL;
pC->pActiveEffectsList1 = M4OSA_NULL;
+ pC->uiCurrentClip = 0;
pC->pC1 = M4OSA_NULL;
pC->pC2 = M4OSA_NULL;
pC->yuv1[0].pac_data = pC->yuv1[1].pac_data = pC->
@@ -164,26 +169,49 @@
pC->yuv4[0].pac_data = pC->yuv4[1].pac_data = pC->
yuv4[2].pac_data = M4OSA_NULL;
pC->bClip1AtBeginCut = M4OSA_FALSE;
+ pC->iClip1ActiveEffect = 0;
+ pC->iClip2ActiveEffect = 0;
pC->bTransitionEffect = M4OSA_FALSE;
pC->bSupportSilence = M4OSA_FALSE;
/**
* Init PC->ewc members */
// Decorrelate input and output encoding timestamp to handle encoder prefetch
+ pC->ewc.dInputVidCts = 0.0;
+ pC->ewc.dOutputVidCts = 0.0;
+ pC->ewc.dATo = 0.0;
+ pC->ewc.iOutputDuration = 0;
pC->ewc.VideoStreamType = M4SYS_kVideoUnknown;
+ pC->ewc.uiVideoBitrate = 0;
+ pC->ewc.uiVideoWidth = 0;
+ pC->ewc.uiVideoHeight = 0;
+ pC->ewc.uiVideoTimeScale = 0;
pC->ewc.bVideoDataPartitioning = M4OSA_FALSE;
pC->ewc.pVideoOutputDsi = M4OSA_NULL;
+ pC->ewc.uiVideoOutputDsiSize = 0;
pC->ewc.bActivateEmp = M4OSA_FALSE;
pC->ewc.AudioStreamType = M4SYS_kAudioUnknown;
pC->ewc.uiNbChannels = 1;
+ pC->ewc.uiAudioBitrate = 0;
+ pC->ewc.uiSamplingFrequency = 0;
pC->ewc.pAudioOutputDsi = M4OSA_NULL;
+ pC->ewc.uiAudioOutputDsiSize = 0;
pC->ewc.pAudioEncCtxt = M4OSA_NULL;
+ pC->ewc.pAudioEncDSI.infoSize = 0;
pC->ewc.pAudioEncDSI.pInfo = M4OSA_NULL;
+ pC->ewc.uiSilencePcmSize = 0;
pC->ewc.pSilenceFrameData = M4OSA_NULL;
+ pC->ewc.uiSilenceFrameSize = 0;
+ pC->ewc.iSilenceFrameDuration = 0;
+ pC->ewc.scale_audio = 0.0;
pC->ewc.pEncContext = M4OSA_NULL;
pC->ewc.pDummyAuBuffer = M4OSA_NULL;
+ pC->ewc.iMpeg4GovOffset = 0;
+ pC->ewc.VppError = 0;
pC->ewc.encoderState = M4VSS3GPP_kNoEncoder;
pC->ewc.p3gpWriterContext = M4OSA_NULL;
+ pC->ewc.uiVideoMaxAuSize = 0;
+ pC->ewc.uiAudioMaxAuSize = 0;
/**
* Keep the OSAL file functions pointer set in our context */
pC->pOsaFileReadPtr = pFileReadPtrFct;
@@ -212,7 +240,10 @@
pC->iInOutTimeOffset = 0;
pC->bEncodeTillEoF = M4OSA_FALSE;
-
+ pC->nbActiveEffects = 0;
+ pC->nbActiveEffects1 = 0;
+ pC->bIssecondClip = M4OSA_FALSE;
+ pC->m_air_context = M4OSA_NULL;
/**
* Return with no error */
M4OSA_TRACE3_0("M4VSS3GPP_editInit(): returning M4NO_ERROR");
@@ -289,6 +320,7 @@
pClipSettings->uiBeginCutTime = 0; /**< no begin cut */
pClipSettings->uiEndCutTime = 0; /**< no end cut */
+ pClipSettings->ClipProperties.bSetImageData = M4OSA_FALSE;
/**
* Reset video characteristics */
@@ -598,37 +630,45 @@
* Check clip compatibility */
for ( i = 0; i < pC->uiClipNumber; i++ )
{
- /**
- * Check all the clips are compatible with VSS 3GPP */
- err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(
- &pC->pClipList[i].ClipProperties);
+ if (pC->pClipList[i].FileType !=M4VIDEOEDITING_kFileType_ARGB8888) {
+ /**
+ * Check all the clips are compatible with VSS 3GPP */
+ err = M4VSS3GPP_intCheckClipCompatibleWithVssEditing(
+ &pC->pClipList[i].ClipProperties);
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_2(
- "M4VSS3GPP_editOpen:\
- M4VSS3GPP_intCheckClipCompatibleWithVssEditing(%d) returns 0x%x!",
- i, err);
- return err;
+ if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_2(
+ "M4VSS3GPP_editOpen:\
+ M4VSS3GPP_intCheckClipCompatibleWithVssEditing(%d) returns 0x%x!",
+ i, err);
+ return err;
+ }
}
/**
* Check the master clip versus all the other ones.
(including master clip with itself, else variables for master clip
are not properly setted) */
- err = M4VSS3GPP_editCheckClipCompatibility(
- &pC->pClipList[pSettings->uiMasterClip].ClipProperties,
- &pC->pClipList[i].ClipProperties);
- /* in case of warning regarding audio incompatibility, editing continues */
- if( M4OSA_ERR_IS_ERROR(err) )
- {
- M4OSA_TRACE1_2(
- "M4VSS3GPP_editOpen: M4VSS3GPP_editCheckClipCompatibility(%d) returns 0x%x!",
- i, err);
- return err;
+ if(pC->pClipList[i].FileType != M4VIDEOEDITING_kFileType_ARGB8888) {
+
+ err = M4VSS3GPP_editCheckClipCompatibility(
+ &pC->pClipList[pSettings->uiMasterClip].ClipProperties,
+ &pC->pClipList[i].ClipProperties);
+ /* in case of warning regarding audio incompatibility,
+ editing continues */
+ if( M4OSA_ERR_IS_ERROR(err) )
+ {
+ M4OSA_TRACE1_2(
+ "M4VSS3GPP_editOpen: M4VSS3GPP_editCheckClipCompatibility \
+ (%d) returns 0x%x!", i, err);
+ return err;
+ }
+ } else {
+ pC->pClipList[i].ClipProperties.bAudioIsCompatibleWithMasterClip =
+ M4OSA_FALSE;
}
}
-
/* Search audio tracks that cannot be edited :
* - delete all audio effects for the clip
* - if master clip is editable let the transition
@@ -691,19 +731,49 @@
* Avoid weird clip settings */
for ( i = 0; i < pSettings->uiClipNumber; i++ )
{
- err = M4VSS3GPP_intClipSettingsSanityCheck(&pC->pClipList[i]);
+ if (pC->pClipList[i].FileType !=M4VIDEOEDITING_kFileType_ARGB8888) {
+ err = M4VSS3GPP_intClipSettingsSanityCheck(&pC->pClipList[i]);
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_editOpen: M4VSS3GPP_intClipSettingsSanityCheck returns 0x%x!",
- err);
- return err;
+ if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_editOpen: M4VSS3GPP_intClipSettingsSanityCheck returns 0x%x!",
+ err);
+ return err;
+ }
}
}
for ( i = 0; i < (pSettings->uiClipNumber - 1); i++ )
{
+ if (pC->pTransitionList[i].uiTransitionDuration != 0) {
+ if (pC->pClipList[i].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
+ pC->pClipList[i].uiBeginCutTime = 0;
+ pC->pClipList[i].uiEndCutTime =
+ pC->pTransitionList[i].uiTransitionDuration;
+ }
+
+ if (pC->pClipList[i+1].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
+ pC->pClipList[i+1].uiBeginCutTime = 0;
+ pC->pClipList[i+1].uiEndCutTime =
+ pC->pTransitionList[i].uiTransitionDuration;
+ }
+ } else {
+
+ if (pC->pClipList[i].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
+ pC->pClipList[i].uiEndCutTime =
+ pC->pClipList[i].uiEndCutTime - pC->pClipList[i].uiBeginCutTime;
+ pC->pClipList[i].uiBeginCutTime = 0;
+ }
+
+ if (pC->pClipList[i+1].FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
+ pC->pClipList[i+1].uiEndCutTime =
+ pC->pClipList[i+1].uiEndCutTime - pC->pClipList[i+1].uiBeginCutTime;
+ pC->pClipList[i+1].uiBeginCutTime = 0;
+ }
+
+ }
+
/**
* Maximum transition duration between clip n and clip n+1 is the duration
* of the shortest clip */
@@ -809,34 +879,89 @@
pC->ewc.iOutputDuration -= pC->pTransitionList[i].uiTransitionDuration;
}
- /**
- * Copy the video properties of the master clip to the output properties */
- pC->ewc.uiVideoWidth =
- pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiVideoWidth;
- pC->ewc.uiVideoHeight =
- pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiVideoHeight;
- pC->ewc.uiVideoTimeScale =
- pC->pClipList[pSettings->uiMasterClip].ClipProperties.uiVideoTimeScale;
- pC->ewc.bVideoDataPartitioning = pC->pClipList[pSettings->
- uiMasterClip].ClipProperties.bMPEG4dataPartition;
+ /* Get video properties from output properties */
- switch( pC->pClipList[pSettings->uiMasterClip].ClipProperties.VideoStreamType )
- {
+ /* Get output width and height */
+ switch(pC->xVSS.outputVideoSize) {
+ case M4VIDEOEDITING_kSQCIF:
+ pC->ewc.uiVideoWidth = 128;
+ pC->ewc.uiVideoHeight = 96;
+ break;
+ case M4VIDEOEDITING_kQQVGA:
+ pC->ewc.uiVideoWidth = 160;
+ pC->ewc.uiVideoHeight = 120;
+ break;
+ case M4VIDEOEDITING_kQCIF:
+ pC->ewc.uiVideoWidth = 176;
+ pC->ewc.uiVideoHeight = 144;
+ break;
+ case M4VIDEOEDITING_kQVGA:
+ pC->ewc.uiVideoWidth = 320;
+ pC->ewc.uiVideoHeight = 240;
+ break;
+ case M4VIDEOEDITING_kCIF:
+ pC->ewc.uiVideoWidth = 352;
+ pC->ewc.uiVideoHeight = 288;
+ break;
+ case M4VIDEOEDITING_kVGA:
+ pC->ewc.uiVideoWidth = 640;
+ pC->ewc.uiVideoHeight = 480;
+ break;
+ /* +PR LV5807 */
+ case M4VIDEOEDITING_kWVGA:
+ pC->ewc.uiVideoWidth = 800;
+ pC->ewc.uiVideoHeight = 480;
+ break;
+ case M4VIDEOEDITING_kNTSC:
+ pC->ewc.uiVideoWidth = 720;
+ pC->ewc.uiVideoHeight = 480;
+ break;
+ /* -PR LV5807 */
+ /* +CR Google */
+ case M4VIDEOEDITING_k640_360:
+ pC->ewc.uiVideoWidth = 640;
+ pC->ewc.uiVideoHeight = 360;
+ break;
+
+ case M4VIDEOEDITING_k854_480:
+ pC->ewc.uiVideoWidth = M4ENCODER_854_480_Width;
+ pC->ewc.uiVideoHeight = 480;
+ break;
+
+ case M4VIDEOEDITING_k1280_720:
+ pC->ewc.uiVideoWidth = 1280;
+ pC->ewc.uiVideoHeight = 720;
+ break;
+ case M4VIDEOEDITING_k1080_720:
+ pC->ewc.uiVideoWidth = M4ENCODER_1080_720_Width;
+
+ pC->ewc.uiVideoHeight = 720;
+ break;
+ case M4VIDEOEDITING_k960_720:
+ pC->ewc.uiVideoWidth = 960;
+ pC->ewc.uiVideoHeight = 720;
+ break;
+
+ default: /* If output video size is not given, we take QCIF size */
+ pC->ewc.uiVideoWidth = 176;
+ pC->ewc.uiVideoHeight = 144;
+ pC->xVSS.outputVideoSize = M4VIDEOEDITING_kQCIF;
+ break;
+ }
+
+ pC->ewc.uiVideoTimeScale = 30;
+ pC->ewc.bVideoDataPartitioning = 0;
+
+ switch(pC->xVSS.outputVideoFormat) {
case M4VIDEOEDITING_kH263:
pC->ewc.VideoStreamType = M4SYS_kH263;
break;
-
- case M4VIDEOEDITING_kMPEG4_EMP:
- pC->ewc.bActivateEmp = M4OSA_TRUE; /* no break */
-
case M4VIDEOEDITING_kMPEG4:
pC->ewc.VideoStreamType = M4SYS_kMPEG_4;
break;
-
case M4VIDEOEDITING_kH264:
pC->ewc.VideoStreamType = M4SYS_kH264;
break;
-
default:
pC->ewc.VideoStreamType = M4SYS_kVideoUnknown;
break;
@@ -913,6 +1038,22 @@
break;
}
+ for (i=0; i<pC->uiClipNumber; i++) {
+ if ((pC->pClipList[i].ClipProperties.VideoStreamType !=
+ pC->xVSS.outputVideoFormat)||
+ (pC->pClipList[i].ClipProperties.uiVideoWidth !=
+ pC->ewc.uiVideoWidth) ||
+ (pC->pClipList[i].ClipProperties.uiVideoHeight !=
+ pC->ewc.uiVideoHeight) ||
+ (pC->pClipList[i].ClipProperties.VideoStreamType ==
+ M4VIDEOEDITING_kH264) ||
+ (pC->pClipList[i].ClipProperties.VideoStreamType ==
+ M4VIDEOEDITING_kMPEG4 &&
+ pC->pClipList[i].ClipProperties.uiVideoTimeScale !=
+ pC->ewc.uiVideoTimeScale)) {
+ pC->pClipList[i].bTranscodingRequired = M4OSA_TRUE;
+ }
+ }
/**
* We produce a 3gpp file, unless it is mp3 */
if( M4VIDEOEDITING_kMP3 == pC->
@@ -1108,8 +1249,6 @@
* Create the 3GPP output file */
else if( M4VIDEOEDITING_kFileType_3GPP == outputFileType )
{
- /* Compute an average bitrate from mixed bitrates of the input clips */
- M4VSS3GPP_intComputeOutputAverageVideoBitrate(pC);
pC->ewc.uiVideoBitrate = pSettings->xVSS.outputVideoBitrate;
/**
@@ -1526,6 +1665,10 @@
free(pC->pActiveEffectsList1);
pC->pActiveEffectsList1 = M4OSA_NULL;
}
+ if(pC->m_air_context != M4OSA_NULL) {
+ free(pC->m_air_context);
+ pC->m_air_context = M4OSA_NULL;
+ }
/**
* Update state automaton */
pC->State = M4VSS3GPP_kEditState_CLOSED;
@@ -2474,6 +2617,9 @@
M4VSS3GPP_ClipContext *pClip;
M4OSA_ERR err;
M4OSA_UInt32 i;
+ M4DECODER_MPEG4_DecoderConfigInfo DecConfigInfo;
+ M4DECODER_VideoSize dummySize;
+ M4OSA_Bool bGetDSiFromEncoder = M4OSA_FALSE;
M4ENCODER_Header *encHeader;
M4SYS_StreamIDmemAddr streamHeader;
@@ -2519,11 +2665,11 @@
for ( i = 0; i < pC->uiClipNumber; i++ )
{
- uiNewLevel = pC->pClipList[i].ClipProperties.uiH263level;
-
- if( uiNewLevel > uiCurrentLevel )
- {
- uiCurrentLevel = uiNewLevel;
+ if(pC->pClipList[i].bTranscodingRequired == M4OSA_FALSE) {
+ uiNewLevel = pC->pClipList[i].ClipProperties.uiH263level;
+ if (uiNewLevel > uiCurrentLevel) {
+ uiCurrentLevel = uiNewLevel;
+ }
}
}
@@ -2560,68 +2706,100 @@
/**
* Start with profile of the first clip */
- uiCurrentProf = pC->pClipList[0].ClipProperties.uiVideoProfile;
+ M4OSA_TRACE1_0("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ get DSI for Mpeg4 stream");
+ if(M4OSA_NULL == pC->ewc.pEncContext) {
+ M4OSA_TRACE1_0("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ pC->ewc.pEncContext is NULL");
+ err = M4VSS3GPP_intCreateVideoEncoder(pC);
+ if(M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ M4VSS3GPP_intCreateVideoEncoder returned error 0x%x", err);
+ }
+ }
+ if(M4OSA_NULL != pC->ewc.pEncContext) {
+ err = pC->ShellAPI.pVideoEncoderGlobalFcts->pFctGetOption(
+ pC->ewc.pEncContext, M4ENCODER_kOptionID_EncoderHeader,
+ (M4OSA_DataOption)&encHeader);
+ if ( (M4NO_ERROR != err) || (M4OSA_NULL == encHeader->pBuf)) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ failed to get the encoder header (err 0x%x)", err);
+ M4OSA_TRACE1_2("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ encHeader->pBuf=0x%x, size=0x%x", encHeader->pBuf,
+ encHeader->Size);
+ }
+ }
+ err = M4DECODER_EXTERNAL_ParseVideoDSI((M4OSA_UInt8 *)encHeader->pBuf,
+ encHeader->Size, &DecConfigInfo, &dummySize);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intBuildAnalysis(): \
+ M4DECODER_EXTERNAL_ParseVideoDSI returns 0x%08X", err);
+ return err;
+ }
+
+ uiCurrentProf = DecConfigInfo.uiProfile;
/**
* Combine current profile with the one of the next clip */
- for ( i = 1; i < pC->uiClipNumber; i++ )
- {
- uiNewProf = pC->pClipList[i].ClipProperties.uiVideoProfile;
+ for (i=0; i<pC->uiClipNumber; i++) {
+ if(pC->pClipList[i].bTranscodingRequired == M4OSA_FALSE) {
+ uiNewProf = pC->pClipList[i].ClipProperties.uiVideoProfile;
- switch( uiNewProf )
- {
- case 8:
- /**< 8 + x --> x */
- /**< uiCurrentProf is not updated */
- break;
+ switch( uiNewProf )
+ {
+ case 8:
+ /**< 8 + x --> x */
+ /**< uiCurrentProf is not updated */
+ break;
- case 1:
- case 2:
- case 3:
- switch( uiCurrentProf )
- {
- case 1:
- case 2:
- case 3:
- case 4:
- case 5:
- /**< 1, 2, 3, 4 or 5 -> max */
- uiCurrentProf = (uiCurrentProf > uiNewProf)
- ? uiCurrentProf : uiNewProf;
- break;
+ case 1:
+ case 2:
+ case 3:
+ switch( uiCurrentProf )
+ {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ /**< 1, 2, 3, 4 or 5 -> max */
+ uiCurrentProf = (uiCurrentProf > uiNewProf)
+ ? uiCurrentProf : uiNewProf;
+ break;
- case 8: /**< 8 + x -> x */
- uiCurrentProf = uiNewProf;
- break;
+ case 8: /**< 8 + x -> x */
+ uiCurrentProf = uiNewProf;
+ break;
- case 9:
- /**< 9 and 1 -> 2 */
- /**< 9 and 2 -> 2 */
- /**< 9 and 3 -> 3 */
- /**< 9 and 4 -> 4 */
- /**< 9 and 5 -> 5 */
- uiCurrentProf = (uiNewProf > 2) ? uiNewProf : 2;
- break;
+ case 9:
+ /**< 9 and 1 -> 2 */
+ /**< 9 and 2 -> 2 */
+ /**< 9 and 3 -> 3 */
+ /**< 9 and 4 -> 4 */
+ /**< 9 and 5 -> 5 */
+ uiCurrentProf = (uiNewProf > 2) ? uiNewProf : 2;
+ break;
+ }
+ break;
+
+ case 9:
+ switch( uiCurrentProf )
+ {
+ case 1:
+ case 2:
+ case 3:
+ /**< 9 and 1 -> 2 */
+ /**< 9 and 2 -> 2 */
+ /**< 9 and 3 -> 3 */
+ uiCurrentProf =
+ (uiCurrentProf > 2) ? uiCurrentProf : 2;
+ break;
+
+ case 9: /**< 9 + x -> x */
+ case 8: /**< 8 + x -> x */
+ uiCurrentProf = uiNewProf;
+ break;
}
- break;
-
- case 9:
- switch( uiCurrentProf )
- {
- case 1:
- case 2:
- case 3:
- /**< 9 and 1 -> 2 */
- /**< 9 and 2 -> 2 */
- /**< 9 and 3 -> 3 */
- uiCurrentProf =
- (uiCurrentProf > 2) ? uiCurrentProf : 2;
- break;
-
- case 9: /**< 9 + x -> x */
- case 8: /**< 8 + x -> x */
- uiCurrentProf = uiNewProf;
- break;
}
}
}
@@ -2634,9 +2812,9 @@
while( i < pC->uiClipNumber )
{
- if( M4OSA_TRUE
- == pC->pClipList[i].ClipProperties.bMPEG4resynchMarker )
- {
+ if ((M4OSA_TRUE ==
+ pC->pClipList[i].ClipProperties.bMPEG4resynchMarker) &&
+ (pC->pClipList[i].bTranscodingRequired == M4OSA_FALSE)) {
iResynchMarkerDsiIndex = i;
break; /**< we found it, get out the while loop */
}
@@ -2648,7 +2826,62 @@
* Else we must open it (and later close it...) */
if( 0 == iResynchMarkerDsiIndex )
{
- pStreamForDsi = &(pC->pC1->pVideoStream->m_basicProperties);
+ for (i=0; i<pC->uiClipNumber; i++) {
+ if(pC->pClipList[i].bTranscodingRequired == M4OSA_FALSE) {
+ /**
+ * We can use the fast open mode and the skip audio mode
+ to get the DSI */
+ err = M4VSS3GPP_intClipInit(&pClip, pC->pOsaFileReadPtr);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ M4VSS3GPP_intClipInit() returns 0x%x!", err);
+ if (M4OSA_NULL != pClip) {
+ M4VSS3GPP_intClipCleanUp(pClip);
+ }
+ return err;
+ }
+ err = M4VSS3GPP_intClipOpen(
+ pClip, &pC->pClipList[i],
+ M4OSA_TRUE, M4OSA_TRUE,
+ M4OSA_TRUE);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ M4VSS3GPP_intClipOpen() returns 0x%x!", err);
+ M4VSS3GPP_intClipCleanUp(pClip);
+ return err;
+ }
+ pStreamForDsi = &(pClip->pVideoStream->m_basicProperties);
+ /*got the DSI */
+
+ bGetDSiFromEncoder = M4OSA_TRUE;
+
+ break;
+ }
+ }
+ if(bGetDSiFromEncoder == M4OSA_FALSE) {
+ /**
+ * Allocate and copy the new DSI */
+ pC->ewc.pVideoOutputDsi = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(
+ encHeader->Size, M4VSS3GPP, (M4OSA_Char *)"ewc dsi (MPEG4)");
+ if (M4OSA_NULL == pC->ewc.pVideoOutputDsi) {
+ M4OSA_TRACE1_0(
+ "M4VSS3GPP_intComputeOutputVideoAndAudioDsi(): \
+ unable to allocate pVideoOutputDsi (MPEG4)");
+ return M4ERR_ALLOC;
+ }
+ pC->ewc.uiVideoOutputDsiSize = (M4OSA_UInt16)encHeader->Size;
+ memcpy((void *)pC->ewc.pVideoOutputDsi,
+ (void *)encHeader->pBuf, pC->ewc.uiVideoOutputDsiSize);
+
+ }
+
+ err = M4VSS3GPP_intDestroyVideoEncoder(pC);
+ if(M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intComputeOutputVideoAndAudioDsi: \
+ M4VSS3GPP_intDestroyVideoEncoder error 0x%x", err);
+ }
}
else
{
@@ -2687,24 +2920,27 @@
pStreamForDsi = &(pClip->pVideoStream->m_basicProperties);
}
- /**
- * Allocate and copy the new DSI */
- pC->ewc.pVideoOutputDsi = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(
- pStreamForDsi->m_decoderSpecificInfoSize,
- M4VSS3GPP, (M4OSA_Char *)"pC->ewc.pVideoOutputDsi (MPEG4)");
+ if(pC->ewc.pVideoOutputDsi == M4OSA_NULL) {
- if( M4OSA_NULL == pC->ewc.pVideoOutputDsi )
- {
- M4OSA_TRACE1_0(
- "M4VSS3GPP_intComputeOutputVideoAndAudioDsi():\
- unable to allocate pVideoOutputDsi (MPEG4), returning M4ERR_ALLOC");
- return M4ERR_ALLOC;
+ /**
+ * Allocate and copy the new DSI */
+ pC->ewc.pVideoOutputDsi = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(
+ pStreamForDsi->m_decoderSpecificInfoSize,
+ M4VSS3GPP, (M4OSA_Char *)"pC->ewc.pVideoOutputDsi (MPEG4)");
+
+ if( M4OSA_NULL == pC->ewc.pVideoOutputDsi )
+ {
+ M4OSA_TRACE1_0(
+ "M4VSS3GPP_intComputeOutputVideoAndAudioDsi():\
+ unable to allocate pVideoOutputDsi (MPEG4), returning M4ERR_ALLOC");
+ return M4ERR_ALLOC;
+ }
+ pC->ewc.uiVideoOutputDsiSize =
+ (M4OSA_UInt16)pStreamForDsi->m_decoderSpecificInfoSize;
+ memcpy((void *)pC->ewc.pVideoOutputDsi,
+ (void *)pStreamForDsi->m_pDecoderSpecificInfo,
+ pC->ewc.uiVideoOutputDsiSize);
}
- pC->ewc.uiVideoOutputDsiSize =
- (M4OSA_UInt16)pStreamForDsi->m_decoderSpecificInfoSize;
- memcpy((void *)pC->ewc.pVideoOutputDsi,
- (void *)pStreamForDsi->m_pDecoderSpecificInfo,
- pC->ewc.uiVideoOutputDsiSize);
/**
* We rewrite the profile in the output DSI because it may not be the good one
@@ -2914,6 +3150,22 @@
if( M4OSA_NULL != pC->pC1 )
{
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame) {
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[0].pac_data) {
+ free(pC->pC1->m_pPreResizeFrame[0].pac_data);
+ pC->pC1->m_pPreResizeFrame[0].pac_data = M4OSA_NULL;
+ }
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[1].pac_data) {
+ free(pC->pC1->m_pPreResizeFrame[1].pac_data);
+ pC->pC1->m_pPreResizeFrame[1].pac_data = M4OSA_NULL;
+ }
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame[2].pac_data) {
+ free(pC->pC1->m_pPreResizeFrame[2].pac_data);
+ pC->pC1->m_pPreResizeFrame[2].pac_data = M4OSA_NULL;
+ }
+ free(pC->pC1->m_pPreResizeFrame);
+ pC->pC1->m_pPreResizeFrame = M4OSA_NULL;
+ }
/**
* Close the current first clip */
err = M4VSS3GPP_intClipCleanUp(pC->pC1);
@@ -2949,6 +3201,9 @@
if( M4OSA_NULL != pC->pC2 )
{
pC->pC1 = pC->pC2;
+ if(M4OSA_NULL != pC->pC2->m_pPreResizeFrame) {
+ pC->pC1->m_pPreResizeFrame = pC->pC2->m_pPreResizeFrame;
+ }
pC->pC2 = M4OSA_NULL;
}
/**
@@ -3145,7 +3400,7 @@
{
M4OSA_ERR err;
M4VSS3GPP_ClipContext *pClip; /**< shortcut */
- M4VIDEOEDITING_ClipProperties *pClipProperties;
+ M4VIDEOEDITING_ClipProperties *pClipProperties = M4OSA_NULL;
M4OSA_Int32 iCts;
M4OSA_UInt32 i;
@@ -3171,20 +3426,25 @@
* Set shortcut */
pClip = *hClip;
- err = M4VSS3GPP_intClipOpen(pClip, pClipSettings, M4OSA_FALSE, M4OSA_FALSE,
- M4OSA_FALSE);
+ if (pClipSettings->FileType == M4VIDEOEDITING_kFileType_ARGB8888 ) {
+ pClipProperties = &pClipSettings->ClipProperties;
+ pClip->pSettings = pClipSettings;
+ pClip->iEndTime = pClipSettings->uiEndCutTime;
+ }
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intOpenClip: M4VSS3GPP_intClipOpen() returns 0x%x!",
- err);
+ err = M4VSS3GPP_intClipOpen(pClip, pClipSettings,
+ M4OSA_FALSE, M4OSA_FALSE, M4OSA_FALSE);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intOpenClip: \
+ M4VSS3GPP_intClipOpen() returns 0x%x!", err);
M4VSS3GPP_intClipCleanUp(pClip);
*hClip = M4OSA_NULL;
return err;
}
- pClipProperties = &pClip->pSettings->ClipProperties;
+ if (pClipSettings->FileType != M4VIDEOEDITING_kFileType_ARGB8888 ) {
+ pClipProperties = &pClip->pSettings->ClipProperties;
+ }
/**
* Copy common 'silence frame stuff' to ClipContext */
@@ -3213,8 +3473,7 @@
pClip->iActualVideoBeginCut = 0;
pClip->iActualAudioBeginCut = 0;
}
- else
- {
+ else if(pClipSettings->FileType != M4VIDEOEDITING_kFileType_ARGB8888) {
if( M4SYS_kVideoUnknown != pC->ewc.VideoStreamType )
{
/**
@@ -3274,25 +3533,128 @@
if( M4SYS_kVideoUnknown != pC->ewc.VideoStreamType )
{
- /**
- * Read the first Video AU of the clip */
- err = pClip->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu(
- pClip->pReaderContext,
- (M4_StreamHandler *)pClip->pVideoStream, &pClip->VideoAU);
+ if ((pClipSettings->FileType != M4VIDEOEDITING_kFileType_ARGB8888 )) {
- if( M4WAR_NO_MORE_AU == err )
- {
/**
- * If we (already!) reach the end of the clip, we filter the error.
- * It will be correctly managed at the first step. */
- err = M4NO_ERROR;
+ * Read the first Video AU of the clip */
+ err = pClip->ShellAPI.m_pReaderDataIt->m_pFctGetNextAu(
+ pClip->pReaderContext,
+ (M4_StreamHandler *)pClip->pVideoStream, &pClip->VideoAU);
+
+ if( M4WAR_NO_MORE_AU == err )
+ {
+ /**
+ * If we (already!) reach the end of the clip, we filter the error.
+ * It will be correctly managed at the first step. */
+ err = M4NO_ERROR;
+ }
+ else if( M4NO_ERROR != err )
+ {
+ M4OSA_TRACE1_1("M4VSS3GPP_intOpenClip: \
+ m_pReaderDataIt->m_pFctGetNextAu() returns 0x%x!", err);
+ return err;
+ }
+ } else {
+ pClipProperties->uiVideoWidth = pClipProperties->uiStillPicWidth;
+ pClipProperties->uiVideoHeight = pClipProperties->uiStillPicHeight;
}
- else if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intOpenClip: m_pReaderDataIt->m_pFctGetNextAu() returns 0x%x!",
- err);
- return err;
+ /* state check not to allocate buffer during save start */
+
+
+ /******************************/
+ /* Video resize management */
+ /******************************/
+ /**
+ * Compare input video size with output video size
+ to check if resize needed */
+ if (((M4OSA_UInt32)pC->ewc.uiVideoWidth !=
+ pClipProperties->uiVideoWidth) ||
+ ((M4OSA_UInt32)pC->ewc.uiVideoHeight !=
+ pClipProperties->uiVideoHeight)) {
+ if(pClip->m_pPreResizeFrame == M4OSA_NULL) {
+ /**
+ * Allocate the intermediate video plane that will
+ receive the decoded image before resizing */
+ pClip->m_pPreResizeFrame =
+ (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(
+ 3*sizeof(M4VIFI_ImagePlane), M4VSS3GPP,
+ (M4OSA_Char *)"pPreResizeFrame");
+ if (M4OSA_NULL == pClip->m_pPreResizeFrame) {
+ M4OSA_TRACE1_0("M4MCS_intPrepareVideoEncoder(): \
+ unable to allocate m_pPreResizeFrame");
+ return M4ERR_ALLOC;
+ }
+
+ pClip->m_pPreResizeFrame[0].pac_data = M4OSA_NULL;
+ pClip->m_pPreResizeFrame[1].pac_data = M4OSA_NULL;
+ pClip->m_pPreResizeFrame[2].pac_data = M4OSA_NULL;
+
+ /**
+ * Allocate the Y plane */
+ pClip->m_pPreResizeFrame[0].u_topleft = 0;
+ pClip->m_pPreResizeFrame[0].u_width =
+ pClipProperties->uiVideoWidth;
+ pClip->m_pPreResizeFrame[0].u_height =
+ pClipProperties->uiVideoHeight;
+ pClip->m_pPreResizeFrame[0].u_stride =
+ pClip->m_pPreResizeFrame[0].u_width;
+
+ pClip->m_pPreResizeFrame[0].pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc (
+ pClip->m_pPreResizeFrame[0].u_stride * pClip->m_pPreResizeFrame[0].u_height,
+ M4MCS, (M4OSA_Char *)"m_pPreResizeFrame[0].pac_data");
+ if (M4OSA_NULL == pClip->m_pPreResizeFrame[0].pac_data) {
+ M4OSA_TRACE1_0("M4MCS_intPrepareVideoEncoder(): \
+ unable to allocate m_pPreResizeFrame[0].pac_data");
+ free(pClip->m_pPreResizeFrame);
+ return M4ERR_ALLOC;
+ }
+
+ /**
+ * Allocate the U plane */
+ pClip->m_pPreResizeFrame[1].u_topleft = 0;
+ pClip->m_pPreResizeFrame[1].u_width =
+ pClip->m_pPreResizeFrame[0].u_width >> 1;
+ pClip->m_pPreResizeFrame[1].u_height =
+ pClip->m_pPreResizeFrame[0].u_height >> 1;
+ pClip->m_pPreResizeFrame[1].u_stride =
+ pClip->m_pPreResizeFrame[1].u_width;
+
+ pClip->m_pPreResizeFrame[1].pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc (
+ pClip->m_pPreResizeFrame[1].u_stride * pClip->m_pPreResizeFrame[1].u_height,
+ M4MCS, (M4OSA_Char *)"m_pPreResizeFrame[1].pac_data");
+ if (M4OSA_NULL == pClip->m_pPreResizeFrame[1].pac_data) {
+ M4OSA_TRACE1_0("M4MCS_intPrepareVideoEncoder(): \
+ unable to allocate m_pPreResizeFrame[1].pac_data");
+ free(pClip->m_pPreResizeFrame[0].pac_data);
+ free(pClip->m_pPreResizeFrame);
+ return M4ERR_ALLOC;
+ }
+
+ /**
+ * Allocate the V plane */
+ pClip->m_pPreResizeFrame[2].u_topleft = 0;
+ pClip->m_pPreResizeFrame[2].u_width =
+ pClip->m_pPreResizeFrame[1].u_width;
+ pClip->m_pPreResizeFrame[2].u_height =
+ pClip->m_pPreResizeFrame[1].u_height;
+ pClip->m_pPreResizeFrame[2].u_stride =
+ pClip->m_pPreResizeFrame[2].u_width;
+
+ pClip->m_pPreResizeFrame[2].pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc (
+ pClip->m_pPreResizeFrame[2].u_stride * pClip->m_pPreResizeFrame[2].u_height,
+ M4MCS, (M4OSA_Char *)"m_pPreResizeFrame[2].pac_data");
+ if (M4OSA_NULL == pClip->m_pPreResizeFrame[2].pac_data) {
+ M4OSA_TRACE1_0("M4MCS_intPrepareVideoEncoder(): \
+ unable to allocate m_pPreResizeFrame[2].pac_data");
+ free(pClip->m_pPreResizeFrame[0].pac_data);
+ free(pClip->m_pPreResizeFrame[1].pac_data);
+ free(pClip->m_pPreResizeFrame);
+ return M4ERR_ALLOC;
+ }
+ }
}
/**
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_EditVideo.c b/libvideoeditor/vss/src/M4VSS3GPP_EditVideo.c
index f73487f..e6271ea 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_EditVideo.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_EditVideo.c
@@ -47,6 +47,13 @@
/*for transition behaviour*/
#include <math.h>
+#include "M4AIR_API.h"
+#include "M4VSS3GPP_Extended_API.h"
+/** Determine absolute value of a. */
+#define M4xVSS_ABS(a) ( ( (a) < (0) ) ? (-(a)) : (a) )
+#define Y_PLANE_BORDER_VALUE 0x00
+#define U_PLANE_BORDER_VALUE 0x80
+#define V_PLANE_BORDER_VALUE 0x80
/************************************************************************/
/* Static local functions */
@@ -75,6 +82,26 @@
M4OSA_UInt32 *pCtsSec );
static M4OSA_ERR M4VSS3GPP_intAllocateYUV420( M4VIFI_ImagePlane *pPlanes,
M4OSA_UInt32 uiWidth, M4OSA_UInt32 uiHeight );
+static M4OSA_ERR M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420(
+ M4OSA_Void* pFileIn, M4OSA_FileReadPointer* pFileReadPtr,
+ M4VIFI_ImagePlane* pImagePlanes,
+ M4OSA_UInt32 width,M4OSA_UInt32 height);
+static M4OSA_ERR M4VSS3GPP_intApplyRenderingMode(
+ M4VSS3GPP_InternalEditContext *pC,
+ M4xVSS_MediaRendering renderingMode,
+ M4VIFI_ImagePlane* pInplane,
+ M4VIFI_ImagePlane* pOutplane);
+
+static M4OSA_ERR M4VSS3GPP_intSetYuv420PlaneFromARGB888 (
+ M4VSS3GPP_InternalEditContext *pC,
+ M4VSS3GPP_ClipContext* pClipCtxt);
+static M4OSA_ERR M4VSS3GPP_intRenderFrameWithEffect(
+ M4VSS3GPP_InternalEditContext *pC,
+ M4VSS3GPP_ClipContext* pClipCtxt,
+ M4OSA_Bool bIsClip1,
+ M4VIFI_ImagePlane *pResizePlane,
+ M4VIFI_ImagePlane *pPlaneNoResize,
+ M4VIFI_ImagePlane *pPlaneOut);
/**
******************************************************************************
@@ -381,6 +408,19 @@
M4OSA_TRACE3_0(
"M4VSS3GPP_intEditStepVideo DECODE_ENCODE / BEGIN_CUT");
+ if ((pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (M4OSA_FALSE ==
+ pC->pC1->pSettings->ClipProperties.bSetImageData)) {
+
+ err = M4VSS3GPP_intSetYuv420PlaneFromARGB888(pC, pC->pC1);
+ if( M4NO_ERROR != err ) {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intEditStepVideo: DECODE_ENCODE:\
+ M4VSS3GPP_intSetYuv420PlaneFromARGB888 err=%x", err);
+ return err;
+ }
+ }
/**
* Decode the video up to the target time
(will jump to the previous RAP if needed ) */
@@ -496,6 +536,19 @@
/**
* Decode the clip1 video up to the target time
(will jump to the previous RAP if needed */
+ if ((pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (M4OSA_FALSE ==
+ pC->pC1->pSettings->ClipProperties.bSetImageData)) {
+
+ err = M4VSS3GPP_intSetYuv420PlaneFromARGB888(pC, pC->pC1);
+ if( M4NO_ERROR != err ) {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intEditStepVideo: TRANSITION:\
+ M4VSS3GPP_intSetYuv420PlaneFromARGB888 err=%x", err);
+ return err;
+ }
+ }
// Decorrelate input and output encoding timestamp to handle encoder prefetch
err = M4VSS3GPP_intClipDecodeVideoUpToCts(pC->pC1,
(M4OSA_Int32)pC->ewc.dInputVidCts);
@@ -522,6 +575,20 @@
/**
* Decode the clip2 video up to the target time
(will jump to the previous RAP if needed) */
+ if ((pC->pC2->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (M4OSA_FALSE ==
+ pC->pC2->pSettings->ClipProperties.bSetImageData)) {
+
+ err = M4VSS3GPP_intSetYuv420PlaneFromARGB888(pC, pC->pC2);
+ if( M4NO_ERROR != err ) {
+ M4OSA_TRACE1_1(
+ "M4VSS3GPP_intEditStepVideo: TRANSITION:\
+ M4VSS3GPP_intSetYuv420PlaneFromARGB888 err=%x", err);
+ return err;
+ }
+ }
+
// Decorrelate input and output encoding timestamp to handle encoder prefetch
err = M4VSS3GPP_intClipDecodeVideoUpToCts(pC->pC2,
(M4OSA_Int32)pC->ewc.dInputVidCts);
@@ -670,6 +737,8 @@
* Open second clip for transition, if not yet opened */
if( M4OSA_NULL == pC->pC2 )
{
+ pC->pC1->bGetYuvDataFromDecoder = M4OSA_TRUE;
+
err = M4VSS3GPP_intOpenClip(pC, &pC->pC2,
&pC->pClipList[pC->uiCurrentClip + 1]);
@@ -720,8 +789,10 @@
pC->bTransitionEffect = M4OSA_FALSE;
/* If there is an effect we go to decode/encode mode */
- if ((pC->nbActiveEffects > 0) ||(pC->nbActiveEffects1 > 0))
- {
+ if((pC->nbActiveEffects > 0) || (pC->nbActiveEffects1 > 0) ||
+ (pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) ||
+ (pC->pC1->pSettings->bTranscodingRequired == M4OSA_TRUE)) {
pC->Vstate = M4VSS3GPP_kEditVideoState_DECODE_ENCODE;
}
/* We do a begin cut, except if already done (time is not progressing because we want
@@ -976,16 +1047,25 @@
M4OSA_ERR M4VSS3GPP_intVPP( M4VPP_Context pContext, M4VIFI_ImagePlane *pPlaneIn,
M4VIFI_ImagePlane *pPlaneOut )
{
- M4OSA_ERR err;
- M4_MediaTime t;
+ M4OSA_ERR err = M4NO_ERROR;
+ M4_MediaTime ts;
M4VIFI_ImagePlane *pTmp = M4OSA_NULL;
+ M4VIFI_ImagePlane *pLastDecodedFrame = M4OSA_NULL ;
+ M4VIFI_ImagePlane *pDecoderRenderFrame = M4OSA_NULL;
M4VIFI_ImagePlane pTemp1[3],pTemp2[3];
- M4OSA_UInt32 i =0;
+ M4VIFI_ImagePlane pTempPlaneClip1[3],pTempPlaneClip2[3];
+ M4OSA_UInt32 i = 0;
+
/**
* VPP context is actually the VSS3GPP context */
M4VSS3GPP_InternalEditContext *pC =
(M4VSS3GPP_InternalEditContext *)pContext;
- pTemp1[0].pac_data = pTemp2[0].pac_data = M4OSA_NULL;
+
+ memset((void *)pTemp1, 0, 3*sizeof(M4VIFI_ImagePlane));
+ memset((void *)pTemp2, 0, 3*sizeof(M4VIFI_ImagePlane));
+ memset((void *)pTempPlaneClip1, 0, 3*sizeof(M4VIFI_ImagePlane));
+ memset((void *)pTempPlaneClip2, 0, 3*sizeof(M4VIFI_ImagePlane));
+
/**
* Reset VPP error remembered in context */
pC->ewc.VppError = M4NO_ERROR;
@@ -1098,134 +1178,84 @@
}
/**
- * Compute the time in the clip1 base: t = to - Offset */
+ * Compute the time in the clip1 base: ts = to - Offset */
// Decorrelate input and output encoding timestamp to handle encoder prefetch
- t = pC->ewc.dInputVidCts - pC->pC1->iVoffset;
+ ts = pC->ewc.dInputVidCts - pC->pC1->iVoffset;
/**
* Render Clip1 */
if( pC->pC1->isRenderDup == M4OSA_FALSE )
{
- if(pC->nbActiveEffects > 0)
- {
- err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(pC->pC1->pViDecCtxt,
- &t, pTemp1,
- M4OSA_TRUE);
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: m_pVideoDecoder->m_pFctRender(C1) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->bIssecondClip = M4OSA_FALSE;
- err = M4VSS3GPP_intApplyVideoEffect(pC, pTemp1 ,pC->yuv1 );
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: M4VSS3GPP_intApplyVideoEffect(1) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->pC1->lastDecodedPlane = pTemp1;
+ pC->bIssecondClip = M4OSA_FALSE;
+
+ err = M4VSS3GPP_intRenderFrameWithEffect(pC, pC->pC1, M4OSA_TRUE,
+ pTempPlaneClip1, pTemp1,
+ pPlaneOut);
+ if ((M4NO_ERROR != err) &&
+ (M4WAR_VIDEORENDERER_NO_NEW_FRAME != err)) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ M4VSS3GPP_intRenderFrameWithEffect returns 0x%x", err);
+ pC->ewc.VppError = err;
+ /** Return no error to the encoder core
+ * else it may leak in some situations.*/
+ return M4NO_ERROR;
}
- else
- {
- err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(pC->pC1->pViDecCtxt,
- &t, pC->yuv1,
- M4OSA_TRUE);
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: m_pVideoDecoder->m_pFctRender(C1) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->pC1->lastDecodedPlane = pC->yuv1;
- }
- pC->pC1->iVideoRenderCts = (M4OSA_Int32)t;
}
- else
- {
- /* Copy last decoded plane to output plane */
- memcpy((void *)pTmp[0].pac_data,
- (void *)pC->pC1->lastDecodedPlane[0].pac_data,
- (pTmp[0].u_height * pTmp[0].u_width));
- memcpy((void *)pTmp[1].pac_data,
- (void *)pC->pC1->lastDecodedPlane[1].pac_data,
- (pTmp[1].u_height * pTmp[1].u_width));
- memcpy((void *)pTmp[2].pac_data,
- (void *)pC->pC1->lastDecodedPlane[2].pac_data,
- (pTmp[2].u_height * pTmp[2].u_width));
+ if ((pC->pC1->isRenderDup == M4OSA_TRUE) ||
+ (M4WAR_VIDEORENDERER_NO_NEW_FRAME == err)) {
+ pTmp = pC->yuv1;
+ if (pC->pC1->lastDecodedPlane != M4NO_ERROR) {
+ /* Copy last decoded plane to output plane */
+ memcpy((void *)pTmp[0].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[0].pac_data,
+ (pTmp[0].u_height * pTmp[0].u_width));
+ memcpy((void *)pTmp[1].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[1].pac_data,
+ (pTmp[1].u_height * pTmp[1].u_width));
+ memcpy((void *)pTmp[2].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[2].pac_data,
+ (pTmp[2].u_height * pTmp[2].u_width));
+ }
pC->pC1->lastDecodedPlane = pTmp;
}
/**
- * Compute the time in the clip2 base: t = to - Offset */
+ * Compute the time in the clip2 base: ts = to - Offset */
// Decorrelate input and output encoding timestamp to handle encoder prefetch
- t = pC->ewc.dInputVidCts - pC->pC2->iVoffset;
+ ts = pC->ewc.dInputVidCts - pC->pC2->iVoffset;
/**
* Render Clip2 */
if( pC->pC2->isRenderDup == M4OSA_FALSE )
{
- if(pC->nbActiveEffects1 > 0)
- {
- err = pC->pC2->ShellAPI.m_pVideoDecoder->m_pFctRender(pC->pC2->pViDecCtxt,
- &t, pTemp2,
- M4OSA_TRUE);
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: m_pVideoDecoder->m_pFctRender(C2) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->bIssecondClip = M4OSA_TRUE;
- err = M4VSS3GPP_intApplyVideoEffect(pC, pTemp2 ,pC->yuv2);
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: M4VSS3GPP_intApplyVideoEffect(1) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->pC2->lastDecodedPlane = pTemp2;
+ err = M4VSS3GPP_intRenderFrameWithEffect(pC, pC->pC2, M4OSA_FALSE,
+ pTempPlaneClip2, pTemp2,
+ pPlaneOut);
+ if ((M4NO_ERROR != err) &&
+ (M4WAR_VIDEORENDERER_NO_NEW_FRAME != err)) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ M4VSS3GPP_intRenderFrameWithEffect returns 0x%x", err);
+ pC->ewc.VppError = err;
+ /** Return no error to the encoder core
+ * else it may leak in some situations.*/
+ return M4NO_ERROR;
}
- else
- {
- err = pC->pC2->ShellAPI.m_pVideoDecoder->m_pFctRender(pC->pC2->pViDecCtxt,
- &t, pC->yuv2,
- M4OSA_TRUE);
- if (M4NO_ERROR != err)
- {
- M4OSA_TRACE1_1("M4VSS3GPP_intVPP: m_pVideoDecoder->m_pFctRender(C2) returns 0x%x, \
- returning M4NO_ERROR", err);
- pC->ewc.VppError = err;
- return M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
- }
- pC->pC2->lastDecodedPlane = pC->yuv2;
- }
- pC->pC2->iVideoRenderCts = (M4OSA_Int32)t;
}
- else
- {
- /* Copy last decoded plane to output plane */
- memcpy((void *)pTmp[0].pac_data,
- (void *)pC->pC2->lastDecodedPlane[0].pac_data,
- (pTmp[0].u_height * pTmp[0].u_width));
- memcpy((void *)pTmp[1].pac_data,
- (void *)pC->pC2->lastDecodedPlane[1].pac_data,
- (pTmp[1].u_height * pTmp[1].u_width));
- memcpy((void *)pTmp[2].pac_data,
- (void *)pC->pC2->lastDecodedPlane[2].pac_data,
- (pTmp[2].u_height * pTmp[2].u_width));
+ if ((pC->pC2->isRenderDup == M4OSA_TRUE) ||
+ (M4WAR_VIDEORENDERER_NO_NEW_FRAME == err)) {
+ pTmp = pC->yuv2;
+ if (pC->pC2->lastDecodedPlane != M4NO_ERROR) {
+ /* Copy last decoded plane to output plane */
+ memcpy((void *)pTmp[0].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[0].pac_data,
+ (pTmp[0].u_height * pTmp[0].u_width));
+ memcpy((void *)pTmp[1].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[1].pac_data,
+ (pTmp[1].u_height * pTmp[1].u_width));
+ memcpy((void *)pTmp[2].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[2].pac_data,
+ (pTmp[2].u_height * pTmp[2].u_width));
+ }
pC->pC2->lastDecodedPlane = pTmp;
}
@@ -1245,117 +1275,278 @@
}
for (i=0; i < 3; i++)
{
- if (pTemp2[i].pac_data != M4OSA_NULL)
- {
+ if(pTempPlaneClip2[i].pac_data != M4OSA_NULL) {
+ free(pTempPlaneClip2[i].pac_data);
+ pTempPlaneClip2[i].pac_data = M4OSA_NULL;
+ }
+
+ if(pTempPlaneClip1[i].pac_data != M4OSA_NULL) {
+ free(pTempPlaneClip1[i].pac_data);
+ pTempPlaneClip1[i].pac_data = M4OSA_NULL;
+ }
+
+ if (pTemp2[i].pac_data != M4OSA_NULL) {
free(pTemp2[i].pac_data);
pTemp2[i].pac_data = M4OSA_NULL;
}
-
- if (pTemp1[i].pac_data != M4OSA_NULL)
- {
- free(pTemp1[i].pac_data);
- pTemp1[i].pac_data = M4OSA_NULL;
- }
+ if (pTemp1[i].pac_data != M4OSA_NULL) {
+ free(pTemp1[i].pac_data);
+ pTemp1[i].pac_data = M4OSA_NULL;
}
+ }
}
/**
**************** No Transition case ****************/
else
{
+ M4OSA_TRACE3_0("M4VSS3GPP_intVPP: NO transition case");
/**
- * Check if there is a filter */
- if( pC->nbActiveEffects > 0 )
- {
+ * Compute the time in the clip base: ts = to - Offset */
+ ts = pC->ewc.dInputVidCts - pC->pC1->iVoffset;
+ /**
+ * Render */
+ if (pC->pC1->isRenderDup == M4OSA_FALSE) {
+ M4OSA_TRACE3_0("M4VSS3GPP_intVPP: renderdup false");
/**
- * If we do modify the image, we need an intermediate image plane */
- if( M4OSA_NULL == pC->yuv1[0].pac_data )
- {
- err =
- M4VSS3GPP_intAllocateYUV420(pC->yuv1, pC->ewc.uiVideoWidth,
- pC->ewc.uiVideoHeight);
-
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intVPP: M4VSS3GPP_intAllocateYUV420 returns 0x%x,\
- returning M4NO_ERROR",
- err);
+ * Check if resizing is needed */
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame) {
+ if ((pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (pC->nbActiveEffects == 0) &&
+ (pC->pC1->bGetYuvDataFromDecoder == M4OSA_FALSE)) {
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pC->pC1->pViDecCtxt,
+ M4DECODER_kOptionID_EnableYuvWithEffect,
+ (M4OSA_DataOption)M4OSA_TRUE);
+ if (M4NO_ERROR == err ) {
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pC->pC1->pViDecCtxt, &ts,
+ pPlaneOut, M4OSA_TRUE);
+ }
+ } else {
+ if (pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) {
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pC->pC1->pViDecCtxt,
+ M4DECODER_kOptionID_EnableYuvWithEffect,
+ (M4OSA_DataOption)M4OSA_FALSE);
+ }
+ if (M4NO_ERROR == err) {
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pC->pC1->pViDecCtxt, &ts,
+ pC->pC1->m_pPreResizeFrame, M4OSA_TRUE);
+ }
+ }
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ m_pFctRender() returns error 0x%x", err);
pC->ewc.VppError = err;
- return
- M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
+ return M4NO_ERROR;
+ }
+
+ if (pC->nbActiveEffects > 0) {
+ pC->pC1->bGetYuvDataFromDecoder = M4OSA_TRUE;
+ /**
+ * If we do modify the image, we need an intermediate
+ * image plane */
+ if (M4OSA_NULL == pTemp1[0].pac_data) {
+ err = M4VSS3GPP_intAllocateYUV420(pTemp1,
+ pC->pC1->m_pPreResizeFrame[0].u_width,
+ pC->pC1->m_pPreResizeFrame[0].u_height);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ M4VSS3GPP_intAllocateYUV420 error 0x%x", err);
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+ err = M4VSS3GPP_intApplyVideoEffect(pC,
+ pC->pC1->m_pPreResizeFrame,pTemp1);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ M4VSS3GPP_intApplyVideoEffect() error 0x%x", err);
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ pDecoderRenderFrame= pTemp1;
+
+ } else {
+ pDecoderRenderFrame = pC->pC1->m_pPreResizeFrame;
+ }
+
+ pTmp = pPlaneOut;
+ if ((pC->pC1->bGetYuvDataFromDecoder == M4OSA_TRUE) ||
+ (pC->pC1->pSettings->FileType !=
+ M4VIDEOEDITING_kFileType_ARGB8888)) {
+
+ err = M4VSS3GPP_intApplyRenderingMode(pC,
+ pC->pC1->pSettings->xVSS.MediaRendering,
+ pDecoderRenderFrame, pTmp);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intVPP: \
+ M4VSS3GPP_intApplyRenderingMode) error 0x%x ", err);
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+
+ if ((pC->pC1->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (pC->nbActiveEffects == 0) &&
+ (pC->pC1->bGetYuvDataFromDecoder == M4OSA_TRUE)) {
+
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pC->pC1->pViDecCtxt,
+ M4DECODER_kOptionID_YuvWithEffectNonContiguous,
+ (M4OSA_DataOption)pTmp);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ pC->pC1->bGetYuvDataFromDecoder = M4OSA_FALSE;
}
}
- /**
- * The image is rendered in the intermediate image plane */
- pTmp = pC->yuv1;
- }
- else
- {
- /**
- * No filter, the image is directly rendered in pPlaneOut */
- pTmp = pPlaneOut;
- }
-
- /**
- * Compute the time in the clip base: t = to - Offset */
- // Decorrelate input and output encoding timestamp to handle encoder prefetch
- t = pC->ewc.dInputVidCts - pC->pC1->iVoffset;
-
- if( pC->pC1->isRenderDup == M4OSA_FALSE )
- {
- err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(
- pC->pC1->pViDecCtxt, &t, pTmp, M4OSA_TRUE);
-
- if( M4NO_ERROR != err )
+ else
{
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intVPP: m_pVideoDecoder->m_pFctRender returns 0x%x,\
- returning M4NO_ERROR",
- err);
- pC->ewc.VppError = err;
- return
- M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
+ M4OSA_TRACE3_0("M4VSS3GPP_intVPP: NO resize required");
+ if (pC->nbActiveEffects > 0) {
+ /** If we do modify the image, we need an
+ * intermediate image plane */
+ if (M4OSA_NULL == pTemp1[0].pac_data) {
+ err = M4VSS3GPP_intAllocateYUV420(pTemp1,
+ pC->ewc.uiVideoWidth,
+ pC->ewc.uiVideoHeight);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+ pDecoderRenderFrame = pTemp1;
+ }
+ else {
+ pDecoderRenderFrame = pPlaneOut;
+ }
+
+ pTmp = pPlaneOut;
+ err = pC->pC1->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pC->pC1->pViDecCtxt, &ts,
+ pDecoderRenderFrame, M4OSA_TRUE);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+
+ if (pC->nbActiveEffects > 0) {
+ err = M4VSS3GPP_intApplyVideoEffect(pC,
+ pDecoderRenderFrame,pPlaneOut);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
}
pC->pC1->lastDecodedPlane = pTmp;
- pC->pC1->iVideoRenderCts = (M4OSA_Int32)t;
- }
- else
- {
- /* Copy last decoded plane to output plane */
- memcpy((void *)pTmp[0].pac_data,
- (void *)pC->pC1->lastDecodedPlane[0].pac_data,
- (pTmp[0].u_height * pTmp[0].u_width));
- memcpy((void *)pTmp[1].pac_data,
- (void *)pC->pC1->lastDecodedPlane[1].pac_data,
- (pTmp[1].u_height * pTmp[1].u_width));
- memcpy((void *)pTmp[2].pac_data,
- (void *)pC->pC1->lastDecodedPlane[2].pac_data,
- (pTmp[2].u_height * pTmp[2].u_width));
+ pC->pC1->iVideoRenderCts = (M4OSA_Int32)ts;
+
+ } else {
+ M4OSA_TRACE3_0("M4VSS3GPP_intVPP: renderdup true");
+
+ if (M4OSA_NULL != pC->pC1->m_pPreResizeFrame) {
+ /**
+ * Copy last decoded plane to output plane */
+ memcpy((void *)pC->pC1->m_pPreResizeFrame[0].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[0].pac_data,
+ (pC->pC1->m_pPreResizeFrame[0].u_height * pC->pC1->m_pPreResizeFrame[0].u_width));
+
+ memcpy((void *)pC->pC1->m_pPreResizeFrame[1].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[1].pac_data,
+ (pC->pC1->m_pPreResizeFrame[1].u_height * pC->pC1->m_pPreResizeFrame[1].u_width));
+
+ memcpy((void *)pC->pC1->m_pPreResizeFrame[2].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[2].pac_data,
+ (pC->pC1->m_pPreResizeFrame[2].u_height * pC->pC1->m_pPreResizeFrame[2].u_width));
+
+ if(pC->nbActiveEffects > 0) {
+ /**
+ * If we do modify the image, we need an
+ * intermediate image plane */
+ if (M4OSA_NULL == pTemp1[0].pac_data) {
+ err = M4VSS3GPP_intAllocateYUV420(pTemp1,
+ pC->pC1->m_pPreResizeFrame[0].u_width,
+ pC->pC1->m_pPreResizeFrame[0].u_height);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+
+ err = M4VSS3GPP_intApplyVideoEffect(pC,
+ pC->pC1->m_pPreResizeFrame,pTemp1);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ pDecoderRenderFrame= pTemp1;
+
+ } else {
+ pDecoderRenderFrame = pC->pC1->m_pPreResizeFrame;
+ }
+
+ pTmp = pPlaneOut;
+ err = M4VSS3GPP_intApplyRenderingMode(pC,
+ pC->pC1->pSettings->xVSS.MediaRendering,
+ pDecoderRenderFrame, pTmp);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ } else {
+
+ if (M4OSA_NULL == pTemp1[0].pac_data) {
+ err = M4VSS3GPP_intAllocateYUV420(pTemp1,
+ pC->ewc.uiVideoWidth,
+ pC->ewc.uiVideoHeight);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+ /**
+ * Copy last decoded plane to output plane */
+ memcpy((void *)pLastDecodedFrame[0].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[0].pac_data,
+ (pLastDecodedFrame[0].u_height * pLastDecodedFrame[0].u_width));
+
+ memcpy((void *)pLastDecodedFrame[1].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[1].pac_data,
+ (pLastDecodedFrame[1].u_height * pLastDecodedFrame[1].u_width));
+
+ memcpy((void *)pLastDecodedFrame[2].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[2].pac_data,
+ (pLastDecodedFrame[2].u_height * pLastDecodedFrame[2].u_width));
+
+ pTmp = pPlaneOut;
+ /**
+ * Check if there is a filter */
+ if(pC->nbActiveEffects > 0) {
+ err = M4VSS3GPP_intApplyVideoEffect(pC,
+ pLastDecodedFrame, pTmp);
+ if (M4NO_ERROR != err) {
+ pC->ewc.VppError = err;
+ return M4NO_ERROR;
+ }
+ }
+ }
pC->pC1->lastDecodedPlane = pTmp;
}
- M4OSA_TRACE3_1("M4VSS3GPP_intVPP: Rendered at CTS %.3f", t);
+ M4OSA_TRACE3_1("M4VSS3GPP_intVPP: Rendered at CTS %.3f", ts);
- /**
- * Apply the clip1 effect */
- // if (pC->iClip1ActiveEffect >= 0)
- if( pC->nbActiveEffects > 0 )
- {
- err = M4VSS3GPP_intApplyVideoEffect(pC,/*1,*/ pC->yuv1, pPlaneOut);
-
- if( M4NO_ERROR != err )
- {
- M4OSA_TRACE1_1(
- "M4VSS3GPP_intVPP: M4VSS3GPP_intApplyVideoEffect(1) returns 0x%x,\
- returning M4NO_ERROR",
- err);
- pC->ewc.VppError = err;
- return
- M4NO_ERROR; /**< Return no error to the encoder core
- (else it may leak in some situations...) */
+ for(i=0;i<3;i++) {
+ if(pTemp1[i].pac_data != M4OSA_NULL) {
+ free(pTemp1[i].pac_data);
+ pTemp1[i].pac_data = M4OSA_NULL;
}
}
}
@@ -1394,6 +1585,7 @@
M4VIFI_ImagePlane *pPlaneTempIn;
M4VIFI_ImagePlane *pPlaneTempOut;
+ M4VIFI_ImagePlane pTempYuvPlane[3];
M4OSA_UInt8 i;
M4OSA_UInt8 NumActiveEffects =0;
@@ -1408,12 +1600,14 @@
NumActiveEffects = pC->nbActiveEffects;
}
+ memset((void *)pTempYuvPlane, 0, 3*sizeof(M4VIFI_ImagePlane));
+
/**
* Allocate temporary plane if needed RC */
- if (M4OSA_NULL == pC->yuv4[0].pac_data && NumActiveEffects > 1)
+ if (M4OSA_NULL == pTempYuvPlane[0].pac_data && NumActiveEffects > 1)
{
- err = M4VSS3GPP_intAllocateYUV420(pC->yuv4, pC->ewc.uiVideoWidth,
- pC->ewc.uiVideoHeight);
+ err = M4VSS3GPP_intAllocateYUV420(pTempYuvPlane, pPlaneOut->u_width,
+ pPlaneOut->u_height);
if( M4NO_ERROR != err )
{
@@ -1431,7 +1625,7 @@
if (NumActiveEffects % 2 == 0)
{
pPlaneTempIn = pPlaneIn;
- pPlaneTempOut = pC->yuv4;
+ pPlaneTempOut = pTempYuvPlane;
}
else
{
@@ -1574,13 +1768,20 @@
if (((i % 2 == 0) && (NumActiveEffects % 2 == 0))
|| ((i % 2 != 0) && (NumActiveEffects % 2 != 0)))
{
- pPlaneTempIn = pC->yuv4;
+ pPlaneTempIn = pTempYuvPlane;
pPlaneTempOut = pPlaneOut;
}
else
{
pPlaneTempIn = pPlaneOut;
- pPlaneTempOut = pC->yuv4;
+ pPlaneTempOut = pTempYuvPlane;
+ }
+ }
+
+ for(i=0; i<3; i++) {
+ if(pTempYuvPlane[i].pac_data != M4OSA_NULL) {
+ free(pTempYuvPlane[i].pac_data);
+ pTempYuvPlane[i].pac_data = M4OSA_NULL;
}
}
@@ -1908,7 +2109,11 @@
M4OSA_Int32 t = (M4OSA_Int32)pC->ewc.dInputVidCts;
uiClipIndex = pC->uiCurrentClip;
- pClip = pC->pC1;
+ if (uiClipNumber == 1) {
+ pClip = pC->pC1;
+ } else {
+ pClip = pC->pC2;
+ }
/**
* Shortcuts for code readability */
Off = pClip->iVoffset;
@@ -1948,13 +2153,8 @@
{
pC->m_bClipExternalHasStarted = M4OSA_TRUE;
}
-
- /**
- * The third effect has the highest priority, then the
- * second one, then the first one. Hence, as soon as we
- * found an active effect, we can get out of this loop.
- */
}
+
}
else
{
@@ -1983,9 +2183,14 @@
* Hence, as soon as we found an active effect, we can get out of this loop */
}
}
+ if (M4VIDEOEDITING_kH264 !=
+ pC->pC1->pSettings->ClipProperties.VideoStreamType) {
+
+ // For Mpeg4 and H263 clips, full decode encode not required
+ pC->m_bClipExternalHasStarted = M4OSA_FALSE;
+ }
}
}
-
if(1==uiClipNumber)
{
/**
@@ -2160,15 +2365,8 @@
if( pC->bIsMMS == M4OSA_FALSE )
{
- /* Compute max bitrate depending on input files bitrates and transitions */
- if( pC->Vstate == M4VSS3GPP_kEditVideoState_TRANSITION )
- {
- EncParams.Bitrate = pC->ewc.uiVideoBitrate;
- }
- else
- {
- EncParams.Bitrate = pC->ewc.uiVideoBitrate;
- }
+ EncParams.Bitrate = pC->xVSS.outputVideoBitrate;
+
}
else
{
@@ -2497,6 +2695,8 @@
M4OSA_TRACE1_0(
"M4VSS3GPP_intAllocateYUV420: unable to allocate pPlanes[1].pac_data,\
returning M4ERR_ALLOC");
+ free((void *)pPlanes[0].pac_data);
+ pPlanes[0].pac_data = M4OSA_NULL;
return M4ERR_ALLOC;
}
@@ -2512,11 +2712,774 @@
M4OSA_TRACE1_0(
"M4VSS3GPP_intAllocateYUV420: unable to allocate pPlanes[2].pac_data,\
returning M4ERR_ALLOC");
+ free((void *)pPlanes[0].pac_data);
+ free((void *)pPlanes[1].pac_data);
+ pPlanes[0].pac_data = M4OSA_NULL;
+ pPlanes[1].pac_data = M4OSA_NULL;
return M4ERR_ALLOC;
}
+ memset((void *)pPlanes[0].pac_data, 0, pPlanes[0].u_stride*pPlanes[0].u_height);
+ memset((void *)pPlanes[1].pac_data, 0, pPlanes[1].u_stride*pPlanes[1].u_height);
+ memset((void *)pPlanes[2].pac_data, 0, pPlanes[2].u_stride*pPlanes[2].u_height);
/**
* Return */
M4OSA_TRACE3_0("M4VSS3GPP_intAllocateYUV420: returning M4NO_ERROR");
return M4NO_ERROR;
}
+
+/**
+******************************************************************************
+* M4OSA_ERR M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420(M4OSA_Void* pFileIn,
+* M4OSA_FileReadPointer* pFileReadPtr,
+* M4VIFI_ImagePlane* pImagePlanes,
+* M4OSA_UInt32 width,
+* M4OSA_UInt32 height);
+* @brief It Coverts and resizes a ARGB8888 image to YUV420
+* @note
+* @param pFileIn (IN) The ARGB888 input file
+* @param pFileReadPtr (IN) Pointer on filesystem functions
+* @param pImagePlanes (IN/OUT) Pointer on YUV420 output planes allocated by the user.
+* ARGB8888 image will be converted and resized to output
+* YUV420 plane size
+* @param width (IN) width of the ARGB8888
+* @param height (IN) height of the ARGB8888
+* @return M4NO_ERROR: No error
+* @return M4ERR_ALLOC: memory error
+* @return M4ERR_PARAMETER: At least one of the function parameters is null
+******************************************************************************
+*/
+
+M4OSA_ERR M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420(M4OSA_Void* pFileIn,
+ M4OSA_FileReadPointer* pFileReadPtr,
+ M4VIFI_ImagePlane* pImagePlanes,
+ M4OSA_UInt32 width,M4OSA_UInt32 height) {
+ M4OSA_Context pARGBIn;
+ M4VIFI_ImagePlane rgbPlane1 ,rgbPlane2;
+ M4OSA_UInt32 frameSize_argb = width * height * 4;
+ M4OSA_UInt32 frameSize_rgb888 = width * height * 3;
+ M4OSA_UInt32 i = 0,j= 0;
+ M4OSA_ERR err = M4NO_ERROR;
+
+ M4OSA_UInt8 *pArgbPlane =
+ (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb,
+ M4VS, (M4OSA_Char*)"argb data");
+ if (pArgbPlane == M4OSA_NULL) {
+ M4OSA_TRACE1_0("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420: \
+ Failed to allocate memory for ARGB plane");
+ return M4ERR_ALLOC;
+ }
+
+ /* Get file size */
+ err = pFileReadPtr->openRead(&pARGBIn, pFileIn, M4OSA_kFileRead);
+ if (err != M4NO_ERROR) {
+ M4OSA_TRACE1_2("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 : \
+ Can not open input ARGB8888 file %s, error: 0x%x\n",pFileIn, err);
+ free(pArgbPlane);
+ pArgbPlane = M4OSA_NULL;
+ goto cleanup;
+ }
+
+ err = pFileReadPtr->readData(pARGBIn,(M4OSA_MemAddr8)pArgbPlane,
+ &frameSize_argb);
+ if (err != M4NO_ERROR) {
+ M4OSA_TRACE1_2("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 \
+ Can not read ARGB8888 file %s, error: 0x%x\n",pFileIn, err);
+ pFileReadPtr->closeRead(pARGBIn);
+ free(pArgbPlane);
+ pArgbPlane = M4OSA_NULL;
+ goto cleanup;
+ }
+
+ err = pFileReadPtr->closeRead(pARGBIn);
+ if(err != M4NO_ERROR) {
+ M4OSA_TRACE1_2("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 \
+ Can not close ARGB8888 file %s, error: 0x%x\n",pFileIn, err);
+ free(pArgbPlane);
+ pArgbPlane = M4OSA_NULL;
+ goto cleanup;
+ }
+
+ rgbPlane1.pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize_rgb888,
+ M4VS, (M4OSA_Char*)"RGB888 plane1");
+ if(rgbPlane1.pac_data == M4OSA_NULL) {
+ M4OSA_TRACE1_0("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 \
+ Failed to allocate memory for rgb plane1");
+ free(pArgbPlane);
+ return M4ERR_ALLOC;
+ }
+
+ rgbPlane1.u_height = height;
+ rgbPlane1.u_width = width;
+ rgbPlane1.u_stride = width*3;
+ rgbPlane1.u_topleft = 0;
+
+
+ /** Remove the alpha channel */
+ for (i=0, j = 0; i < frameSize_argb; i++) {
+ if ((i % 4) == 0) continue;
+ rgbPlane1.pac_data[j] = pArgbPlane[i];
+ j++;
+ }
+ free(pArgbPlane);
+
+ /**
+ * Check if resizing is required with color conversion */
+ if(width != pImagePlanes->u_width || height != pImagePlanes->u_height) {
+
+ frameSize_rgb888 = pImagePlanes->u_width * pImagePlanes->u_height * 3;
+ rgbPlane2.pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize_rgb888, M4VS,
+ (M4OSA_Char*)"rgb Plane2");
+ if(rgbPlane2.pac_data == M4OSA_NULL) {
+ M4OSA_TRACE1_0("Failed to allocate memory for rgb plane2");
+ free(rgbPlane1.pac_data);
+ return M4ERR_ALLOC;
+ }
+ rgbPlane2.u_height = pImagePlanes->u_height;
+ rgbPlane2.u_width = pImagePlanes->u_width;
+ rgbPlane2.u_stride = pImagePlanes->u_width*3;
+ rgbPlane2.u_topleft = 0;
+
+ /* Resizing */
+ err = M4VIFI_ResizeBilinearRGB888toRGB888(M4OSA_NULL,
+ &rgbPlane1, &rgbPlane2);
+ free(rgbPlane1.pac_data);
+ if(err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("error resizing RGB888 to RGB888: 0x%x\n", err);
+ free(rgbPlane2.pac_data);
+ return err;
+ }
+
+ /*Converting Resized RGB888 to YUV420 */
+ err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane2, pImagePlanes);
+ free(rgbPlane2.pac_data);
+ if(err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("error converting from RGB888 to YUV: 0x%x\n", err);
+ return err;
+ }
+ } else {
+ err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane1, pImagePlanes);
+ if(err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("error when converting from RGB to YUV: 0x%x\n", err);
+ }
+ free(rgbPlane1.pac_data);
+ }
+cleanup:
+ M4OSA_TRACE3_0("M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 exit");
+ return err;
+}
+
+M4OSA_ERR M4VSS3GPP_intApplyRenderingMode(M4VSS3GPP_InternalEditContext *pC,
+ M4xVSS_MediaRendering renderingMode,
+ M4VIFI_ImagePlane* pInplane,
+ M4VIFI_ImagePlane* pOutplane) {
+
+ M4OSA_ERR err = M4NO_ERROR;
+ M4AIR_Params airParams;
+ M4VIFI_ImagePlane pImagePlanesTemp[3];
+ M4OSA_UInt32 i = 0;
+
+ if (renderingMode == M4xVSS_kBlackBorders) {
+ memset((void *)pOutplane[0].pac_data, Y_PLANE_BORDER_VALUE,
+ (pOutplane[0].u_height*pOutplane[0].u_stride));
+ memset((void *)pOutplane[1].pac_data, U_PLANE_BORDER_VALUE,
+ (pOutplane[1].u_height*pOutplane[1].u_stride));
+ memset((void *)pOutplane[2].pac_data, V_PLANE_BORDER_VALUE,
+ (pOutplane[2].u_height*pOutplane[2].u_stride));
+ }
+
+ if (renderingMode == M4xVSS_kResizing) {
+ /**
+ * Call the resize filter.
+ * From the intermediate frame to the encoder image plane */
+ err = M4VIFI_ResizeBilinearYUV420toYUV420(M4OSA_NULL,
+ pInplane, pOutplane);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intApplyRenderingMode: \
+ M4ViFilResizeBilinearYUV420toYUV420 returns 0x%x!", err);
+ return err;
+ }
+ } else {
+ M4VIFI_ImagePlane* pPlaneTemp = M4OSA_NULL;
+ M4OSA_UInt8* pOutPlaneY =
+ pOutplane[0].pac_data + pOutplane[0].u_topleft;
+ M4OSA_UInt8* pOutPlaneU =
+ pOutplane[1].pac_data + pOutplane[1].u_topleft;
+ M4OSA_UInt8* pOutPlaneV =
+ pOutplane[2].pac_data + pOutplane[2].u_topleft;
+ M4OSA_UInt8* pInPlaneY = M4OSA_NULL;
+ M4OSA_UInt8* pInPlaneU = M4OSA_NULL;
+ M4OSA_UInt8* pInPlaneV = M4OSA_NULL;
+
+ /* To keep media aspect ratio*/
+ /* Initialize AIR Params*/
+ airParams.m_inputCoord.m_x = 0;
+ airParams.m_inputCoord.m_y = 0;
+ airParams.m_inputSize.m_height = pInplane->u_height;
+ airParams.m_inputSize.m_width = pInplane->u_width;
+ airParams.m_outputSize.m_width = pOutplane->u_width;
+ airParams.m_outputSize.m_height = pOutplane->u_height;
+ airParams.m_bOutputStripe = M4OSA_FALSE;
+ airParams.m_outputOrientation = M4COMMON_kOrientationTopLeft;
+
+ /**
+ Media rendering: Black borders*/
+ if (renderingMode == M4xVSS_kBlackBorders) {
+ pImagePlanesTemp[0].u_width = pOutplane[0].u_width;
+ pImagePlanesTemp[0].u_height = pOutplane[0].u_height;
+ pImagePlanesTemp[0].u_stride = pOutplane[0].u_width;
+ pImagePlanesTemp[0].u_topleft = 0;
+
+ pImagePlanesTemp[1].u_width = pOutplane[1].u_width;
+ pImagePlanesTemp[1].u_height = pOutplane[1].u_height;
+ pImagePlanesTemp[1].u_stride = pOutplane[1].u_width;
+ pImagePlanesTemp[1].u_topleft = 0;
+
+ pImagePlanesTemp[2].u_width = pOutplane[2].u_width;
+ pImagePlanesTemp[2].u_height = pOutplane[2].u_height;
+ pImagePlanesTemp[2].u_stride = pOutplane[2].u_width;
+ pImagePlanesTemp[2].u_topleft = 0;
+
+ /**
+ * Allocates plan in local image plane structure */
+ pImagePlanesTemp[0].pac_data =
+ (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(
+ pImagePlanesTemp[0].u_width * pImagePlanesTemp[0].u_height,
+ M4VS, (M4OSA_Char *)"pImagePlaneTemp Y") ;
+ if (pImagePlanesTemp[0].pac_data == M4OSA_NULL) {
+ M4OSA_TRACE1_0("M4VSS3GPP_intApplyRenderingMode: Alloc Error");
+ return M4ERR_ALLOC;
+ }
+ pImagePlanesTemp[1].pac_data =
+ (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(
+ pImagePlanesTemp[1].u_width * pImagePlanesTemp[1].u_height,
+ M4VS, (M4OSA_Char *)"pImagePlaneTemp U") ;
+ if (pImagePlanesTemp[1].pac_data == M4OSA_NULL) {
+ M4OSA_TRACE1_0("M4VSS3GPP_intApplyRenderingMode: Alloc Error");
+ free(pImagePlanesTemp[0].pac_data);
+ return M4ERR_ALLOC;
+ }
+ pImagePlanesTemp[2].pac_data =
+ (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(
+ pImagePlanesTemp[2].u_width * pImagePlanesTemp[2].u_height,
+ M4VS, (M4OSA_Char *)"pImagePlaneTemp V") ;
+ if (pImagePlanesTemp[2].pac_data == M4OSA_NULL) {
+ M4OSA_TRACE1_0("M4VSS3GPP_intApplyRenderingMode: Alloc Error");
+ free(pImagePlanesTemp[0].pac_data);
+ free(pImagePlanesTemp[1].pac_data);
+ return M4ERR_ALLOC;
+ }
+
+ pInPlaneY = pImagePlanesTemp[0].pac_data ;
+ pInPlaneU = pImagePlanesTemp[1].pac_data ;
+ pInPlaneV = pImagePlanesTemp[2].pac_data ;
+
+ memset((void *)pImagePlanesTemp[0].pac_data, Y_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride));
+ memset((void *)pImagePlanesTemp[1].pac_data, U_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride));
+ memset((void *)pImagePlanesTemp[2].pac_data, V_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride));
+
+ M4OSA_UInt32 height =
+ (pInplane->u_height * pOutplane->u_width) /pInplane->u_width;
+
+ if (height <= pOutplane->u_height) {
+ /**
+ * Black borders will be on the top and the bottom side */
+ airParams.m_outputSize.m_width = pOutplane->u_width;
+ airParams.m_outputSize.m_height = height;
+ /**
+ * Number of lines at the top */
+ pImagePlanesTemp[0].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_height -
+ airParams.m_outputSize.m_height)>>1)) *
+ pImagePlanesTemp[0].u_stride;
+ pImagePlanesTemp[0].u_height = airParams.m_outputSize.m_height;
+ pImagePlanesTemp[1].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_height -
+ (airParams.m_outputSize.m_height>>1)))>>1) *
+ pImagePlanesTemp[1].u_stride;
+ pImagePlanesTemp[1].u_height =
+ airParams.m_outputSize.m_height>>1;
+ pImagePlanesTemp[2].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_height -
+ (airParams.m_outputSize.m_height>>1)))>>1) *
+ pImagePlanesTemp[2].u_stride;
+ pImagePlanesTemp[2].u_height =
+ airParams.m_outputSize.m_height>>1;
+ } else {
+ /**
+ * Black borders will be on the left and right side */
+ airParams.m_outputSize.m_height = pOutplane->u_height;
+ airParams.m_outputSize.m_width =
+ (M4OSA_UInt32)((pInplane->u_width * pOutplane->u_height)/pInplane->u_height);
+
+ pImagePlanesTemp[0].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_width -
+ airParams.m_outputSize.m_width)>>1));
+ pImagePlanesTemp[0].u_width = airParams.m_outputSize.m_width;
+ pImagePlanesTemp[1].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_width -
+ (airParams.m_outputSize.m_width>>1)))>>1);
+ pImagePlanesTemp[1].u_width = airParams.m_outputSize.m_width>>1;
+ pImagePlanesTemp[2].u_topleft =
+ (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_width -
+ (airParams.m_outputSize.m_width>>1)))>>1);
+ pImagePlanesTemp[2].u_width = airParams.m_outputSize.m_width>>1;
+ }
+
+ /**
+ * Width and height have to be even */
+ airParams.m_outputSize.m_width =
+ (airParams.m_outputSize.m_width>>1)<<1;
+ airParams.m_outputSize.m_height =
+ (airParams.m_outputSize.m_height>>1)<<1;
+ airParams.m_inputSize.m_width =
+ (airParams.m_inputSize.m_width>>1)<<1;
+ airParams.m_inputSize.m_height =
+ (airParams.m_inputSize.m_height>>1)<<1;
+ pImagePlanesTemp[0].u_width =
+ (pImagePlanesTemp[0].u_width>>1)<<1;
+ pImagePlanesTemp[1].u_width =
+ (pImagePlanesTemp[1].u_width>>1)<<1;
+ pImagePlanesTemp[2].u_width =
+ (pImagePlanesTemp[2].u_width>>1)<<1;
+ pImagePlanesTemp[0].u_height =
+ (pImagePlanesTemp[0].u_height>>1)<<1;
+ pImagePlanesTemp[1].u_height =
+ (pImagePlanesTemp[1].u_height>>1)<<1;
+ pImagePlanesTemp[2].u_height =
+ (pImagePlanesTemp[2].u_height>>1)<<1;
+
+ /**
+ * Check that values are coherent */
+ if (airParams.m_inputSize.m_height ==
+ airParams.m_outputSize.m_height) {
+ airParams.m_inputSize.m_width =
+ airParams.m_outputSize.m_width;
+ } else if (airParams.m_inputSize.m_width ==
+ airParams.m_outputSize.m_width) {
+ airParams.m_inputSize.m_height =
+ airParams.m_outputSize.m_height;
+ }
+ pPlaneTemp = pImagePlanesTemp;
+ }
+
+ /**
+ * Media rendering: Cropping*/
+ if (renderingMode == M4xVSS_kCropping) {
+ airParams.m_outputSize.m_height = pOutplane->u_height;
+ airParams.m_outputSize.m_width = pOutplane->u_width;
+ if ((airParams.m_outputSize.m_height *
+ airParams.m_inputSize.m_width)/airParams.m_outputSize.m_width <
+ airParams.m_inputSize.m_height) {
+ /* Height will be cropped */
+ airParams.m_inputSize.m_height =
+ (M4OSA_UInt32)((airParams.m_outputSize.m_height *
+ airParams.m_inputSize.m_width)/airParams.m_outputSize.m_width);
+ airParams.m_inputSize.m_height =
+ (airParams.m_inputSize.m_height>>1)<<1;
+ airParams.m_inputCoord.m_y =
+ (M4OSA_Int32)((M4OSA_Int32)((pInplane->u_height -
+ airParams.m_inputSize.m_height))>>1);
+ } else {
+ /* Width will be cropped */
+ airParams.m_inputSize.m_width =
+ (M4OSA_UInt32)((airParams.m_outputSize.m_width *
+ airParams.m_inputSize.m_height)/airParams.m_outputSize.m_height);
+ airParams.m_inputSize.m_width =
+ (airParams.m_inputSize.m_width>>1)<<1;
+ airParams.m_inputCoord.m_x =
+ (M4OSA_Int32)((M4OSA_Int32)((pInplane->u_width -
+ airParams.m_inputSize.m_width))>>1);
+ }
+ pPlaneTemp = pOutplane;
+ }
+ /**
+ * Call AIR functions */
+ if (M4OSA_NULL == pC->m_air_context) {
+ err = M4AIR_create(&pC->m_air_context, M4AIR_kYUV420P);
+ if(err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intApplyRenderingMode: \
+ M4AIR_create returned error 0x%x", err);
+ goto cleanUp;
+ }
+ }
+
+ err = M4AIR_configure(pC->m_air_context, &airParams);
+ if (err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intApplyRenderingMode: \
+ Error when configuring AIR: 0x%x", err);
+ M4AIR_cleanUp(pC->m_air_context);
+ goto cleanUp;
+ }
+
+ err = M4AIR_get(pC->m_air_context, pInplane, pPlaneTemp);
+ if (err != M4NO_ERROR) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intApplyRenderingMode: \
+ Error when getting AIR plane: 0x%x", err);
+ M4AIR_cleanUp(pC->m_air_context);
+ goto cleanUp;
+ }
+
+ if (renderingMode == M4xVSS_kBlackBorders) {
+ for (i=0; i<pOutplane[0].u_height; i++) {
+ memcpy((void *)pOutPlaneY, (void *)pInPlaneY,
+ pOutplane[0].u_width);
+ pInPlaneY += pOutplane[0].u_width;
+ pOutPlaneY += pOutplane[0].u_stride;
+ }
+ for (i=0; i<pOutplane[1].u_height; i++) {
+ memcpy((void *)pOutPlaneU, (void *)pInPlaneU,
+ pOutplane[1].u_width);
+ pInPlaneU += pOutplane[1].u_width;
+ pOutPlaneU += pOutplane[1].u_stride;
+ }
+ for (i=0; i<pOutplane[2].u_height; i++) {
+ memcpy((void *)pOutPlaneV, (void *)pInPlaneV,
+ pOutplane[2].u_width);
+ pInPlaneV += pOutplane[2].u_width;
+ pOutPlaneV += pOutplane[2].u_stride;
+ }
+ }
+ }
+cleanUp:
+ if (renderingMode == M4xVSS_kBlackBorders) {
+ for (i=0; i<3; i++) {
+ if (pImagePlanesTemp[i].pac_data != M4OSA_NULL) {
+ free(pImagePlanesTemp[i].pac_data);
+ pImagePlanesTemp[i].pac_data = M4OSA_NULL;
+ }
+ }
+ }
+ return err;
+}
+
+M4OSA_ERR M4VSS3GPP_intSetYuv420PlaneFromARGB888 (
+ M4VSS3GPP_InternalEditContext *pC,
+ M4VSS3GPP_ClipContext* pClipCtxt) {
+
+ M4OSA_ERR err= M4NO_ERROR;
+
+ // Allocate memory for YUV plane
+ pClipCtxt->pPlaneYuv =
+ (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(
+ 3*sizeof(M4VIFI_ImagePlane), M4VS,
+ (M4OSA_Char*)"pPlaneYuv");
+
+ if (pClipCtxt->pPlaneYuv == M4OSA_NULL) {
+ return M4ERR_ALLOC;
+ }
+
+ pClipCtxt->pPlaneYuv[0].u_height =
+ pClipCtxt->pSettings->ClipProperties.uiStillPicHeight;
+ pClipCtxt->pPlaneYuv[0].u_width =
+ pClipCtxt->pSettings->ClipProperties.uiStillPicWidth;
+ pClipCtxt->pPlaneYuv[0].u_stride = pClipCtxt->pPlaneYuv[0].u_width;
+ pClipCtxt->pPlaneYuv[0].u_topleft = 0;
+
+ pClipCtxt->pPlaneYuv[0].pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(
+ pClipCtxt->pPlaneYuv[0].u_height * pClipCtxt->pPlaneYuv[0].u_width * 1.5,
+ M4VS, (M4OSA_Char*)"imageClip YUV data");
+ if (pClipCtxt->pPlaneYuv[0].pac_data == M4OSA_NULL) {
+ free(pClipCtxt->pPlaneYuv);
+ return M4ERR_ALLOC;
+ }
+
+ pClipCtxt->pPlaneYuv[1].u_height = pClipCtxt->pPlaneYuv[0].u_height >>1;
+ pClipCtxt->pPlaneYuv[1].u_width = pClipCtxt->pPlaneYuv[0].u_width >> 1;
+ pClipCtxt->pPlaneYuv[1].u_stride = pClipCtxt->pPlaneYuv[1].u_width;
+ pClipCtxt->pPlaneYuv[1].u_topleft = 0;
+ pClipCtxt->pPlaneYuv[1].pac_data = (M4VIFI_UInt8*)(
+ pClipCtxt->pPlaneYuv[0].pac_data +
+ pClipCtxt->pPlaneYuv[0].u_height * pClipCtxt->pPlaneYuv[0].u_width);
+
+ pClipCtxt->pPlaneYuv[2].u_height = pClipCtxt->pPlaneYuv[0].u_height >>1;
+ pClipCtxt->pPlaneYuv[2].u_width = pClipCtxt->pPlaneYuv[0].u_width >> 1;
+ pClipCtxt->pPlaneYuv[2].u_stride = pClipCtxt->pPlaneYuv[2].u_width;
+ pClipCtxt->pPlaneYuv[2].u_topleft = 0;
+ pClipCtxt->pPlaneYuv[2].pac_data = (M4VIFI_UInt8*)(
+ pClipCtxt->pPlaneYuv[1].pac_data +
+ pClipCtxt->pPlaneYuv[1].u_height * pClipCtxt->pPlaneYuv[1].u_width);
+
+ err = M4VSS3GPP_internalConvertAndResizeARGB8888toYUV420 (
+ pClipCtxt->pSettings->pFile,
+ pC->pOsaFileReadPtr,
+ pClipCtxt->pPlaneYuv,
+ pClipCtxt->pSettings->ClipProperties.uiStillPicWidth,
+ pClipCtxt->pSettings->ClipProperties.uiStillPicHeight);
+ if (M4NO_ERROR != err) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ free(pClipCtxt->pPlaneYuv);
+ return err;
+ }
+
+ // Set the YUV data to the decoder using setoption
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption (
+ pClipCtxt->pViDecCtxt,
+ M4DECODER_kOptionID_DecYuvData,
+ (M4OSA_DataOption)pClipCtxt->pPlaneYuv);
+ if (M4NO_ERROR != err) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ free(pClipCtxt->pPlaneYuv);
+ return err;
+ }
+
+ pClipCtxt->pSettings->ClipProperties.bSetImageData = M4OSA_TRUE;
+
+ // Allocate Yuv plane with effect
+ pClipCtxt->pPlaneYuvWithEffect =
+ (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(
+ 3*sizeof(M4VIFI_ImagePlane), M4VS,
+ (M4OSA_Char*)"pPlaneYuvWithEffect");
+ if (pClipCtxt->pPlaneYuvWithEffect == M4OSA_NULL) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ free(pClipCtxt->pPlaneYuv);
+ return M4ERR_ALLOC;
+ }
+
+ pClipCtxt->pPlaneYuvWithEffect[0].u_height = pC->ewc.uiVideoHeight;
+ pClipCtxt->pPlaneYuvWithEffect[0].u_width = pC->ewc.uiVideoWidth;
+ pClipCtxt->pPlaneYuvWithEffect[0].u_stride = pC->ewc.uiVideoWidth;
+ pClipCtxt->pPlaneYuvWithEffect[0].u_topleft = 0;
+
+ pClipCtxt->pPlaneYuvWithEffect[0].pac_data =
+ (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(
+ pC->ewc.uiVideoHeight * pC->ewc.uiVideoWidth * 1.5,
+ M4VS, (M4OSA_Char*)"imageClip YUV data");
+ if (pClipCtxt->pPlaneYuvWithEffect[0].pac_data == M4OSA_NULL) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ free(pClipCtxt->pPlaneYuv);
+ free(pClipCtxt->pPlaneYuvWithEffect);
+ return M4ERR_ALLOC;
+ }
+
+ pClipCtxt->pPlaneYuvWithEffect[1].u_height =
+ pClipCtxt->pPlaneYuvWithEffect[0].u_height >>1;
+ pClipCtxt->pPlaneYuvWithEffect[1].u_width =
+ pClipCtxt->pPlaneYuvWithEffect[0].u_width >> 1;
+ pClipCtxt->pPlaneYuvWithEffect[1].u_stride =
+ pClipCtxt->pPlaneYuvWithEffect[1].u_width;
+ pClipCtxt->pPlaneYuvWithEffect[1].u_topleft = 0;
+ pClipCtxt->pPlaneYuvWithEffect[1].pac_data = (M4VIFI_UInt8*)(
+ pClipCtxt->pPlaneYuvWithEffect[0].pac_data +
+ pClipCtxt->pPlaneYuvWithEffect[0].u_height * pClipCtxt->pPlaneYuvWithEffect[0].u_width);
+
+ pClipCtxt->pPlaneYuvWithEffect[2].u_height =
+ pClipCtxt->pPlaneYuvWithEffect[0].u_height >>1;
+ pClipCtxt->pPlaneYuvWithEffect[2].u_width =
+ pClipCtxt->pPlaneYuvWithEffect[0].u_width >> 1;
+ pClipCtxt->pPlaneYuvWithEffect[2].u_stride =
+ pClipCtxt->pPlaneYuvWithEffect[2].u_width;
+ pClipCtxt->pPlaneYuvWithEffect[2].u_topleft = 0;
+ pClipCtxt->pPlaneYuvWithEffect[2].pac_data = (M4VIFI_UInt8*)(
+ pClipCtxt->pPlaneYuvWithEffect[1].pac_data +
+ pClipCtxt->pPlaneYuvWithEffect[1].u_height * pClipCtxt->pPlaneYuvWithEffect[1].u_width);
+
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pClipCtxt->pViDecCtxt, M4DECODER_kOptionID_YuvWithEffectContiguous,
+ (M4OSA_DataOption)pClipCtxt->pPlaneYuvWithEffect);
+ if (M4NO_ERROR != err) {
+ free(pClipCtxt->pPlaneYuv[0].pac_data);
+ free(pClipCtxt->pPlaneYuv);
+ free(pClipCtxt->pPlaneYuvWithEffect);
+ return err;
+ }
+
+ return M4NO_ERROR;
+}
+
+M4OSA_ERR M4VSS3GPP_intRenderFrameWithEffect(M4VSS3GPP_InternalEditContext *pC,
+ M4VSS3GPP_ClipContext* pClipCtxt,
+ M4OSA_Bool bIsClip1,
+ M4VIFI_ImagePlane *pResizePlane,
+ M4VIFI_ImagePlane *pPlaneNoResize,
+ M4VIFI_ImagePlane *pPlaneOut) {
+
+ M4OSA_ERR err = M4NO_ERROR;
+ M4OSA_UInt8 numEffects = 0;
+ M4_MediaTime ts;
+ M4VIFI_ImagePlane *pDecoderRenderFrame = M4OSA_NULL;
+
+ /**
+ Check if resizing is needed */
+ if (M4OSA_NULL != pClipCtxt->m_pPreResizeFrame) {
+ /**
+ * If we do modify the image, we need an intermediate image plane */
+ if (M4OSA_NULL == pResizePlane[0].pac_data) {
+ err = M4VSS3GPP_intAllocateYUV420(pResizePlane,
+ pClipCtxt->m_pPreResizeFrame[0].u_width,
+ pClipCtxt->m_pPreResizeFrame[0].u_height);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ M4VSS3GPP_intAllocateYUV420 returns 0x%x", err);
+ return err;
+ }
+ }
+
+ if ((pClipCtxt->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (pC->nbActiveEffects == 0) &&
+ (pClipCtxt->bGetYuvDataFromDecoder == M4OSA_FALSE)) {
+
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pClipCtxt->pViDecCtxt,
+ M4DECODER_kOptionID_EnableYuvWithEffect,
+ (M4OSA_DataOption)M4OSA_TRUE);
+ if (M4NO_ERROR == err) {
+ pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pClipCtxt->pViDecCtxt, &ts,
+ pClipCtxt->pPlaneYuvWithEffect, M4OSA_TRUE);
+ }
+
+ } else {
+ if (pClipCtxt->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pClipCtxt->pViDecCtxt,
+ M4DECODER_kOptionID_EnableYuvWithEffect,
+ (M4OSA_DataOption)M4OSA_FALSE);
+ }
+ if (M4NO_ERROR == err) {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pClipCtxt->pViDecCtxt, &ts,
+ pClipCtxt->m_pPreResizeFrame, M4OSA_TRUE);
+ }
+
+ }
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ returns error 0x%x", err);
+ return err;
+ }
+
+ if (bIsClip1 == M4OSA_TRUE) {
+ numEffects = pC->nbActiveEffects;
+ } else {
+ numEffects = pC->nbActiveEffects1;
+ }
+
+ if ( numEffects > 0) {
+ pClipCtxt->bGetYuvDataFromDecoder = M4OSA_TRUE;
+ err = M4VSS3GPP_intApplyVideoEffect(pC,
+ pClipCtxt->m_pPreResizeFrame, pResizePlane);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ M4VSS3GPP_intApplyVideoEffect() err 0x%x", err);
+ return err;
+ }
+
+ pDecoderRenderFrame= pResizePlane;
+
+ } else {
+ pDecoderRenderFrame = pClipCtxt->m_pPreResizeFrame;
+ }
+
+ if ((pClipCtxt->bGetYuvDataFromDecoder == M4OSA_TRUE) ||
+ (pClipCtxt->pSettings->FileType !=
+ M4VIDEOEDITING_kFileType_ARGB8888)) {
+ if (bIsClip1 == M4OSA_TRUE) {
+ err = M4VSS3GPP_intApplyRenderingMode (pC,
+ pClipCtxt->pSettings->xVSS.MediaRendering,
+ pDecoderRenderFrame,pC->yuv1);
+ } else {
+ err = M4VSS3GPP_intApplyRenderingMode (pC,
+ pClipCtxt->pSettings->xVSS.MediaRendering,
+ pDecoderRenderFrame,pC->yuv2);
+ }
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ M4VSS3GPP_intApplyRenderingMode error 0x%x ", err);
+ return err;
+ }
+
+ if (bIsClip1 == M4OSA_TRUE) {
+ pClipCtxt->lastDecodedPlane = pC->yuv1;
+ } else {
+ pClipCtxt->lastDecodedPlane = pC->yuv2;
+ }
+
+ } else {
+ pClipCtxt->lastDecodedPlane = pClipCtxt->pPlaneYuvWithEffect;
+ }
+
+ if ((pClipCtxt->pSettings->FileType ==
+ M4VIDEOEDITING_kFileType_ARGB8888) &&
+ (pC->nbActiveEffects == 0) &&
+ (pClipCtxt->bGetYuvDataFromDecoder == M4OSA_TRUE)) {
+ if (bIsClip1 == M4OSA_TRUE) {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pClipCtxt->pViDecCtxt,
+ M4DECODER_kOptionID_YuvWithEffectNonContiguous,
+ (M4OSA_DataOption)pC->yuv1);
+ } else {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctSetOption(
+ pClipCtxt->pViDecCtxt,
+ M4DECODER_kOptionID_YuvWithEffectNonContiguous,
+ (M4OSA_DataOption)pPlaneOut);
+ }
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ null decoder setOption error 0x%x ", err);
+ return err;
+ }
+ pClipCtxt->bGetYuvDataFromDecoder = M4OSA_FALSE;
+ }
+
+ } else {
+ if (bIsClip1 == M4OSA_TRUE) {
+ numEffects = pC->nbActiveEffects;
+ } else {
+ numEffects = pC->nbActiveEffects1;
+ }
+
+ if(numEffects > 0) {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pClipCtxt->pViDecCtxt, &ts, pPlaneNoResize, M4OSA_TRUE);
+
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ Render returns error 0x%x", err);
+ return err;
+ }
+ if (bIsClip1 == M4OSA_TRUE) {
+ pC->bIssecondClip = M4OSA_FALSE;
+ err = M4VSS3GPP_intApplyVideoEffect(pC, pPlaneNoResize ,pC->yuv1);
+ pClipCtxt->lastDecodedPlane = pC->yuv1;
+ } else {
+ pC->bIssecondClip = M4OSA_TRUE;
+ err = M4VSS3GPP_intApplyVideoEffect(pC, pPlaneNoResize ,pC->yuv2);
+ pClipCtxt->lastDecodedPlane = pC->yuv2;
+ }
+
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ M4VSS3GPP_intApplyVideoEffect error 0x%x", err);
+ return err;
+ }
+
+ } else {
+ if (bIsClip1 == M4OSA_TRUE) {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pClipCtxt->pViDecCtxt, &ts, pC->yuv1, M4OSA_TRUE);
+ pClipCtxt->lastDecodedPlane = pC->yuv1;
+ } else {
+ err = pClipCtxt->ShellAPI.m_pVideoDecoder->m_pFctRender(
+ pClipCtxt->pViDecCtxt, &ts, pC->yuv2, M4OSA_TRUE);
+ pClipCtxt->lastDecodedPlane = pC->yuv2;
+ }
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_1("M4VSS3GPP_intRenderFrameWithEffect: \
+ Render returns error 0x%x,", err);
+ return err;
+ }
+ }
+ pClipCtxt->iVideoRenderCts = (M4OSA_Int32)ts;
+ }
+
+ return err;
+}
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_MediaAndCodecSubscription.c b/libvideoeditor/vss/src/M4VSS3GPP_MediaAndCodecSubscription.c
index ea13c9e..f30f705 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_MediaAndCodecSubscription.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_MediaAndCodecSubscription.c
@@ -79,6 +79,7 @@
#include "VideoEditorAudioDecoder.h"
#include "VideoEditorVideoDecoder.h"
+#include "M4DECODER_Null.h"
#ifdef M4VSS_SUPPORT_AUDEC_NULL
#include "M4AD_Null.h"
#endif
@@ -259,6 +260,18 @@
"M4VSS3GPP_subscribeMediaAndCodec: can't register H264 decoder");
#endif /* M4VSS_SUPPORT_VIDEC_3GP */
+#ifdef M4VSS_SUPPORT_VIDEC_NULL
+ err = M4DECODER_NULL_getInterface(
+ &videoDecoderType, &pVideoDecoderInterface);
+ if (M4NO_ERROR != err) {
+ M4OSA_TRACE1_0("M4VD NULL Decoder interface allocation error");
+ return err;
+ }
+ err = M4VSS3GPP_registerVideoDecoder(
+ pContext, videoDecoderType, pVideoDecoderInterface);
+ M4OSA_DEBUG_IF1((err != M4NO_ERROR), err, "M4VSS3GPP_subscribeMediaAndCodec: \
+ can't register video NULL decoder");
+#endif
/* ______________________________ */
/*| |*/
/*| audio decoder subscription |*/
diff --git a/libvideoeditor/vss/src/M4xVSS_API.c b/libvideoeditor/vss/src/M4xVSS_API.c
index d09b145..6bf8c81 100755
--- a/libvideoeditor/vss/src/M4xVSS_API.c
+++ b/libvideoeditor/vss/src/M4xVSS_API.c
@@ -1196,6 +1196,9 @@
return err;
}
+ xVSS_context->pSettings->pClipList[i]->bTranscodingRequired =
+ M4OSA_FALSE;
+
/* Because there is 1 less transition than clip number */
if( i < xVSS_context->pSettings->uiClipNumber - 1 )
{
@@ -1648,476 +1651,479 @@
if( xVSS_context->pSettings->pClipList[i]->FileType
== M4VIDEOEDITING_kFileType_ARGB8888 )
{
- M4OSA_Char out_img[M4XVSS_MAX_PATH_LEN];
- M4OSA_Char out_img_tmp[M4XVSS_MAX_PATH_LEN];
- M4xVSS_Pto3GPP_params *pParams = M4OSA_NULL;
- M4OSA_Context pARGBFileIn;
- /*UTF conversion support*/
- M4OSA_Void *pDecodedPath = pSettings->pClipList[i]->pFile;
+ if(M4OSA_TRUE ==
+ xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom) {
+ M4OSA_Char out_img[M4XVSS_MAX_PATH_LEN];
+ M4OSA_Char out_img_tmp[M4XVSS_MAX_PATH_LEN];
+ M4xVSS_Pto3GPP_params *pParams = M4OSA_NULL;
+ M4OSA_Context pARGBFileIn;
+ /*UTF conversion support*/
+ M4OSA_Void *pDecodedPath = pSettings->pClipList[i]->pFile;
- /* Parse Pto3GPP params chained list to know if input file has already been
- converted */
- if( xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
- {
- M4OSA_UInt32 pCmpResult = 0;
-
- pParams = xVSS_context->pPTo3GPPparamsList;
- /* We parse all Pto3gpp Param chained list */
- while( pParams != M4OSA_NULL )
+ /* Parse Pto3GPP params chained list to know if input file has already been
+ converted */
+ if( xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
{
- pCmpResult = strcmp((const char *)pSettings->pClipList[i]->pFile,
- (const char *)pParams->pFileIn);
+ M4OSA_UInt32 pCmpResult = 0;
- if( pCmpResult == 0
- && (pSettings->pClipList[i]->uiEndCutTime
- == pParams->duration
- || pSettings->pClipList[i]->xVSS.uiDuration
- == pParams->duration)
- && pSettings->pClipList[i]->xVSS.MediaRendering
- == pParams->MediaRendering )
-
-
-
+ pParams = xVSS_context->pPTo3GPPparamsList;
+ /* We parse all Pto3gpp Param chained list */
+ while( pParams != M4OSA_NULL )
{
- /* Replace JPG filename with existing 3GP filename */
- goto replaceARGB_3GP;
+ pCmpResult = strcmp((const char *)pSettings->pClipList[i]->pFile,
+ (const char *)pParams->pFileIn);
+
+ if( pCmpResult == 0
+ && (pSettings->pClipList[i]->uiEndCutTime
+ == pParams->duration
+ || pSettings->pClipList[i]->xVSS.uiDuration
+ == pParams->duration)
+ && pSettings->pClipList[i]->xVSS.MediaRendering
+ == pParams->MediaRendering )
+
+
+
+ {
+ /* Replace JPG filename with existing 3GP filename */
+ goto replaceARGB_3GP;
+ }
+ /* We need to update this variable, in case some pictures have been
+ added between two */
+ /* calls to M4xVSS_sendCommand */
+ pPto3GPP_last = pParams;
+ pParams = pParams->pNext;
}
- /* We need to update this variable, in case some pictures have been
- added between two */
- /* calls to M4xVSS_sendCommand */
- pPto3GPP_last = pParams;
- pParams = pParams->pNext;
}
- }
- /* Construct output temporary 3GP filename */
- err = M4OSA_chrSPrintf(out_img, M4XVSS_MAX_PATH_LEN - 1, (M4OSA_Char *)"%simg%d.3gp",
- xVSS_context->pTempPath, xVSS_context->tempFileIndex);
+ /* Construct output temporary 3GP filename */
+ err = M4OSA_chrSPrintf(out_img, M4XVSS_MAX_PATH_LEN - 1, (M4OSA_Char *)"%simg%d.3gp",
+ xVSS_context->pTempPath, xVSS_context->tempFileIndex);
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return err;
- }
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return err;
+ }
-#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
+ #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
- err = M4OSA_chrSPrintf(out_img_tmp, M4XVSS_MAX_PATH_LEN - 1, "%simg%d.tmp",
- xVSS_context->pTempPath, xVSS_context->tempFileIndex);
+ err = M4OSA_chrSPrintf(out_img_tmp, M4XVSS_MAX_PATH_LEN - 1, "%simg%d.tmp",
+ xVSS_context->pTempPath, xVSS_context->tempFileIndex);
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return err;
- }
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return err;
+ }
-#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
+ #endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
- xVSS_context->tempFileIndex++;
+ xVSS_context->tempFileIndex++;
- /* Allocate last element Pto3GPP params structure */
- pParams = (M4xVSS_Pto3GPP_params
- *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_Pto3GPP_params),
- M4VS, (M4OSA_Char *)"Element of Pto3GPP Params");
+ /* Allocate last element Pto3GPP params structure */
+ pParams = (M4xVSS_Pto3GPP_params
+ *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_Pto3GPP_params),
+ M4VS, (M4OSA_Char *)"Element of Pto3GPP Params");
- if( pParams == M4OSA_NULL )
- {
- M4OSA_TRACE1_0(
- "M4xVSS_sendCommand: Problem when allocating one element Pto3GPP Params");
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return M4ERR_ALLOC;
- }
+ if( pParams == M4OSA_NULL )
+ {
+ M4OSA_TRACE1_0(
+ "M4xVSS_sendCommand: Problem when allocating one element Pto3GPP Params");
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return M4ERR_ALLOC;
+ }
- /* Initializes pfilexxx members of pParams to be able to free them correctly */
- pParams->pFileIn = M4OSA_NULL;
- pParams->pFileOut = M4OSA_NULL;
- pParams->pFileTemp = M4OSA_NULL;
- pParams->pNext = M4OSA_NULL;
- pParams->MediaRendering = M4xVSS_kResizing;
+ /* Initializes pfilexxx members of pParams to be able to free them correctly */
+ pParams->pFileIn = M4OSA_NULL;
+ pParams->pFileOut = M4OSA_NULL;
+ pParams->pFileTemp = M4OSA_NULL;
+ pParams->pNext = M4OSA_NULL;
+ pParams->MediaRendering = M4xVSS_kResizing;
- /*To support ARGB8888 :get the width and height */
- pParams->height = pSettings->pClipList[
- i]->ClipProperties.uiStillPicHeight; //ARGB_Height;
- pParams->width = pSettings->pClipList[
- i]->ClipProperties.uiStillPicWidth; //ARGB_Width;
- M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 H = %d", pParams->height);
- M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 W = %d", pParams->width);
+ /*To support ARGB8888 :get the width and height */
+ pParams->height = pSettings->pClipList[
+ i]->ClipProperties.uiStillPicHeight; //ARGB_Height;
+ pParams->width = pSettings->pClipList[
+ i]->ClipProperties.uiStillPicWidth; //ARGB_Width;
+ M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 H = %d", pParams->height);
+ M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 W = %d", pParams->width);
- if( xVSS_context->pPTo3GPPparamsList
- == M4OSA_NULL ) /* Means it is the first element of the list */
- {
- /* Initialize the xVSS context with the first element of the list */
- xVSS_context->pPTo3GPPparamsList = pParams;
+ if( xVSS_context->pPTo3GPPparamsList
+ == M4OSA_NULL ) /* Means it is the first element of the list */
+ {
+ /* Initialize the xVSS context with the first element of the list */
+ xVSS_context->pPTo3GPPparamsList = pParams;
- /* Save this element in case of other file to convert */
- pPto3GPP_last = pParams;
- }
- else
- {
- /* Update next pointer of the previous last element of the chain */
- pPto3GPP_last->pNext = pParams;
+ /* Save this element in case of other file to convert */
+ pPto3GPP_last = pParams;
+ }
+ else
+ {
+ /* Update next pointer of the previous last element of the chain */
+ pPto3GPP_last->pNext = pParams;
- /* Update save of last element of the chain */
- pPto3GPP_last = pParams;
- }
+ /* Update save of last element of the chain */
+ pPto3GPP_last = pParams;
+ }
- /* Fill the last M4xVSS_Pto3GPP_params element */
- pParams->duration =
- xVSS_context->pSettings->pClipList[i]->uiEndCutTime;
- /* If duration is filled, let's use it instead of EndCutTime */
- if( xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration != 0 )
- {
+ /* Fill the last M4xVSS_Pto3GPP_params element */
pParams->duration =
- xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration;
- }
-
- pParams->InputFileType = M4VIDEOEDITING_kFileType_ARGB8888;
-
- /**
- * UTF conversion: convert into the customer format, before being used*/
- pDecodedPath = xVSS_context->pSettings->pClipList[i]->pFile;
- length = strlen(pDecodedPath);
-
- /**
- * UTF conversion: convert into the customer format, before being used*/
- if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
- != M4OSA_NULL && xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer
- != M4OSA_NULL )
- {
- err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void
- *)xVSS_context->pSettings->pClipList[i]->pFile,
- (M4OSA_Void *)xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer,
- &length);
-
- if( err != M4NO_ERROR )
+ xVSS_context->pSettings->pClipList[i]->uiEndCutTime;
+ /* If duration is filled, let's use it instead of EndCutTime */
+ if( xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration != 0 )
{
- M4OSA_TRACE1_1(
- "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
- err);
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- return err;
+ pParams->duration =
+ xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration;
}
- pDecodedPath =
- xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
- }
- /**
- * End of the UTF conversion, use the converted file path*/
- pParams->pFileIn = (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
- (M4OSA_Char *)"Pto3GPP Params: file in");
+ pParams->InputFileType = M4VIDEOEDITING_kFileType_ARGB8888;
- if( pParams->pFileIn == M4OSA_NULL )
- {
- M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return M4ERR_ALLOC;
- }
- memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
- (length + 1)); /* Copy input file path */
+ /**
+ * UTF conversion: convert into the customer format, before being used*/
+ pDecodedPath = xVSS_context->pSettings->pClipList[i]->pFile;
+ length = strlen(pDecodedPath);
- /* Check that JPG file is present on the FS (P4ME00002974) by just opening
- and closing it */
- err =
- xVSS_context->pFileReadPtr->openRead(&pARGBFileIn, pDecodedPath,
- M4OSA_kFileRead);
-
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_2("Can't open input jpg file %s, error: 0x%x\n",
- pDecodedPath, err);
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- return err;
- }
- err = xVSS_context->pFileReadPtr->closeRead(pARGBFileIn);
-
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_2("Can't close input jpg file %s, error: 0x%x\n",
- pDecodedPath, err);
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- return err;
- }
-
- /**
- * UTF conversion: convert into the customer format, before being used*/
- pDecodedPath = out_img;
- length = strlen(pDecodedPath);
-
- if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
- != M4OSA_NULL && xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer
- != M4OSA_NULL )
- {
- err = M4xVSS_internalConvertFromUTF8(xVSS_context,
- (M4OSA_Void *)out_img, (M4OSA_Void *)xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer, &length);
-
- if( err != M4NO_ERROR )
+ /**
+ * UTF conversion: convert into the customer format, before being used*/
+ if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
+ != M4OSA_NULL && xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer
+ != M4OSA_NULL )
{
- M4OSA_TRACE1_1(
- "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
- err);
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- return err;
+ err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void
+ *)xVSS_context->pSettings->pClipList[i]->pFile,
+ (M4OSA_Void *)xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer,
+ &length);
+
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1(
+ "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
+ err);
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ return err;
+ }
+ pDecodedPath =
+ xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
}
- pDecodedPath =
- xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
- }
- /**
- * End of the UTF conversion, use the converted file path*/
- pParams->pFileOut = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
- (M4OSA_Char *)"Pto3GPP Params: file out");
+ /**
+ * End of the UTF conversion, use the converted file path*/
+ pParams->pFileIn = (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
+ (M4OSA_Char *)"Pto3GPP Params: file in");
- if( pParams->pFileOut == M4OSA_NULL )
- {
- M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return M4ERR_ALLOC;
- }
- memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
- (length + 1)); /* Copy output file path */
-
-#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
- /**
- * UTF conversion: convert into the customer format, before being used*/
-
- pDecodedPath = out_img_tmp;
- length = strlen(pDecodedPath);
-
- if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
- != M4OSA_NULL && xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer
- != M4OSA_NULL )
- {
- err = M4xVSS_internalConvertFromUTF8(xVSS_context,
- (M4OSA_Void *)out_img_tmp, (M4OSA_Void *)xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer, &length);
-
- if( err != M4NO_ERROR )
- {
- M4OSA_TRACE1_1("M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8\
- returns err: 0x%x",
- err);
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- return err;
- }
- pDecodedPath =
- xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
- }
-
- /**
- * End of the UTF conversion, use the converted file path*/
- pParams->pFileTemp = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
- (M4OSA_Char *)"Pto3GPP Params: file temp");
-
- if( pParams->pFileTemp == M4OSA_NULL )
- {
- M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return M4ERR_ALLOC;
- }
- memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
- (length + 1)); /* Copy temporary file path */
-
-#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
-
- /* Fill PanAndZoom settings if needed */
-
- if( M4OSA_TRUE
- == xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom )
- {
- pParams->isPanZoom =
- xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom;
- /* Check that Pan & Zoom parameters are corrects */
- if( xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa > 1000
- || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa
- <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
- PanZoomTopleftXa > 1000
- || xVSS_context->pSettings->pClipList[i]->xVSS.
- PanZoomTopleftYa > 1000
- || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
- > 1000
- || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
- <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
- PanZoomTopleftXb > 1000
- || xVSS_context->pSettings->pClipList[i]->xVSS.
- PanZoomTopleftYb > 1000)
+ if( pParams->pFileIn == M4OSA_NULL )
{
M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
M4xVSS_freeCommand(xVSS_context);
- return M4ERR_PARAMETER;
+ /**/
+ return M4ERR_ALLOC;
}
+ memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
+ (length + 1)); /* Copy input file path */
- pParams->PanZoomXa =
- xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa;
- pParams->PanZoomTopleftXa =
- xVSS_context->pSettings->
- pClipList[i]->xVSS.PanZoomTopleftXa;
- pParams->PanZoomTopleftYa =
- xVSS_context->pSettings->
- pClipList[i]->xVSS.PanZoomTopleftYa;
- pParams->PanZoomXb =
- xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb;
- pParams->PanZoomTopleftXb =
- xVSS_context->pSettings->
- pClipList[i]->xVSS.PanZoomTopleftXb;
- pParams->PanZoomTopleftYb =
- xVSS_context->pSettings->
- pClipList[i]->xVSS.PanZoomTopleftYb;
- }
- else
- {
- pParams->isPanZoom = M4OSA_FALSE;
- }
- /*+ PR No: blrnxpsw#223*/
- /*Intializing the Video Frame Rate as it may not be intialized*/
- /*Other changes made is @ M4xVSS_Internal.c @ line 1518 in
- M4xVSS_internalStartConvertPictureTo3gp*/
- switch( xVSS_context->pSettings->videoFrameRate )
- {
- case M4VIDEOEDITING_k30_FPS:
- pParams->framerate = 33;
- break;
-
- case M4VIDEOEDITING_k25_FPS:
- pParams->framerate = 40;
- break;
-
- case M4VIDEOEDITING_k20_FPS:
- pParams->framerate = 50;
- break;
-
- case M4VIDEOEDITING_k15_FPS:
- pParams->framerate = 66;
- break;
-
- case M4VIDEOEDITING_k12_5_FPS:
- pParams->framerate = 80;
- break;
-
- case M4VIDEOEDITING_k10_FPS:
- pParams->framerate = 100;
- break;
-
- case M4VIDEOEDITING_k7_5_FPS:
- pParams->framerate = 133;
- break;
-
- case M4VIDEOEDITING_k5_FPS:
- pParams->framerate = 200;
- break;
-
- default:
- /*Making Default Frame Rate @ 15 FPS*/
- pParams->framerate = 66;
- break;
- }
- /*-PR No: blrnxpsw#223*/
- if( xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering
- == M4xVSS_kCropping
- || xVSS_context->pSettings->pClipList[i]->xVSS.
- MediaRendering == M4xVSS_kBlackBorders
- || xVSS_context->pSettings->pClipList[i]->xVSS.
- MediaRendering == M4xVSS_kResizing )
- {
- pParams->MediaRendering =
- xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering;
- }
-
- pParams->pNext = M4OSA_NULL;
- pParams->isCreated = M4OSA_FALSE;
- xVSS_context->nbStepTotal++;
-
-replaceARGB_3GP:
- /* Update total duration */
- totalDuration += pParams->duration;
-
- /* Replacing in VSS structure the JPG file by the 3gp file */
- xVSS_context->pSettings->pClipList[i]->FileType =
- M4VIDEOEDITING_kFileType_3GPP;
-
- if( xVSS_context->pSettings->pClipList[i]->pFile != M4OSA_NULL )
- {
- free(xVSS_context->pSettings->pClipList[i]->pFile);
- xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_NULL;
- }
-
- /**
- * UTF conversion: convert into UTF8, before being used*/
- pDecodedPath = pParams->pFileOut;
-
- if( xVSS_context->UTFConversionContext.pConvToUTF8Fct != M4OSA_NULL
- && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
- != M4OSA_NULL )
- {
- err = M4xVSS_internalConvertToUTF8(xVSS_context,
- (M4OSA_Void *)pParams->pFileOut,
- (M4OSA_Void *)xVSS_context->
- UTFConversionContext.pTempOutConversionBuffer,
- &length);
+ /* Check that JPG file is present on the FS (P4ME00002974) by just opening
+ and closing it */
+ err =
+ xVSS_context->pFileReadPtr->openRead(&pARGBFileIn, pDecodedPath,
+ M4OSA_kFileRead);
if( err != M4NO_ERROR )
{
- M4OSA_TRACE1_1(
- "M4xVSS_SendCommand: M4xVSS_internalConvertToUTF8 returns err: \
- 0x%x",err);
+ M4OSA_TRACE1_2("Can't open input jpg file %s, error: 0x%x\n",
+ pDecodedPath, err);
/* Free Send command */
M4xVSS_freeCommand(xVSS_context);
return err;
}
- pDecodedPath =
- xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
- }
- else
- {
- length = strlen(pDecodedPath);
- }
- /**
- * End of the UTF conversion, use the converted file path*/
- xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_32bitAlignedMalloc((length
- + 1), M4VS, (M4OSA_Char *)"xVSS file path of ARGB to 3gp");
+ err = xVSS_context->pFileReadPtr->closeRead(pARGBFileIn);
- if( xVSS_context->pSettings->pClipList[i]->pFile == M4OSA_NULL )
- {
- M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
- /*FB: to avoid leaks when there is an error in the send command*/
- /* Free Send command */
- M4xVSS_freeCommand(xVSS_context);
- /**/
- return M4ERR_ALLOC;
- }
- memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
- (void *)pDecodedPath, (length + 1));
- /*FB: add file path size because of UTF16 conversion*/
- xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_2("Can't close input jpg file %s, error: 0x%x\n",
+ pDecodedPath, err);
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ return err;
+ }
+
+ /**
+ * UTF conversion: convert into the customer format, before being used*/
+ pDecodedPath = out_img;
+ length = strlen(pDecodedPath);
+
+ if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
+ != M4OSA_NULL && xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer
+ != M4OSA_NULL )
+ {
+ err = M4xVSS_internalConvertFromUTF8(xVSS_context,
+ (M4OSA_Void *)out_img, (M4OSA_Void *)xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer, &length);
+
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1(
+ "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
+ err);
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ return err;
+ }
+ pDecodedPath =
+ xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
+ }
+
+ /**
+ * End of the UTF conversion, use the converted file path*/
+ pParams->pFileOut = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
+ (M4OSA_Char *)"Pto3GPP Params: file out");
+
+ if( pParams->pFileOut == M4OSA_NULL )
+ {
+ M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return M4ERR_ALLOC;
+ }
+ memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
+ (length + 1)); /* Copy output file path */
+
+ #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
+ /**
+ * UTF conversion: convert into the customer format, before being used*/
+
+ pDecodedPath = out_img_tmp;
+ length = strlen(pDecodedPath);
+
+ if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
+ != M4OSA_NULL && xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer
+ != M4OSA_NULL )
+ {
+ err = M4xVSS_internalConvertFromUTF8(xVSS_context,
+ (M4OSA_Void *)out_img_tmp, (M4OSA_Void *)xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer, &length);
+
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1("M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8\
+ returns err: 0x%x",
+ err);
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ return err;
+ }
+ pDecodedPath =
+ xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
+ }
+
+ /**
+ * End of the UTF conversion, use the converted file path*/
+ pParams->pFileTemp = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
+ (M4OSA_Char *)"Pto3GPP Params: file temp");
+
+ if( pParams->pFileTemp == M4OSA_NULL )
+ {
+ M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return M4ERR_ALLOC;
+ }
+ memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
+ (length + 1)); /* Copy temporary file path */
+
+ #endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
+
+ /* Fill PanAndZoom settings if needed */
+
+ if( M4OSA_TRUE
+ == xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom )
+ {
+ pParams->isPanZoom =
+ xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom;
+ /* Check that Pan & Zoom parameters are corrects */
+ if( xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa > 1000
+ || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa
+ <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
+ PanZoomTopleftXa > 1000
+ || xVSS_context->pSettings->pClipList[i]->xVSS.
+ PanZoomTopleftYa > 1000
+ || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
+ > 1000
+ || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
+ <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
+ PanZoomTopleftXb > 1000
+ || xVSS_context->pSettings->pClipList[i]->xVSS.
+ PanZoomTopleftYb > 1000)
+ {
+ M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
+ M4xVSS_freeCommand(xVSS_context);
+ return M4ERR_PARAMETER;
+ }
+
+ pParams->PanZoomXa =
+ xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa;
+ pParams->PanZoomTopleftXa =
+ xVSS_context->pSettings->
+ pClipList[i]->xVSS.PanZoomTopleftXa;
+ pParams->PanZoomTopleftYa =
+ xVSS_context->pSettings->
+ pClipList[i]->xVSS.PanZoomTopleftYa;
+ pParams->PanZoomXb =
+ xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb;
+ pParams->PanZoomTopleftXb =
+ xVSS_context->pSettings->
+ pClipList[i]->xVSS.PanZoomTopleftXb;
+ pParams->PanZoomTopleftYb =
+ xVSS_context->pSettings->
+ pClipList[i]->xVSS.PanZoomTopleftYb;
+ }
+ else
+ {
+ pParams->isPanZoom = M4OSA_FALSE;
+ }
+ /*+ PR No: blrnxpsw#223*/
+ /*Intializing the Video Frame Rate as it may not be intialized*/
+ /*Other changes made is @ M4xVSS_Internal.c @ line 1518 in
+ M4xVSS_internalStartConvertPictureTo3gp*/
+ switch( xVSS_context->pSettings->videoFrameRate )
+ {
+ case M4VIDEOEDITING_k30_FPS:
+ pParams->framerate = 33;
+ break;
+
+ case M4VIDEOEDITING_k25_FPS:
+ pParams->framerate = 40;
+ break;
+
+ case M4VIDEOEDITING_k20_FPS:
+ pParams->framerate = 50;
+ break;
+
+ case M4VIDEOEDITING_k15_FPS:
+ pParams->framerate = 66;
+ break;
+
+ case M4VIDEOEDITING_k12_5_FPS:
+ pParams->framerate = 80;
+ break;
+
+ case M4VIDEOEDITING_k10_FPS:
+ pParams->framerate = 100;
+ break;
+
+ case M4VIDEOEDITING_k7_5_FPS:
+ pParams->framerate = 133;
+ break;
+
+ case M4VIDEOEDITING_k5_FPS:
+ pParams->framerate = 200;
+ break;
+
+ default:
+ /*Making Default Frame Rate @ 15 FPS*/
+ pParams->framerate = 66;
+ break;
+ }
+ /*-PR No: blrnxpsw#223*/
+ if( xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering
+ == M4xVSS_kCropping
+ || xVSS_context->pSettings->pClipList[i]->xVSS.
+ MediaRendering == M4xVSS_kBlackBorders
+ || xVSS_context->pSettings->pClipList[i]->xVSS.
+ MediaRendering == M4xVSS_kResizing )
+ {
+ pParams->MediaRendering =
+ xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering;
+ }
+
+ pParams->pNext = M4OSA_NULL;
+ pParams->isCreated = M4OSA_FALSE;
+ xVSS_context->nbStepTotal++;
+
+ replaceARGB_3GP:
+ /* Update total duration */
+ totalDuration += pParams->duration;
+
+ /* Replacing in VSS structure the JPG file by the 3gp file */
+ xVSS_context->pSettings->pClipList[i]->FileType =
+ M4VIDEOEDITING_kFileType_3GPP;
+
+ if( xVSS_context->pSettings->pClipList[i]->pFile != M4OSA_NULL )
+ {
+ free(xVSS_context->pSettings->pClipList[i]->pFile);
+ xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_NULL;
+ }
+
+ /**
+ * UTF conversion: convert into UTF8, before being used*/
+ pDecodedPath = pParams->pFileOut;
+
+ if( xVSS_context->UTFConversionContext.pConvToUTF8Fct != M4OSA_NULL
+ && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
+ != M4OSA_NULL )
+ {
+ err = M4xVSS_internalConvertToUTF8(xVSS_context,
+ (M4OSA_Void *)pParams->pFileOut,
+ (M4OSA_Void *)xVSS_context->
+ UTFConversionContext.pTempOutConversionBuffer,
+ &length);
+
+ if( err != M4NO_ERROR )
+ {
+ M4OSA_TRACE1_1(
+ "M4xVSS_SendCommand: M4xVSS_internalConvertToUTF8 returns err: \
+ 0x%x",err);
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ return err;
+ }
+ pDecodedPath =
+ xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
+ }
+ else
+ {
+ length = strlen(pDecodedPath);
+ }
+ /**
+ * End of the UTF conversion, use the converted file path*/
+ xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_32bitAlignedMalloc((length
+ + 1), M4VS, (M4OSA_Char *)"xVSS file path of ARGB to 3gp");
+
+ if( xVSS_context->pSettings->pClipList[i]->pFile == M4OSA_NULL )
+ {
+ M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
+ /*FB: to avoid leaks when there is an error in the send command*/
+ /* Free Send command */
+ M4xVSS_freeCommand(xVSS_context);
+ /**/
+ return M4ERR_ALLOC;
+ }
+ memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
+ (void *)pDecodedPath, (length + 1));
+ /*FB: add file path size because of UTF16 conversion*/
+ xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
+ }
}
/************************
3GP input file type case
@@ -2380,22 +2386,6 @@
i);
}
- /* If the output video format/size is not the same as provided video,
- let's transcode it */
-
- if( fileProperties.VideoStreamType
- != xVSS_context->pSettings->xVSS.outputVideoFormat
- || fileProperties.uiVideoWidth != width
- || fileProperties.uiVideoHeight != height
- || (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4
- && fileProperties.uiVideoTimeScale
- != xVSS_context->targetedTimescale) )
- {
- videoIsDifferent = M4OSA_TRUE;
- }
- /*temp solution for fixng issue for H.264 compressed domain */
- videoIsDifferent = M4OSA_TRUE;
-
if( fileProperties.uiNbChannels == 1 )
{
bAudioMono = M4OSA_TRUE;
@@ -2479,6 +2469,7 @@
return M4ERR_ALLOC;
}
pParams->MediaRendering = M4xVSS_kResizing;
+ pParams->videoclipnumber = i; // Indicates video clip index
if( xVSS_context->pMCSparamsList
== M4OSA_NULL ) /* Means it is the first element of the list */
@@ -2893,11 +2884,6 @@
xVSS_context->pSettings->pClipList[i]->uiEndCutTime
- xVSS_context->pSettings->pClipList[i]->uiBeginCutTime;
- /*the cuts are done in the MCS, so we need to replace the beginCutTime
- and endCutTime to keep the entire video*/
- xVSS_context->pSettings->pClipList[i]->uiBeginCutTime = 0;
- xVSS_context->pSettings->pClipList[i]->uiEndCutTime = 0;
-
/* Replacing in VSS structure the original 3GP file by the transcoded 3GP file */
xVSS_context->pSettings->pClipList[i]->FileType =
M4VIDEOEDITING_kFileType_3GPP;
@@ -4924,7 +4910,9 @@
|| (xVSS_context->pSettings->pClipList[i]->FileType
== M4VIDEOEDITING_kFileType_MP4)
|| (xVSS_context->pSettings->pClipList[i]->FileType
- == M4VIDEOEDITING_kFileType_M4V) )
+ == M4VIDEOEDITING_kFileType_M4V)
+ || (xVSS_context->pSettings->pClipList[i]->FileType
+ == M4VIDEOEDITING_kFileType_ARGB8888))
{
/* Copy data from given structure to our saving structure */
@@ -5800,10 +5788,21 @@
code ? */
return err;
}
- M4OSA_TRACE1_1("M4xVSS_Step: M4xVSS_internalStartTranscoding returned\
+ int32_t index = xVSS_context->pMCScurrentParams->videoclipnumber;
+ if(xVSS_context->pSettings->pClipList[index]->bTranscodingRequired
+ == M4OSA_FALSE) {
+ /*the cuts are done in the MCS, so we need to replace
+ the beginCutTime and endCutTime to keep the entire video*/
+ xVSS_context->pSettings->pClipList[index]->uiBeginCutTime = 0;
+ xVSS_context->pSettings->pClipList[index]->uiEndCutTime = 0;
+ }
+
+ M4OSA_TRACE1_1("M4xVSS_Step: \
+ M4xVSS_internalStartTranscoding returned \
success; MCS context: 0x%x",
- xVSS_context->pMCS_Ctxt)xVSS_context->analyseStep =
- M4xVSS_kMicroStateTranscodeMCS;
+ xVSS_context->pMCS_Ctxt);
+ xVSS_context->analyseStep =
+ M4xVSS_kMicroStateTranscodeMCS;
}
}
else if( xVSS_context->analyseStep
diff --git a/libvideoeditor/vss/src/M4xVSS_internal.c b/libvideoeditor/vss/src/M4xVSS_internal.c
index 3827720..66e3b80 100755
--- a/libvideoeditor/vss/src/M4xVSS_internal.c
+++ b/libvideoeditor/vss/src/M4xVSS_internal.c
@@ -2354,6 +2354,22 @@
return err;
}
+ M4VSS3GPP_InternalEditContext* pVSSContext =
+ (M4VSS3GPP_InternalEditContext*)pVssCtxt;
+ pVSSContext->xVSS.outputVideoFormat =
+ xVSS_context->pSettings->xVSS.outputVideoFormat;
+ pVSSContext->xVSS.outputVideoSize =
+ xVSS_context->pSettings->xVSS.outputVideoSize ;
+ pVSSContext->xVSS.outputAudioFormat =
+ xVSS_context->pSettings->xVSS.outputAudioFormat;
+ pVSSContext->xVSS.outputAudioSamplFreq =
+ xVSS_context->pSettings->xVSS.outputAudioSamplFreq;
+ pVSSContext->xVSS.outputVideoBitrate =
+ xVSS_context->pSettings->xVSS.outputVideoBitrate ;
+ pVSSContext->xVSS.outputAudioBitrate =
+ xVSS_context->pSettings->xVSS.outputAudioBitrate ;
+ pVSSContext->xVSS.bAudioMono =
+ xVSS_context->pSettings->xVSS.bAudioMono;
/* In case of MMS use case, we fill directly into the VSS context the targeted bitrate */
if(xVSS_context->targetedBitrate != 0)
{