// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include <e32debug.h>
#include <c3gplibrary.h>
#if defined (COMPOSE_DEBUG)
#define DEBUG_PRINT RDebug::Print
#else
#define DEBUG_PRINT
#endif
const TInt KMinWriteBufferMaxCount = 6;
_LIT(K3GPComposePanicName, "C3GPCompose");
// This is video base class containing common video properties.
T3GPVideoPropertiesBase::T3GPVideoPropertiesBase(T3GPVideoType aType,
TUint aTimescale, const TSize& aSize) :
iType(aType), iTimescale(aTimescale), iSize(aSize)
{
}
/**
This structure stores the common and MPEG-4 video specific properties of video data.
@param aTimescale Timescale of the video data. This is the number of time units that
pass in one second.
@param aSize Video width and height in pixels.
@param aMaxBitRate Maximum video bit rate.
@param aAvgBitRate Average video bit rate.
@param aDecoderSpecificInfo MPEG-4 video DecoderSpecificInfo data stored in an ESDS atom.
*/
EXPORT_C T3GPVideoPropertiesMpeg4Video::T3GPVideoPropertiesMpeg4Video(TUint aTimescale,
const TSize& aSize, TUint aMaxBitRate, TUint aAvgBitRate, const TDesC8& aDecoderSpecificInfo) :
T3GPVideoPropertiesBase(E3GPMpeg4Video, aTimescale, aSize),
iMaxBitRate(aMaxBitRate),
iAvgBitRate(aAvgBitRate),
iDecoderSpecificInfo(aDecoderSpecificInfo)
{
}
/**
This structure stores the common and H.263 specific properties of video data.
@param aTimescale Timescale of the video data. This is the number of time units that
pass in one second.
@param aSize Video width and height in pixels.
@param aVideoLevel Indicates the H263 video level.
@param aProfile Indicates the H263 profile.
*/
EXPORT_C T3GPVideoPropertiesH263::T3GPVideoPropertiesH263(TUint aTimescale, const TSize& aSize,
TInt aVideoLevel, TProfile aProfile) :
T3GPVideoPropertiesBase((aProfile == EProfile0) ? E3GPH263Profile0 : E3GPH263Profile3,
aTimescale, aSize), iVideoLevel(aVideoLevel)
{
}
/**
This structure stores the common and AVC specific properties of video data.
@param aTimescale Timescale of the video data. This is the number of time units that
pass in one second.
@param aSize Video width and height in pixels.
@param aDecoderSpecificInfo AVCDecoderConfigurationRecord data that will be stored in the avcC atom.
*/
EXPORT_C T3GPVideoPropertiesAvc::T3GPVideoPropertiesAvc(TUint aTimescale, const TSize& aSize,
const TDesC8& aDecoderSpecificInfo) :
T3GPVideoPropertiesBase(E3GPAvcProfileBaseline, aTimescale, aSize),
iDecoderSpecificInfo(aDecoderSpecificInfo)
{
/*
NOTE: Although Baseline profile is being set here, it's just used to indicate
the fact that we have AVC data. The underlying 3GP lib does not differentiate
between profiles when composing a file. It simply writes the contents of
iDecoderSpecificInfo (which contains the profile amongst other things)
verbatim into the "avcC" box.
*/
}
// This is audio base class containing common audio properties.
T3GPAudioPropertiesBase::T3GPAudioPropertiesBase(T3GPAudioType aType,
TUint aTimescale, TInt aFramesPerSample) :
iType(aType), iTimescale(aTimescale), iFramesPerSample(aFramesPerSample)
{
__ASSERT_ALWAYS((aTimescale > 0) && (aTimescale <= KMaxTUint16), User::Panic(K3GPComposePanicName, KErrOverflow));
}
/**
This structure stores the common and MPEG-4 audio-specific properties of audio data.
@param aTimescale Timescale of the audio data. This is the number of time units that pass in one
second. It must be smaller than 65536.
@param aDecoderSpecificInfo MPEG-4 audio DecoderSpecificInfo data stored in an ESDS atom.
*/
EXPORT_C T3GPAudioPropertiesMpeg4Audio::T3GPAudioPropertiesMpeg4Audio(TUint aTimescale,
const TDesC8& aDecoderSpecificInfo) :
T3GPAudioPropertiesBase(E3GPMpeg4Audio, aTimescale, 0),
iDecoderSpecificInfo(aDecoderSpecificInfo)
{
}
/**
This structure stores the common and AMR-specific properties of audio data.
@param aTimescale Timescale of the audio data. This is the number of time units that pass in one
second. It must be smaller than 65536.
@param aFramesPerSample Frames per sample. It must be smaller than 256.
MPEG-4 audio has a fixed value of 1.
@param aModeSet AMR mode set.
@param aCodec AMR Speech Codec.
*/
EXPORT_C T3GPAudioPropertiesAmr::T3GPAudioPropertiesAmr(TUint aTimescale, TInt aFramesPerSample,
TInt aModeSet, TSpeechCodec aCodec) :
T3GPAudioPropertiesBase((aCodec == EAmrNB) ? E3GPAmrNB : E3GPAmrWB,
aTimescale, aFramesPerSample), iModeSet(aModeSet)
{
__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8),
User::Panic(K3GPComposePanicName, KErrOverflow));
}
/**
This structure stores the common and QCELP-specific properties of MPEG4 audio data. The storage mode is
automatically set to MPEG4 Audio Sample Description Box mode.
@param aTimescale Timescale of the audio data. This is the number of time units that pass in one
second. It must be smaller than 65536.
@param aFramesPerSample Frames per sample. It must be smaller than 512.
MPEG-4 audio has a fixed value of 1.
@param aDecoderSpecificInfo MPEG-4 audio decoder specific information data stored in an ESDS atom.
*/
EXPORT_C T3GPAudioPropertiesQcelp::T3GPAudioPropertiesQcelp(TUint aTimescale, TInt aFramesPerSample,
const TDesC8& aDecoderSpecificInfo) :
T3GPAudioPropertiesBase(E3GPQcelp13K, aTimescale, aFramesPerSample),
iMode(E3GPMP4AudioDescriptionBox),
iDecoderSpecificInfo(aDecoderSpecificInfo)
{
__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8),
User::Panic(K3GPComposePanicName, KErrOverflow));
}
/**
This structure stores the common and QCELP-specific properties of audio data.
@param aTimescale Timescale of the audio data. This is the number of time units that pass in one
second. It must be smaller than 65536.
@param aFramesPerSample Frames per sample. It must be smaller than 512.
MPEG-4 audio has a fixed value of 1.
*/
EXPORT_C T3GPAudioPropertiesQcelp::T3GPAudioPropertiesQcelp(TUint aTimescale, TInt aFramesPerSample) :
T3GPAudioPropertiesBase(E3GPQcelp13K, aTimescale, aFramesPerSample),
iMode(E3GPQcelpSampleEntryBox),
iDecoderSpecificInfo(KNullDesC8)
{
__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8),
User::Panic(K3GPComposePanicName, KErrOverflow));
}
/**
Create an instance of 3GP composer using default buffer count and size.
The default values for buffer count and size are as follow:
Write Buffer Size is 2048
Write Buffer Max Count is 15
@return A pointer to the newly created 3gp compose object.
@leave KErrGeneral General error.
@leave KErrNoMemory Out of memory.
@panic C3GPCompose KErrAbort if clients do not a CActiveScheduler installed already.
*/
EXPORT_C C3GPCompose* C3GPCompose::NewL()
{
// Leave if no scheduler exists
__ASSERT_ALWAYS ((CActiveScheduler::Current() != NULL), Panic(KErrAbort));
C3GPCompose* self = new (ELeave) C3GPCompose();
return self;
}
/**
Create an instance of 3GP composer, and let the user set a count limit and size of
internal buffer for composition.
The default values for buffer count and size are as follow:
Write Buffer Size is 2048
Write Buffer Max Count is 15
An increase of the buffer count and size will lead to a decrease of file I/O activities, thereby,
improves the performance of the 3GP Composer at the expense of higher memory usage.
@param aMediaWriteBufferSize Size of media data file output buffer (in bytes).
@param aWriteBufferMaxCount Maximum number of buffers (both media and meta) allowed before file
output changes to synchronous (by default file writing is asynchronous
operation). A minimum value of 6 is enforced.
@return A pointer to the newly created 3gp compose object.
@leave KErrGeneral General error.
@leave KErrNoMemory Out of memory.
@panic C3GPCompose KErrAbort if clients do not a CActiveScheduler installed already.
@panic C3GPCompose KErrArgument if Write Buffer Size is less or equal to 0 or Write Buffer Max Count is
less than 6.
*/
EXPORT_C C3GPCompose* C3GPCompose::NewL(TInt aMediaWriteBufferSize, TInt aWriteBufferMaxCount)
{
__ASSERT_ALWAYS ((aMediaWriteBufferSize > 0 && aWriteBufferMaxCount >= KMinWriteBufferMaxCount),
Panic(KErrArgument));
// Leave if no scheduler exists
__ASSERT_ALWAYS ((CActiveScheduler::Current() != NULL), Panic(KErrAbort));
C3GPCompose* self = new (ELeave) C3GPCompose(aMediaWriteBufferSize, aWriteBufferMaxCount);
return self;
}
// First phase constructor
C3GPCompose::C3GPCompose(TInt aMediaWriteBufferSize, TInt aWriteBufferMaxCount) :
iMediaWriteBufferSize(aMediaWriteBufferSize),
iWriteBufferMaxCount(aWriteBufferMaxCount),
iDuplicateFileHandleCreated(EFalse)
{
}
/**
This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.
Any combination of one video and one audio type is acceptable.
Note: Ownership of aVideo and aAudio remains with the caller. Both aVideo and aAudio are ready for
deletion after C3GPCompose::Open returns.
@param aFileFormat Specifies the file format in which the data will be created. Refer to
T3GPFileFormatType for supported file format types.
@param aVideo Specifies the video stream to be used for video data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Video Properties Classes.
If aVideo is NULL, audio-only file will be composed.
@param aAudio Specifies the audio stream to be used for audio data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Audio Properties Classes.
If aAudio is NULL, video-only file will be composed.
@param aFilename A full path name of the file to save the data to. An empty path is not allowed.
@param aFlags Optional flags for composing preferences. Refer to T3GPComposeFlag for supported flags.
The combined use of flags is acceptable. For example:
E3GPLongClip | E3GPMetaDataLast
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNoMemory if an attempt to allocate memory has failed;
KErrArgument if neither video nor audio stream is specified;
KErrAccessDenied if opening file has failed;
KErrUnderflow if the file name length is not greater than 0;
KErrInUse if the composer is currently engaged; C3GPCompose::Complete must be called to
finish the current composition before the composer can be re-initialised again.
*/
EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,
const T3GPVideoPropertiesBase* aVideo,
const T3GPAudioPropertiesBase* aAudio,
const TDesC& aFilename,
TUint aFlags)
{
if (iHandler)
{
return KErrInUse;
}
if (aFilename.Length() <= 0)
{
return KErrUnderflow;
}
if (!aVideo && !aAudio)
{
// if neither video nor audio is supplied
return KErrArgument;
}
// Create a zero terminated version of the file name
RBuf fileName;
TInt err = fileName.Create(aFilename.Length() + 1);
if (err == KErrNone)
{
fileName.Copy(aFilename);
mp4_u16* mp4FileName = const_cast<mp4_u16*>(fileName.PtrZ());
MP4Err mp4Err = MP4ComposeOpen(&iHandler, reinterpret_cast<MP4FileName>(mp4FileName), Mp4Type(aVideo, aAudio));
if (mp4Err == MP4_OK)
{
// Write audio and video properties to the 3GP file
err = SetComposeProperties(aVideo, aAudio, aFileFormat, aFlags);
if (err != KErrNone)
{
Complete(); // Ingore the error
}
}
else
{
err = SymbianOSError(mp4Err);
}
}
fileName.Close();
return err;
}
/**
This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.
Any combination of one video and one audio type is acceptable.
Note: E3GPMetaDataLast will be defaulted in aFlags if file handle is used for the initialisation
of the 3GP composer.
Note: Ownership of aVideo and aAudio remains with the caller. Both aVideo and aAudio are ready for
deletion after C3GPCompose::Open returns.
@param aFileFormat Specifies the file format in which the data will be created. Refer to
T3GPFileFormatType for supported file format types.
@param aVideo Specifies the video stream to be used for video data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Video Properties Classes.
If aVideo is NULL, audio-only file will be composed.
@param aAudio Specifies the audio stream to be used for audio data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Audio Properties Classes.
If aAudio is NULL, video-only file will be composed.
@param aFile File handle of the file to save the data to. E3GPMetaDataLast needs to be set for
aFlags when this is used.
@param aFlags Optional flags for composing preferences. Refer to T3GPComposeFlag for supported flags.
The combined use of flags is acceptable. For example:
E3GPLongClip | E3GPMetaDataLast
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNoMemory if an attempt to allocate memory has failed;
KErrArgument if neither video nor audio stream is specified;
KErrAccessDenied if opening file has failed;
KErrInUse if the composer is currently engaged; C3GPCompose::Complete must be called to
finish the current composition before the composer can be re-initialised again.
*/
EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,
const T3GPVideoPropertiesBase* aVideo,
const T3GPAudioPropertiesBase* aAudio,
RFile& aFile,
TUint aFlags)
{
TInt err = KErrNone;
if (!iDuplicateFileHandleCreated)
{
iDuplicateFileHandleCreated = ETrue;
iFile.Close();
err = iFile.Duplicate(aFile);
if (err != KErrNone)
{
return err;
}
}
return Open(aFileFormat, aVideo, aAudio, iFile, aFlags);
}
/**
This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.
Any combination of one video and one audio type is acceptable.
Note: E3GPMetaDataLast will be defaulted in aFlags if file handle is used for the initialisation
of the 3GP composer.
Note: Ownership of aVideo and aAudio remains with the caller. Both aVideo and aAudio are ready for
deletion after C3GPCompose::Open returns.
@param aFileFormat Specifies the file format in which the data will be created. Refer to
T3GPFileFormatType for supported file format types.
@param aVideo Specifies the video stream to be used for video data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Video Properties Classes.
If aVideo is NULL, audio-only file will be composed.
@param aAudio Specifies the audio stream to be used for audio data. The input data given will
be inserted into 3GP file headers and is ready to be disposed when
C3GPCompose::Open returns. See Audio Properties Classes.
If aAudio is NULL, video-only file will be composed.
@param aFile File handle of the file to save the data to. E3GPMetaDataLast needs to be set for
aFlags when this is used.
@param aFlags Optional flags for composing preferences. Refer to T3GPComposeFlag for supported flags.
The combined use of flags is acceptable. For example:
E3GPLongClip | E3GPMetaDataLast
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNoMemory if an attempt to allocate memory has failed;
KErrArgument if neither video nor audio stream is specified;
KErrAccessDenied if opening file has failed;
KErrInUse if the composer is currently engaged; C3GPCompose::Complete must be called to
finish the current composition before the composer can be re-initialised again.
*/
EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,
const T3GPVideoPropertiesBase* aVideo,
const T3GPAudioPropertiesBase* aAudio,
RFile64& aFile,
TUint aFlags)
{
if (iHandler)
{
return KErrInUse;
}
if (!aVideo && !aAudio)
{
// if neither video nor audio is supplied
return KErrArgument;
}
TInt driveNumber = EDriveA;
TDriveInfo driveInfo;
TInt err = aFile.Drive(driveNumber, driveInfo);
if (err == KErrNone)
{
MP4Err mp4Err = MP4ComposeOpenFileHandle64(&iHandler, &aFile, static_cast<TDriveNumber>(driveNumber), Mp4Type(aVideo, aAudio));
if (mp4Err == MP4_OK)
{
// Write audio and video properties to the 3GP file
err = SetComposeProperties(aVideo, aAudio, aFileFormat, aFlags);
if (err != KErrNone)
{
Complete(); // Ingore the error
}
}
else
{
err = SymbianOSError(mp4Err);
}
}
return err;
}
/**
Destructor
Deletes all objects and releases all resource owned by this instance.
*/
EXPORT_C C3GPCompose::~C3GPCompose()
{
Complete(); // Ignore the error
}
/**
This function completes the composing operation. It frees the memory allocated by the library instance
and closes the output file.
It is necessary to call this function before the output file is guaranteed to be a valid output file
even though the file may exist prior to the call.
The composer can be reused again after this call, following another call to C3GPCompose::Open to
re-initialise the composer.
If C3GPCompose::Complete is called before the composer is initialised, it will be ignored and KErrNone
is returned.
Although during destruction of C3GPCompose, this function will be automatically called, and no error
code will be returned. Therefore, when destroying the Composer object that you have used to compose a
file, you should ensure that data is committed to the file by invoking C3GPCompose::Complete before
destroying the Composer object.
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrWrite if metadata could not be written.
*/
EXPORT_C TInt C3GPCompose::Complete()
{
MP4Err mp4Err = MP4_OK;
if (iHandler)
{
mp4Err = MP4ComposeClose(iHandler);
}
// Always reset the class member data even this function returns error
Reset();
return SymbianOSError(mp4Err);
}
// Helper function to reset class member data.
void C3GPCompose::Reset()
{
iHasVideo = EFalse;
iHasAudio = EFalse;
iHandler = NULL;
iFile.Close();
}
/**
This function writes one video frame to the output file or buffer.
The frames must be inserted according to their causal sequence. Because the library doesn't analyze
the video bit stream, frames are inserted into the 3GP file in the same order as they are entered
with this function. Therefore, the frames will not be retrieved from the resulting 3GP file or
buffer correctly if they are not in proper order.
A frame inserted with this function call will result in one 3GP sample and one 3GP chunk.
The current frame's dependency information which is using default values (E3GPDependencyUnknown &
E3GPRedundancyUnknown) is inserted.
The data is available in the output file only after calling C3GPCompose::Complete. C3GPCompose::Complete
should be called exactly once when all audio and video data has been inserted into the library.
@param aBuffer The descriptor containing the video frame data to be written.
@param aDuration Duration of video frame in timescale, see T3GPVideoPropertiesBase.
@param aKeyFrame ETrue to indicate whether this frame is a key frame. EFalse otherwise.
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNotSupported if the composer is setup for an audio-only file;
KErrUnderflow if the supplied video frame buffer data is empty;
KErrNotReady if the composer has not yet been initialised; See C3GPCompose::Open.
*/
EXPORT_C TInt C3GPCompose::WriteVideoFrame(const TDesC8& aBuffer, TUint aDuration, TBool aKeyFrame)
{
if (!iHandler)
{
return KErrNotReady;
}
if (aBuffer.Length() <= 0)
{
return KErrUnderflow;
}
if (!iHasVideo)
{
return KErrNotSupported;
}
// Insert video frame data
mp4_bool keyFrame = aKeyFrame;
mp4_u32 duration = aDuration;
MP4Err mp4Err = MP4ComposeWriteVideoFrame(iHandler, const_cast<mp4_u8*>(aBuffer.Ptr()), aBuffer.Length(), duration, keyFrame);
return SymbianOSError(mp4Err);
}
/**
This function sets the current frame's dependency information to SDTP box and writes one video frame
to the output file.
The frames must be inserted according to their causal sequence. Because the library doesn't analyze
the video bit stream, frames are inserted into the 3GP file in the same order as they are entered
with this function. Therefore, the frames will not be retrieved from the resulting 3GP file or
buffer correctly if they are not in proper order.
A frame inserted with this function call will result in one 3GP sample and one 3GP chunk.
The data is available in the output file only after calling C3GPCompose::Complete. C3GPCompose::Complete
should be called exactly once when all audio and video data has been inserted into the library.
@param aBuffer The descriptor containing the video frame data to be written.
@param aDuration Duration of video frame in timescale, see T3GPVideoPropertiesBase.
@param aKeyFrame ETrue to indicate whether this frame is a key frame. EFalse otherwise.
@param aDependencies This specifies the current frame's dependency information.
The information will be supplied into the SDTP box.
See T3GPFrameDependencies.
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNotSupported if the composer is setup for an audio-only file;
KErrUnderflow if the supplied video frame buffer data is empty;
KErrNotReady if the composer has not yet been initialised; See C3GPCompose::Open.
*/
EXPORT_C TInt C3GPCompose::WriteVideoFrame(const TDesC8& aBuffer, TUint aDuration, TBool aKeyFrame,
const T3GPFrameDependencies& aDependencies)
{
if (!iHandler)
{
return KErrNotReady;
}
if (aBuffer.Length() <= 0)
{
return KErrUnderflow;
}
if (!iHasVideo)
{
return KErrNotSupported;
}
// Insert the current frame's dependency information
MP4Err mp4Err = MP4ComposeWriteNextVideoFrameDependencies(iHandler, aDependencies.iDependsOn,
aDependencies.iIsDependedOn, aDependencies.iHasRedundancy);
if (mp4Err == MP4_OK)
{
// Insert video frame data
mp4_bool keyFrame = aKeyFrame;
mp4_u32 duration = aDuration;
mp4Err = MP4ComposeWriteVideoFrame(iHandler, const_cast<mp4_u8*>(aBuffer.Ptr()),
aBuffer.Length(), duration, keyFrame);
}
return SymbianOSError(mp4Err);
}
/**
This function writes audio frames into the output file or buffer. The data is available in the
3GP output file only after calling C3GPCompose::Complete. C3GPCompose::Complete should be called exactly
once when all audio and video data has been inserted into the library.
For MPEG-4 audio:
This function writes one MPEG audio frame to the 3GP file.
For other audio types:
This function writes a number of audio frames to the 3GP file specified during composer setup
in the input parameter aAudio when calling C3GPCompose::Open. All audio frames inserted with
one function call will be placed inside one sample in the resulting file.
Note: Only the last call can have a different number of frames if the number is less than
the number of frames per sample specified during composer setup.
@see T3GPAudioPropertiesAmr
@see T3GPAudioPropertiesQcelp
@param aBuffer The descriptor containing the audio data to be written.
@param aDuration Duration of audio frames in timescale, see T3GPAudioPropertiesBase
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrNotSupported if the composer is setup for a video-only file;
KErrUnderflow if the supplied audio frames buffer data is empty;
KErrNotReady if the composer has not yet been initialised; See C3GPCompose::Open.
*/
EXPORT_C TInt C3GPCompose::WriteAudioFrames(const TDesC8& aBuffer, TUint aDuration)
{
if (!iHandler)
{
return KErrNotReady;
}
if (aBuffer.Length() <= 0)
{
return KErrUnderflow;
}
if (!iHasAudio)
{
return KErrNotSupported;
}
mp4_u32 duration = aDuration;
// use 0 for the number of frames since it is being ignored within the mp4 library implementation
MP4Err mp4Err = MP4ComposeWriteAudioFrames(iHandler, const_cast<mp4_u8*>(aBuffer.Ptr()),
aBuffer.Length(), 0, duration);
return SymbianOSError(mp4Err);
}
/**
Writes a buffer containing whole atom to inside of user data atom (UDTA) defined in aLocation.
The buffer should contain an atom of structure that conforms to the definition of a "full box"
as specified in ISO/IEC 14496-12:2003: "Information technology – Coding of audio-visual objects
– Part 12: ISO base media file format."
For more information on user data atoms, see Section 8 – Asset Information of "3GPP TS 26.244
version 6.1.0 – 3GP file format (Rel 6)."
@param aLocation Specifies the location of user information to be written. Refer to
T3GPUdtaLocation for possible values.
@param aBuffer The descriptor containing the user information to write into file.
@return KErrNone if successful. Otherwise, returns one of the system wide error codes.
KErrGeneral if an error has no specific categorisation;
KErrArgument if asked aLocation is invalid;
KErrUnderflow if the supplied buffer data is empty;
KErrNotSupported if specify video track user data but no video type is specified,
or specify audio track user data but no audio type is specified
KErrNoMemory if an attempt to allocate memory has failed;
KErrNotReady if the composer has not yet been initialised; See C3GPCompose::Open.
@panic C3GPCompose KErrArgument if the location of user information is not of T3GPUdtaLocation.
*/
EXPORT_C TInt C3GPCompose::SetUserData(T3GPUdtaLocation aLocation, const TDesC8& aBuffer)
{
if (!iHandler)
{
return KErrNotReady;
}
if (aBuffer.Length() <= 0)
{
return KErrUnderflow;
}
if ((!iHasAudio && aLocation == E3GPUdtaAudioTrak) || (!iHasVideo && aLocation == E3GPUdtaVideoTrak))
{
return KErrNotSupported;
}
mp4_u8 location;
switch (aLocation)
{
case (E3GPUdtaMoov):
location = MP4_UDTA_MOOV;
break;
case (E3GPUdtaVideoTrak):
location = MP4_UDTA_VIDEOTRAK;
break;
case (E3GPUdtaAudioTrak):
location = MP4_UDTA_AUDIOTRAK;
break;
default:
Panic(KErrArgument);
break;
}
mp4_u32 bufferSize = aBuffer.Length();
MP4Err mp4Err = MP4ComposeSetUserDataAtom(iHandler, location, const_cast<mp4_u8*>(aBuffer.Ptr()), bufferSize);
return SymbianOSError(mp4Err);
}
// Helper function to convert 3GP/MP4 library specific error codes to system wide error codes
TInt C3GPCompose::SymbianOSError(MP4Err aError)
{
TInt error = KErrNone;
switch (aError)
{
case (MP4_OK):
break;
case (MP4_ERROR):
error = KErrGeneral;
break;
case (MP4_OUT_OF_MEMORY):
error = KErrNoMemory;
break;
case (MP4_FILE_ERROR):
error = KErrAccessDenied;
break;
case (MP4_INVALID_TYPE):
error = KErrArgument;
break;
case (MP4_METADATA_ERROR):
error = KErrWrite;
break;
default:
Panic(KErrArgument);
}
return error;
}
// Helper function to map 3GP enum type to MP4 audio and video type
mp4_u32 C3GPCompose::Mp4Type(const T3GPVideoPropertiesBase* aVideo, const T3GPAudioPropertiesBase* aAudio)
{
mp4_u32 videoType = MP4_TYPE_NONE;
mp4_u32 audioType = MP4_TYPE_NONE;
if (aVideo)
{
iHasVideo = ETrue;
switch (aVideo->iType)
{
case (E3GPMpeg4Video):
videoType = MP4_TYPE_MPEG4_VIDEO;
break;
case (E3GPH263Profile0):
videoType = MP4_TYPE_H263_PROFILE_0;
break;
case (E3GPH263Profile3):
videoType = MP4_TYPE_H263_PROFILE_3;
break;
/*
* NOTE: The underlying 3GP library does
* not differentiate between the various AVC
* profiles when composing.
*
* In all cases it will simply copy the data
* from the iDecoderSpecificInfo member of
* T3GPVideoPropertiesAvc into the 'avcC' atom.
* It does not do any checking of that data, so
* it is the API user's responsibility to ensure
* that it contains a valid AVCDecoderConfigurationRecord
* with the correct AVC profile and level.
*
* An interesting side-effect of this is that you can
* compose AVC data with arbitrary profiles even if they
* are not "supported" by this API. For example, as long
* as the AVCDecoderConfigurationRecord says there is
* High 10 profile data and the AVC data is of that profile
* then you will still end up with a valid file.
*/
case (E3GPAvcProfileBaseline):
videoType = MP4_TYPE_AVC_PROFILE_BASELINE;
break;
case (E3GPAvcProfileMain):
videoType = MP4_TYPE_AVC_PROFILE_MAIN;
break;
case (E3GPAvcProfileExtended):
videoType = MP4_TYPE_AVC_PROFILE_EXTENDED;
break;
case (E3GPAvcProfileHigh):
videoType = MP4_TYPE_AVC_PROFILE_HIGH;
break;
default:
Panic(KErrArgument);
}
}
if(aAudio)
{
iHasAudio = ETrue;
switch (aAudio->iType)
{
case (E3GPMpeg4Audio):
audioType = MP4_TYPE_MPEG4_AUDIO;
break;
case (E3GPAmrNB):
audioType = MP4_TYPE_AMR_NB;
break;
case (E3GPAmrWB):
audioType = MP4_TYPE_AMR_WB;
break;
case (E3GPQcelp13K):
audioType = MP4_TYPE_QCELP_13K;
break;
default:
Panic(KErrArgument);
}
}
return (videoType | audioType);
}
// Helper function to set compose properties
TInt C3GPCompose::SetComposeProperties(const T3GPVideoPropertiesBase* aVideo,
const T3GPAudioPropertiesBase* aAudio, T3GPFileFormatType aFileFormat, TUint aFlag)
{
mp4_u32 writeBufferSize = iMediaWriteBufferSize;
mp4_u32 writeBufferMaxCount = iWriteBufferMaxCount;
MP4Err mp4Err = MP4SetCustomFileBufferSizes(iHandler, writeBufferSize, writeBufferMaxCount, 0);
if ( mp4Err != MP4_OK)
{
return SymbianOSError(mp4Err);
}
// Set compose flag before other MP4Compose functions
TInt err = SetComposeFlag(aFileFormat, aFlag);
if (err != KErrNone)
{
return err;
}
if (aVideo)
{
switch (aVideo->iType)
{
case (E3GPMpeg4Video):
err = SetMPeg4VideoProperties(aVideo);
break;
case (E3GPAvcProfileBaseline):
case (E3GPAvcProfileMain):
case (E3GPAvcProfileExtended):
case (E3GPAvcProfileHigh):
err = SetAvcVideoProperties(aVideo);
break;
case (E3GPH263Profile0):
case (E3GPH263Profile3):
err = SetH263VideoProperties(aVideo);
break;
default:
Panic(KErrArgument);
}
}
if (err != KErrNone)
{
return err;
}
if (aAudio)
{
switch (aAudio->iType)
{
case (E3GPMpeg4Audio):
err = SetMpeg4AudioProperties(aAudio);
break;
case (E3GPQcelp13K):
err = SetQcelpAudioProperties(aAudio);
break;
case (E3GPAmrNB):
case (E3GPAmrWB):
err = SetAmrAudioProperties(aAudio);
break;
default:
Panic(KErrArgument);
}
}
return err;
}
// Inform the 3GP library about the MPeg4 video data
TInt C3GPCompose::SetMPeg4VideoProperties(const T3GPVideoPropertiesBase* aVideo)
{
const T3GPVideoPropertiesMpeg4Video* mpeg4Video = static_cast<const T3GPVideoPropertiesMpeg4Video*>(aVideo);
MP4Err err = MP4ComposeWriteVideoDecoderSpecificInfo(iHandler, const_cast<mp4_u8*>(mpeg4Video->iDecoderSpecificInfo.Ptr()),
mpeg4Video->iDecoderSpecificInfo.Length());
if ( err == MP4_OK)
{
err = MP4ComposeAddVideoDescription(iHandler, mpeg4Video->iTimescale,
mpeg4Video->iSize.iWidth, mpeg4Video->iSize.iHeight,
mpeg4Video->iMaxBitRate, mpeg4Video->iAvgBitRate);
}
return SymbianOSError(err);
}
// Inform the 3GP library about the AVC video data
TInt C3GPCompose::SetAvcVideoProperties(const T3GPVideoPropertiesBase* aVideo)
{
const T3GPVideoPropertiesAvc* avcVideo = static_cast<const T3GPVideoPropertiesAvc*>(aVideo);
MP4Err err = MP4ComposeWriteVideoDecoderSpecificInfo(iHandler, const_cast<mp4_u8*>(avcVideo->iDecoderSpecificInfo.Ptr()),
avcVideo->iDecoderSpecificInfo.Length ());
if ( err == MP4_OK)
{
// aMaxBitRate and aAvgBitRate are MPEG-4 video specific values. Set 0 for them
err = MP4ComposeAddVideoDescription(iHandler, avcVideo->iTimescale,
avcVideo->iSize.iWidth, avcVideo->iSize.iHeight, 0, 0);
}
return SymbianOSError(err);
}
// Inform the 3GP library about the H263 video data
TInt C3GPCompose::SetH263VideoProperties(const T3GPVideoPropertiesBase* aVideo)
{
// aMaxBitRate and aAvgBitRate are MPEG-4 video specific values. Set 0 for H263 video
MP4Err err = MP4ComposeAddVideoDescription(iHandler, aVideo->iTimescale,
aVideo->iSize.iWidth, aVideo->iSize.iHeight, 0, 0);
if ( err == MP4_OK)
{
const T3GPVideoPropertiesH263* h263Video = static_cast<const T3GPVideoPropertiesH263*>(aVideo);
TVideoClipProperties properties;
properties.iH263Level = h263Video->iVideoLevel;
err = MP4ComposeSetVideoClipProperties(iHandler, properties);
}
return SymbianOSError(err);
}
// Inform the 3GP library about the MPeg4 audio data
TInt C3GPCompose::SetMpeg4AudioProperties(const T3GPAudioPropertiesBase* aAudio)
{
const T3GPAudioPropertiesMpeg4Audio* mpeg4Audio = static_cast<const T3GPAudioPropertiesMpeg4Audio*>(aAudio);
MP4Err err = MP4ComposeWriteAudioDecoderSpecificInfo(iHandler, const_cast<mp4_u8*>(mpeg4Audio->iDecoderSpecificInfo.Ptr()),
mpeg4Audio->iDecoderSpecificInfo.Length ());
if ( err == MP4_OK)
{
//modeSet is needed only for AMR audio. Set it to 0 for Mpeg4 audio.
err = MP4ComposeAddAudioDescription(iHandler, mpeg4Audio->iTimescale, mpeg4Audio->iFramesPerSample, 0);
}
return SymbianOSError(err);
}
// Inform the 3GP library about the Amr audio data
TInt C3GPCompose::SetAmrAudioProperties(const T3GPAudioPropertiesBase* aAudio)
{
const T3GPAudioPropertiesAmr* amrAudio = static_cast<const T3GPAudioPropertiesAmr*>(aAudio);
//modeSet is needed only for AMR audio.
MP4Err err = MP4ComposeAddAudioDescription(iHandler, amrAudio->iTimescale,
amrAudio->iFramesPerSample, amrAudio->iModeSet);
return SymbianOSError(err);
}
// Sets the storage mode of storing 13K QCELP data in a 3G2 file
TInt C3GPCompose::SetQcelpAudioProperties(const T3GPAudioPropertiesBase* aAudio)
{
const T3GPAudioPropertiesQcelp* qcelpAudio = static_cast<const T3GPAudioPropertiesQcelp*>(aAudio);
MP4Err err = MP4ComposeSetQCELPStorageMode(iHandler, qcelpAudio->iMode);
if ( err == MP4_OK)
{
if ( qcelpAudio->iMode == E3GPMP4AudioDescriptionBox)
{
err = MP4ComposeWriteAudioDecoderSpecificInfo(iHandler, const_cast<mp4_u8*>(qcelpAudio->iDecoderSpecificInfo.Ptr()), qcelpAudio->iDecoderSpecificInfo.Length ());
}
if ( err == MP4_OK)
{
//modeSet is needed only for AMR audio. Set it to 0 for Qcelp audio.
err = MP4ComposeAddAudioDescription(iHandler, qcelpAudio->iTimescale, qcelpAudio->iFramesPerSample, 0);
}
}
return SymbianOSError(err);
}
// Set compose flag
TInt C3GPCompose::SetComposeFlag(T3GPFileFormatType aFileFormat, TUint aFlag)
{
mp4_u32 fileFormat = 0;
switch (aFileFormat)
{
case (E3GPMP4):
fileFormat = MP4_FLAG_GENERATE_MP4;
break;
case (E3GP3G2):
fileFormat = MP4_FLAG_GENERATE_3G2;
break;
case (E3GP3GP):
fileFormat = MP4_FLAG_NONE;
break;
default:
Panic(KErrArgument);
}
MP4Err err = MP4ComposeSetFlags(iHandler, aFlag | fileFormat);
return SymbianOSError(err);
}
void C3GPCompose::Panic(TInt aPanic)
// Panic client
{
User::Panic(K3GPComposePanicName, aPanic);
}