/*
* 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 M4MP4W_Interface.c
* @brief 3GPP file writer interface
* @note This implementation follows the common interface defined
* in "M4WRITER_common.h".
******************************************************************************
*/
#include "NXPSW_CompilerSwitches.h"
/**
* OSAL includes */
#include "M4OSA_Types.h" /**< OSAL basic types definiton */
#include "M4OSA_FileWriter.h" /**< Include for OSAL file accesses implementation */
#include "M4OSA_Memory.h" /**< Include for OSAL memory accesses implementation */
#include "M4OSA_Debug.h" /**< OSAL debug tools */
/**
* Writer includes */
#include "M4WRITER_common.h" /**< Definition of the writer common interface that
this module follows */
#ifdef _M4MP4W_USE_CST_MEMORY_WRITER
#include "M4MP4W_Types_CstMem.h" /**< MP4/3GP core writer types */
#include "M4MP4W_Writer_CstMem.h" /**< MP4/3GP core writer functions */
#else
#include "M4MP4W_Types.h" /**< MP4/3GP core writer types */
#include "M4MP4W_Writer.h" /**< MP4/3GP core writer functions */
#endif /* _M4MP4W_USE_CST_MEMORY_WRITER */
/**
* Specific errors for this module */
#define M4WRITER_3GP_ERR_UNSUPPORTED_STREAM_TYPE \
M4OSA_ERR_CREATE(M4_ERR, M4WRITER_3GP, 0x000001)
/**
******************************************************************************
* structure M4WRITER_3GP_InternalContext
* @brief This structure defines the writer context (private)
* @note This structure is used for all writer calls to store the context
******************************************************************************
*/
typedef struct
{
M4OSA_Context pMP4Context; /**< MP4 writer context */
M4OSA_UInt32 maxAUsizes; /**< the maximum AU size possible */
} M4WRITER_3GP_InternalContext;
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_openWrite(M4WRITER_Context* pContext, void* pWhat,
* M4OSA_FileWriterPointer* pFileWriterPointer)
* @brief Open a writer session.
* @note
* @param pContext: (OUT) Execution context of the 3GP writer, allocated by this function.
* @param outputFileDescriptor (IN) Descriptor of the output file to create.
* @param fileWriterFunction (IN) Pointer to structure containing the set of OSAL
* file write functions.
* @param tempFileDescriptor (IN) Descriptor of the temporary file to open
* (NULL if not used)
* @param fileReaderFunction (IN) Pointer to structure containing the set of OSAL file read
* functions (NULL if not used)
* @return M4NO_ERROR: there is no error
* @return M4ERR_ALLOC: there is no more available memory
* @return M4ERR_PARAMETER: pContext or pFilePtrFct is M4OSA_NULL (debug only)
* @return any error returned by the MP4 core writer openWrite (Its coreID is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_openWrite( M4WRITER_Context* pContext,
void* outputFileDescriptor,
M4OSA_FileWriterPointer* pFileWriterPointer,
void* tempFileDescriptor,
M4OSA_FileReadPointer* pFileReaderPointer )
{
M4WRITER_3GP_InternalContext* apContext;
M4OSA_ERR err;
M4OSA_TRACE1_0("M4WRITER_3GP_openWrite");
/**
* Check input parameters */
M4OSA_DEBUG_IF2((M4OSA_NULL == pContext),M4ERR_PARAMETER,
"M4WRITER_3GP_openWrite: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pFileWriterPointer),M4ERR_PARAMETER,
"M4WRITER_3GP_openWrite: pFileWriterPointer is M4OSA_NULL");
/**
* Allocate memory for the context */
*pContext=M4OSA_NULL;
apContext = (M4WRITER_3GP_InternalContext*)M4OSA_32bitAlignedMalloc(
sizeof(M4WRITER_3GP_InternalContext),
M4WRITER_3GP,
(M4OSA_Char *)"M4WRITER_3GP_InternalContext");
if (M4OSA_NULL == apContext)
{
M4OSA_TRACE1_0("M4WRITER_3GP_openWrite:\
unable to allocate context, returning M4ERR_ALLOC");
return (M4OSA_ERR)M4ERR_ALLOC;
}
/**
* Reset context variables */
apContext->pMP4Context = M4OSA_NULL;
apContext->maxAUsizes = 0;
/**
* Return the writer context */
*pContext = (M4WRITER_Context *)apContext;
/**
* Launch the openWrite of the MP4 writer */
M4OSA_TRACE3_0("M4WRITER_3GP_openWrite: calling M4MP4W_openWrite()");
err = M4MP4W_openWrite(&apContext->pMP4Context, outputFileDescriptor,
pFileWriterPointer, tempFileDescriptor, pFileReaderPointer );
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4WRITER_3GP_openWrite: "
"M4MP4W_openWrite returns error 0x%x", err);
}
M4OSA_TRACE2_1("M4WRITER_3GP_openWrite: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_startWriting(M4WRITER_Context pContext)
* @brief Indicates to the writer that the setup session is ended and that
* we will start to write.
* @note
* @param pContext: (IN) Execution context of the 3GP writer,
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return any error returned by the MP4 core writer startWriting (Its
* coreID is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_startWriting(M4WRITER_Context pContext)
{
M4WRITER_3GP_InternalContext* apContext =
(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err;
M4OSA_TRACE1_1("M4WRITER_3GP_startWriting: pContext=0x%x", pContext);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext),M4ERR_PARAMETER,
"M4WRITER_3GP_startWriting: pContext is M4OSA_NULL");
/**
* Call the MP4 core writer */
M4OSA_TRACE3_0("M4WRITER_3GP_startWriting: calling M4MP4W_startWriting()");
err = M4MP4W_startWriting(apContext->pMP4Context);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_startWriting returns error 0x%x", err);
}
M4OSA_TRACE2_1("M4WRITER_3GP_startWriting: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_addStream(
* M4WRITER_Context pContext,
* M4SYS_StreamDescription *pStreamDescription)
* @brief Add a stream (audio or video).
* @note Decoder specific info properties are correctly set before calling
* the core writer add function
* @param pContext: (IN) Execution context of the 3GP writer,
* @param streamDescription: (IN) stream description.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext or pStreamDescription is M4OSA_NULL
* (debug only)
* @return any error returned by the MP4 core writer addStream
* (Its coreID is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_addStream(M4WRITER_Context pContext,
M4SYS_StreamDescription* pStreamDescription)
{
M4WRITER_3GP_InternalContext *apContext =
(M4WRITER_3GP_InternalContext *)pContext;
M4OSA_ERR err;
M4WRITER_StreamVideoInfos *pVideoInfo = M4OSA_NULL;
M4WRITER_StreamAudioInfos *pAudioInfo = M4OSA_NULL;
M4MP4W_StreamIDsize sizeValue;
M4OSA_TRACE1_2("M4WRITER_3GP_addStream: pContext=0x%x, "
"pStreamDescription=0x%x",
pContext, pStreamDescription);
/**
* Check input parameters */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext),M4ERR_PARAMETER,
"M4WRITER_3GP_addStream: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pStreamDescription),M4ERR_PARAMETER,
"M4WRITER_3GP_addStream: pStreamDescription is M4OSA_NULL");
/**
* Adapt audio/video stream infos */
switch (pStreamDescription->streamType)
{
case M4SYS_kMPEG_4:
case M4SYS_kH264:
case M4SYS_kH263:
M4OSA_TRACE3_1("M4WRITER_3GP_addStream: "
"adding a Video stream (streamType=0x%x)",
pStreamDescription->streamType);
/**
* Common descriptions */
pStreamDescription->streamID = VideoStreamID; /**< The only values checked by our
core writer are streamID */
pStreamDescription->timeScale = 1000; /**< and timeScale */
/* Not recommended for video editing -> write explicitely the 'bitr' box into 'd263' */
/* Rem : it is REL 5 of 3gpp documentation */
// /**
// * Average bit-rate must not be set in H263 to be compatible with Platform4 */
// if (M4SYS_kH263 == pStreamDescription->streamType)
// {
// pStreamDescription->averageBitrate = -1;
// }
/**
* Decoder specific info */
pVideoInfo = (M4WRITER_StreamVideoInfos *)pStreamDescription->decoderSpecificInfo;
pStreamDescription->decoderSpecificInfoSize = pVideoInfo->Header.Size;
pStreamDescription->decoderSpecificInfo = (M4OSA_MemAddr32)pVideoInfo->Header.pBuf;
M4OSA_TRACE3_2("M4WRITER_3GP_addStream: Video: DSI=0x%x, DSIsize=%d",
pVideoInfo->Header.pBuf, pVideoInfo->Header.Size);
break;
case M4SYS_kAMR:
case M4SYS_kAMR_WB:
case M4SYS_kAAC:
case M4SYS_kEVRC:
M4OSA_TRACE3_1("M4WRITER_3GP_addStream: adding an Audio stream (streamType=0x%x)",
pStreamDescription->streamType);
/**
* Common descriptions */
pStreamDescription->streamID = AudioStreamID; /**< The only value checked by our
core writer is streamID */
/**
* Decoder specific info */
pAudioInfo = (M4WRITER_StreamAudioInfos *)pStreamDescription->decoderSpecificInfo;
pStreamDescription->decoderSpecificInfoSize = pAudioInfo->Header.Size;
pStreamDescription->decoderSpecificInfo = (M4OSA_MemAddr32)pAudioInfo->Header.pBuf;
M4OSA_TRACE3_2("M4WRITER_3GP_addStream: Audio: DSI=0x%x, DSIsize=%d",
pAudioInfo->Header.pBuf, pAudioInfo->Header.Size);
break;
default:
M4OSA_TRACE1_1("M4WRITER_3GP_addStream:\
returning M4WRITER_3GP_ERR_UNSUPPORTED_STREAM_TYPE (streamType=0x%x)",
pStreamDescription->streamType);
return (M4OSA_ERR)M4WRITER_3GP_ERR_UNSUPPORTED_STREAM_TYPE;
break;
}
/**
* Call the MP4 core writer */
M4OSA_TRACE3_0("M4WRITER_3GP_addStream: calling M4MP4W_addStream()");
err = M4MP4W_addStream(apContext->pMP4Context,pStreamDescription);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4WRITER_3GP_addStream: M4MP4W_addStream returns error 0x%x", err);
M4OSA_TRACE1_1("M4WRITER_3GP_addStream: returning 0x%x", err);
return (err);
}
/**
* For Video, set the M4MP4W_trackSize Option */
switch (pStreamDescription->streamType)
{
case M4SYS_kMPEG_4:
case M4SYS_kH264:
case M4SYS_kH263:
sizeValue.streamID = VideoStreamID;
sizeValue.height = (M4OSA_UInt16)(pVideoInfo->height);
sizeValue.width = (M4OSA_UInt16)(pVideoInfo->width);
M4OSA_TRACE3_2("M4WRITER_3GP_addStream: Video: height=%d, width=%d",
sizeValue.height, sizeValue.width);
M4OSA_TRACE3_0("M4WRITER_3GP_addStream: calling M4MP4W_setOption(M4MP4W_trackSize)");
err = M4MP4W_setOption( apContext->pMP4Context, M4MP4W_trackSize,
(M4OSA_DataOption)&sizeValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4WRITER_3GP_addStream: M4MP4W_setOption returns error 0x%x",
err);
}
break;
default:
break;
}
M4OSA_TRACE2_1("M4WRITER_3GP_addStream: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_closeWrite(M4WRITER_Context pContext)
* @brief Close the writer. The context is freed here.
* @note
* @param pContext: (IN) Execution context of the 3GP writer,
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return any error returned by the MP4 core writer closeWrite (Its coreID
* is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_closeWrite(M4WRITER_Context pContext)
{
M4WRITER_3GP_InternalContext* apContext=(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err = M4NO_ERROR;
M4OSA_TRACE1_1("M4WRITER_3GP_closeWrite called with pContext=0x%x", pContext);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext),M4ERR_PARAMETER,
"M4WRITER_3GP_closeWrite: pContext is M4OSA_NULL");
/**
* Call the MP4 core writer */
if (M4OSA_NULL != apContext->pMP4Context)
{
M4OSA_TRACE3_0("M4WRITER_3GP_closeWrite: calling M4MP4W_closeWrite()");
err = M4MP4W_closeWrite(apContext->pMP4Context);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4WRITER_3GP_closeWrite: M4MP4W_closeWrite returns error 0x%x", err);
}
}
/**
* Deallocate our own context */
free(apContext);
M4OSA_TRACE2_1("M4WRITER_3GP_closeWrite: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_setOption(
* M4WRITER_Context pContext, M4OSA_UInt32 optionID,
* M4OSA_DataOption optionValue)
* @brief This function asks the writer to set the value associated with
* the optionID. The caller is responsible for allocating/
* de-allocating the memory of the value field.
* @note The options handled by the component depend on the implementation
* of the component.
* @param pContext: (IN) Execution context of the 3GP writer,
* @param pptionId: (IN) ID of the option to set.
* @param OptionValue : (IN) Value of the option to set.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return M4ERR_BAD_OPTION_ID: the ID of the option is not valid.
* @return any error returned by the MP4 core writer setOption (Its coreID
* is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_setOption(
M4WRITER_Context pContext, M4OSA_UInt32 optionID,
M4OSA_DataOption optionValue)
{
M4WRITER_3GP_InternalContext* apContext =
(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err = M4NO_ERROR;
M4MP4W_memAddr memval;
M4SYS_StreamIDValue optval;
M4OSA_TRACE2_3("M4WRITER_3GP_setOption: pContext=0x%x, optionID=0x%x,\
optionValue=0x%x", pContext, optionID, optionValue);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL==apContext),M4ERR_PARAMETER,
"M4WRITER_3GP_setOption: pContext is M4OSA_NULL");
switch (optionID)
{
/**
* Maximum Access Unit size */
case M4WRITER_kMaxAUSize:
M4OSA_TRACE2_0("setting M4WRITER_kMaxAUSize option");
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_maxAUsize, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_maxAUsize) "
"returns error 0x%x", err);
}
break;
/**
* Maximum chunck size */
case M4WRITER_kMaxChunckSize:
M4OSA_TRACE2_0("setting M4WRITER_kMaxChunckSize option");
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_maxChunkSize, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_maxChunkSize)\
returns error 0x%x", err);
}
break;
/**
* File string signature */
case M4WRITER_kEmbeddedString:
M4OSA_TRACE2_0("setting M4WRITER_kEmbeddedString option");
/* The given M4OSA_DataOption must actually
be a text string */
memval.addr = (M4OSA_MemAddr32)optionValue;
/**< this is max string size copied by the core */
memval.size = 16;
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_embeddedString, &memval);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_embeddedString)\
returns error 0x%x", err);
}
break;
/**
* File integration tag */
case M4WRITER_kIntegrationTag:
M4OSA_TRACE2_0("setting M4WRITER_kIntegrationTag option");
/* The given M4OSA_DataOption must actually
be a text string */
memval.addr = (M4OSA_MemAddr32)optionValue;
/**< this is max string size copied by the core */
memval.size = strlen((const char *)optionValue);
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_integrationTag, &memval);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_integrationTag)"
" returns error 0x%x", err);
}
break;
/**
* File version signature */
case M4WRITER_kEmbeddedVersion:
M4OSA_TRACE2_0("setting M4WRITER_kEmbeddedVersion option");
/* The given M4OSA_DataOption must actually
be a version number */
/**< Here 0 means both streams */
optval.streamID = 0;
/**< version number */
optval.value = *(M4OSA_UInt32*)optionValue;
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_CamcoderVersion, &optval);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_CamcoderVersion)"
" returns error 0x%x", err);
}
break;
/**
* Some options are read-only */
case M4WRITER_kFileSize:
case M4WRITER_kFileSizeAudioEstimated:
M4OSA_TRACE2_1("trying to set a read-only option! (ID=0x%x)",
optionID);
return (M4OSA_ERR)M4ERR_READ_ONLY;
break;
/**
* Maximum filesize limitation */
case M4WRITER_kMaxFileSize:
M4OSA_TRACE2_0("setting M4WRITER_kMaxFileSize option");
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_maxFileSize, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_maxFileSize)\
returns error 0x%x", err);
}
break;
/**
* Maximum file duration limitation */
case M4WRITER_kMaxFileDuration:
M4OSA_TRACE2_0("setting M4WRITER_kMaxFileDuration option");
err = M4MP4W_setOption(
apContext->pMP4Context,M4MP4W_maxFileDuration, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4WRITER_kMaxFileDuration)"
" returns error 0x%x", err);
}
break;
/**
* Set 'ftyp' atom */
case M4WRITER_kSetFtypBox:
M4OSA_TRACE2_0("setting M4WRITER_kSetFtypBox option");
err = M4MP4W_setOption(
apContext->pMP4Context, M4MP4W_setFtypBox, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_setFtypBox)\
returns error 0x%x", err);
}
break;
/**
* Decoder Specific Info */
case M4WRITER_kDSI:
M4OSA_TRACE2_0("setting M4WRITER_kDSI option");
err = M4MP4W_setOption(
apContext->pMP4Context, M4MP4W_DSI, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_DSI)\
returns error 0x%x", err);
}
break;
/*+ H.264 Trimming */
case M4WRITER_kMUL_PPS_SPS:
M4OSA_TRACE2_0("setting M4WRITER_kMUL_PPS_SPS option");
err = M4MP4W_setOption(
apContext->pMP4Context, M4MP4W_MUL_PPS_SPS, optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_setOption(M4MP4W_DSI)\
returns error 0x%x", err);
}
break;
/*- H.264 Trimming */
/**
* Unknown option */
default:
M4OSA_TRACE2_1("trying to set an unknown option!\
(optionID=0x%x)", optionID);
return (M4OSA_ERR)M4ERR_BAD_OPTION_ID;
break;
}
M4OSA_TRACE3_1("M4WRITER_3GP_setOption: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_getOption(
* M4WRITER_Context pContext, M4OSA_UInt32 optionID,
* M4OSA_DataOption optionValue)
* @brief This function asks the writer to return the value associated with
* the optionID. The caller is responsible for allocating/
* de-allocating the memory of the value field.
* @note The options handled by the component depend on the implementation
* of the component.
* @param pContext: (IN) Execution context of the 3GP writer,
* @param OptionId: (IN) Id of the option to get.
* @param pOptionValue: (OUT) Value of the option to get.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only)
* @return M4ERR_BAD_OPTION_ID: the ID of the option is not valid.
* @return M4ERR_NOT_IMPLEMENTED: This option is not implemented yet.
* @return any error returned by the MP4 core writer getOption (Its coreID
* is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_getOption(
M4WRITER_Context pContext, M4OSA_UInt32 optionID,
M4OSA_DataOption optionValue)
{
M4WRITER_3GP_InternalContext* apContext =
(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err;
M4OSA_TRACE2_3("M4WRITER_3GP_getOption: pContext=0x%x, optionID=0x%x,\
optionValue=0x%x", pContext, optionID, optionValue);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext),M4ERR_PARAMETER,
"M4WRITER_3GP_getOption: pContext is M4OSA_NULL");
switch (optionID)
{
/**
* Maximum Access Unit size */
case M4WRITER_kMaxAUSize:
M4OSA_TRACE2_0("getting M4WRITER_kMaxAUSize option");
err = M4MP4W_getOption(apContext->pMP4Context,M4MP4W_maxAUsize,
(M4OSA_DataOption*)&optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_getOption(M4MP4W_maxAUsize)"
" returns error 0x%x", err);
}
break;
/**
* Maximum chunck size */
case M4WRITER_kMaxChunckSize:
M4OSA_TRACE2_0("getting M4WRITER_kMaxChunckSize option");
err = M4MP4W_getOption(apContext->pMP4Context,M4MP4W_maxChunkSize,
(M4OSA_DataOption*)&optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_getOption(M4MP4W_maxChunkSize)\
returns error 0x%x", err);
}
break;
/**
* The file size option */
case M4WRITER_kFileSize:
M4OSA_TRACE2_0("getting M4WRITER_kFileSize option");
/* get the current file size */
err = M4MP4W_getCurrentFileSize(
apContext->pMP4Context, (M4OSA_UInt32*)optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_getCurrentFileSize"
" returns error 0x%x", err);
}
break;
/**
* The file size with audio option has its own function call
in the MP4 core writer */
case M4WRITER_kFileSizeAudioEstimated:
M4OSA_TRACE2_0("getting M4WRITER_kFileSizeAudioEstimated option");
/* get the current file size ... */
err = M4MP4W_getCurrentFileSize(
apContext->pMP4Context, (M4OSA_UInt32*)optionValue);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_getCurrentFileSize"
" returns error 0x%x", err);
}
//no more needed 3gp writer has its own mecanism
///* ... add the estimated next max AU size */
//*((M4OSA_UInt32*)optionValue) += apContext->maxAUsizes;
break;
/**
* Unknown option */
default:
M4OSA_TRACE2_1("trying to get an unknown option!\
(optionID=0x%x)", optionID);
return (M4OSA_ERR)M4ERR_BAD_OPTION_ID;
break;
}
M4OSA_TRACE3_1("M4WRITER_3GP_getOption: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_startAU(
* M4WRITER_Context pContext, M4SYS_StreamID streamID,
* M4SYS_AccessUnit* pAU)
* @brief Prepare an Access Unit to be ready to store data
* @note
* @param pContext: (IN) Execution context of the 3GP writer,
* @param streamID: (IN) Id of the stream to which the Access Unit
* is related.
* @param pAU: (IN/OUT) Access Unit to be prepared.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext or pAU is M4OSA_NULL (debug only)
* @return M4ERR_BAD_STREAM_ID: streamID is not VideoStreamID nor
* AudioStreamID (debug only)
* @return any error returned by the MP4 core writer startAU (Its coreID
* is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_startAU(
M4WRITER_Context pContext, M4SYS_StreamID streamID,
M4SYS_AccessUnit* pAU)
{
M4WRITER_3GP_InternalContext* apContext =
(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err;
M4OSA_TRACE2_3("M4WRITER_3GP_startAU: pContext=0x%x, streamID=%d, pAU=0x%x",
pContext, streamID, pAU);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext), M4ERR_PARAMETER,
"M4WRITER_3GP_startAU: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pAU), M4ERR_PARAMETER,
"M4WRITER_3GP_startAU: pAU is M4OSA_NULL");
M4OSA_DEBUG_IF2(
((VideoStreamID != streamID) && (AudioStreamID != streamID)),
M4ERR_BAD_STREAM_ID,
"M4WRITER_3GP_processAU: Wrong streamID");
/**
* Call the MP4 writer */
M4OSA_TRACE3_0("M4WRITER_3GP_startAU: calling M4MP4W_startAU()");
err = M4MP4W_startAU(apContext->pMP4Context, streamID, pAU);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_startAU returns error 0x%x", err);
}
M4OSA_TRACE3_2("AU: dataAddress=0x%x, size=%d",
pAU->dataAddress, pAU->size);
/* Convert oversize to a request toward VES automaton */
if (M4WAR_MP4W_OVERSIZE == err)
{
err = M4WAR_WRITER_STOP_REQ;
}
M4OSA_TRACE3_1("M4WRITER_3GP_startAU: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_processAU(
* M4WRITER_Context pContext, M4SYS_StreamID streamID,
* M4SYS_AccessUnit* pAU)
* @brief Write an Access Unit
* @note
* @param pContext: (IN) Execution context of the 3GP writer,
* @param streamID: (IN) Id of the stream to which the Access Unit
* is related.
* @param pAU: (IN/OUT) Access Unit to be written
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: pContext or pAU is M4OSA_NULL (debug only)
* @return M4ERR_BAD_STREAM_ID: streamID is not VideoStreamID nor
* AudioStreamID (debug only)
* @return any error returned by the MP4 core writer processAU
* (Its coreID is M4MP4_WRITER)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_processAU(
M4WRITER_Context pContext, M4SYS_StreamID streamID,
M4SYS_AccessUnit* pAU)
{
M4WRITER_3GP_InternalContext* apContext =
(M4WRITER_3GP_InternalContext*)pContext;
M4OSA_ERR err;
M4OSA_TRACE2_3("M4WRITER_3GP_processAU: "
"pContext=0x%x, streamID=%d, pAU=0x%x",
pContext, streamID, pAU);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == apContext), M4ERR_PARAMETER,
"M4WRITER_3GP_processAU: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == pAU), M4ERR_PARAMETER,
"M4WRITER_3GP_processAU: pAU is M4OSA_NULL");
M4OSA_DEBUG_IF2(
((VideoStreamID != streamID) && (AudioStreamID != streamID)),
M4ERR_BAD_STREAM_ID,
"M4WRITER_3GP_processAU: Wrong streamID");
M4OSA_TRACE3_4("M4WRITER_3GP_processAU: AU: "
"dataAddress=0x%x, size=%d, CTS=%d, nbFrag=%d",
pAU->dataAddress, pAU->size, (M4OSA_UInt32)pAU->CTS, pAU->nbFrag);
if(pAU->size > apContext->maxAUsizes)
{
apContext->maxAUsizes = pAU->size;
}
/**
* Call the MP4 writer */
M4OSA_TRACE3_0("M4WRITER_3GP_processAU: calling M4MP4W_processAU()");
err = M4MP4W_processAU(apContext->pMP4Context, streamID, pAU);
if (M4OSA_ERR_IS_ERROR(err))
{
M4OSA_TRACE1_1("M4MP4W_processAU returns error 0x%x", err);
}
/* Convert oversize to a request toward VES automaton */
if(M4WAR_MP4W_OVERSIZE == err)
{
err = M4WAR_WRITER_STOP_REQ;
}
M4OSA_TRACE3_1("M4WRITER_3GP_processAU: returning 0x%x", err);
return err;
}
/******************************************************************************
* M4OSA_ERR M4WRITER_3GP_getInterfaces(
* M4WRITER_OutputFileType* Type,
* M4WRITER_GlobalInterface** SrcGlobalInterface,
* M4WRITER_DataInterface** SrcDataInterface)
* @brief Get the 3GPP writer common interface
* @note Retrieves the set of functions needed to use the 3GPP writer.
* It follows the common writer interface.
* @param Type: (OUT) return the type of this writer. Will always be
* M4WRITER_k3GPP.
* @param SrcGlobalInterface: (OUT) Main set of function to use this
* 3GPP writer
* @param SrcDataInterface: (OUT) Set of function related to datas
* to use this 3GPP writer
* @return M4NO_ERROR: there is no error
* @return M4ERR_ALLOC: there is no more available memory
* @return M4ERR_PARAMETER: At least one of the parameters is M4OSA_NULL
* (debug only)
******************************************************************************
*/
M4OSA_ERR M4WRITER_3GP_getInterfaces(
M4WRITER_OutputFileType* Type,
M4WRITER_GlobalInterface** SrcGlobalInterface,
M4WRITER_DataInterface** SrcDataInterface)
{
M4WRITER_GlobalInterface *pGlobal;
M4WRITER_DataInterface *pData;
M4OSA_TRACE2_3("M4WRITER_3GP_getInterfaces: "
"Type=0x%x, SrcGlobalInterface=0x%x,\
SrcDataInterface=0x%x", Type, SrcGlobalInterface, SrcDataInterface);
/**
* Check input parameter */
M4OSA_DEBUG_IF2((M4OSA_NULL == Type), M4ERR_PARAMETER,
"M4WRITER_3GP_getInterfaces: Type is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == SrcGlobalInterface), M4ERR_PARAMETER,
"M4WRITER_3GP_getInterfaces: SrcGlobalInterface is M4OSA_NULL");
M4OSA_DEBUG_IF2((M4OSA_NULL == SrcDataInterface), M4ERR_PARAMETER,
"M4WRITER_3GP_getInterfaces: SrcDataInterface is M4OSA_NULL");
/**
* Set the output type */
*Type = M4WRITER_k3GPP;
/**
* Allocate the global interface structure */
pGlobal = (M4WRITER_GlobalInterface*)M4OSA_32bitAlignedMalloc(
sizeof(M4WRITER_GlobalInterface),
M4WRITER_3GP, (M4OSA_Char *)"M4WRITER_GlobalInterface");
if (M4OSA_NULL == pGlobal)
{
M4OSA_TRACE1_0("unable to allocate M4WRITER_GlobalInterface,\
returning M4ERR_ALLOC");
*SrcGlobalInterface = M4OSA_NULL;
*SrcDataInterface = M4OSA_NULL;
return (M4OSA_ERR)M4ERR_ALLOC;
}
/**
* Allocate the data interface structure */
pData =
(M4WRITER_DataInterface *)M4OSA_32bitAlignedMalloc(sizeof(M4WRITER_DataInterface),
M4WRITER_3GP, (M4OSA_Char *)"M4WRITER_DataInterface");
if (M4OSA_NULL == pData)
{
M4OSA_TRACE1_0("unable to allocate M4WRITER_DataInterface,\
returning M4ERR_ALLOC");
free(pGlobal);
*SrcGlobalInterface = M4OSA_NULL;
*SrcDataInterface = M4OSA_NULL;
return (M4OSA_ERR)M4ERR_ALLOC;
}
/**
* Fill the global interface structure */
pGlobal->pFctOpen = M4WRITER_3GP_openWrite;
pGlobal->pFctAddStream = M4WRITER_3GP_addStream;
pGlobal->pFctStartWriting = M4WRITER_3GP_startWriting;
pGlobal->pFctCloseWrite = M4WRITER_3GP_closeWrite;
pGlobal->pFctSetOption = M4WRITER_3GP_setOption;
pGlobal->pFctGetOption = M4WRITER_3GP_getOption;
/**
* Fill the data interface structure */
pData->pStartAU = M4WRITER_3GP_startAU;
pData->pProcessAU = M4WRITER_3GP_processAU;
/**
* Set the return values */
*SrcGlobalInterface = pGlobal;
*SrcDataInterface = pData;
M4OSA_TRACE2_0("M4WRITER_3GP_getInterfaces: returning M4NO_ERROR");
return M4NO_ERROR;
}