// Copyright (c) 2002-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 <e32std.h>

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfpaniccodes.h>

#include <mmfformatimplementationuids.hrh>

#include "mmfclientaudioconverter.h"

// declared in the recorder module

void Panic(TInt aPanicCode);

//CMdaAudioConvertUtility

/**

Returns the current utility state.

@return The state of the audio sample data. See CMdaAudioClipUtility::TState.

@since  5.0

*/

CMdaAudioClipUtility::TState CMdaAudioConvertUtility::State()

	{

	ASSERT(iProperties);

	return iProperties->State();

	}

/**

Closes the current audio clip.

@since  5.0

*/

void CMdaAudioConvertUtility::Close()

	{

	ASSERT(iProperties);

	iProperties->Close();

	}

/**

This function is mapped to ConvertL(). ConvertL() should be used instead.

@see ConvertL()

@since  5.0

*/

void CMdaAudioConvertUtility::PlayL()

	{

	ASSERT(iProperties);

	iProperties->PlayL();

	}

/**

This function is mapped to ConvertL. ConvertL() should be used instead.

@since  5.0

*/

void CMdaAudioConvertUtility::RecordL()

	{

	ASSERT(iProperties);

	iProperties->RecordL();

	}

/**

Stops the current operation (playback/recording/conversion).

When conversion has been stopped, successfully or otherwise, the client is notified by 

MMdaObjectStateChangeObserver::MoscoStateChangeEvent(). The callback is initiated by this function 

providing it with state change information and error codes.

@since  5.0

*/

void CMdaAudioConvertUtility::Stop()

	{

	ASSERT(iProperties);

	iProperties->Stop();

	}

/**

Crops the current clip from the current position. The remainder of the clip is discarded.

The effects of the function cannot be undone. The function is synchronous and can leave if there is 

a problem. The leave code depends on the configuration.

@since  5.0

*/

void CMdaAudioConvertUtility::CropL()

	{

	ASSERT(iProperties);

	iProperties->CropL(ETrue);

	}

/**

Sets the current position in the audio clip.

A subsequent call to ConvertL() starts conversion from this new position.

@param  aPosition

        The position in the audio clip, in microseconds.

@since  5.0

*/

void CMdaAudioConvertUtility::SetPosition(const TTimeIntervalMicroSeconds& aPosition)

	{

	ASSERT(iProperties);

	iProperties->SetPosition(aPosition);

	}

/**

Returns the current position in the audio clip. The position is defined in terms of a time interval

measured from the beginning of the audio sample data.

@return The current position in the audio clip, in microseconds.

@since  5.0

*/

const TTimeIntervalMicroSeconds& CMdaAudioConvertUtility::Position()

	{

	ASSERT(iProperties);

	return iProperties->Position();

	}

/**

Returns the amount of recording time available to the current clip.

@return The recording time available measured in microseconds.

@since  5.0

*/

const TTimeIntervalMicroSeconds& CMdaAudioConvertUtility::RecordTimeAvailable()

	{

	ASSERT(iProperties);

	return iProperties->RecordTimeAvailable();

	}

/**

Returns the duration of the audio clip.

@return The duration in microseconds.

@since  5.0

*/

const TTimeIntervalMicroSeconds& CMdaAudioConvertUtility::Duration()

	{

	ASSERT(iProperties);

	return iProperties->Duration();

	}

/**

Sets a window for playback.

The window is defined in terms of a start and end time. A subsequent call to ConvertL() results 

in just the data within the window being converted.

@param  aStart

        The position in the clip to start playback, in microseconds. This must be any value from zero

        to aEnd. If this value is less than zero or greater than aEnd, this function raises 

        EMMFMediaClientPanicServerCommunicationProblem panic in debug version.

@param  aEnd

        The position in the clip to end playback, in microseconds. This must be any value from aStart 

        to the value returned by Duration(). If this value is greater than the value returned by 

        Duration() or less than aStart, this function raises EMMFMediaClientPanicServerCommunicationProblem panic in debug version.

@since  5.0

*/

void CMdaAudioConvertUtility::SetPlayWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd)

	{

	ASSERT(iProperties);

	iProperties->SetPlayWindow(aStart, aEnd);

	}

/**

Clears the playback window. 

Playback returns to playing the entire clip. A subsequent call to ConvertL() results in the entire 

source audio being converted.

@since  5.0

*/

void CMdaAudioConvertUtility::ClearPlayWindow()

	{

	ASSERT(iProperties);

	iProperties->ClearPlayWindow();

	}

/**

Sets the number of repetitions for playback. This is unsupported for CMdaConvertUtility as there is

no playback facility. It is provided only for binary compatibility.

@param  aRepeatNumberOfTimes

        The number of times to repeat the audio clip, after the first playback. If this is set to 

        KMdaRepeatForever, then the audio sample, together with the trailing silence, is repeated 

        indefinitely. If this is set to zero, then the audio sample is not repeated.

@param  aTrailingSilence

        A delay to wait before each repetition.

@since  5.0

*/

void CMdaAudioConvertUtility::SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence)

	{

	ASSERT(iProperties);

	iProperties->SetRepeats(aRepeatNumberOfTimes, aTrailingSilence);

	}

/**

Sets the maximum size of an audio clip.

This function is provided so that applications such as recorders and converters can limit the amount 

of file storage/memory that should be allocated.

@param  aMaxWriteLength

        The maximum size of the audio clip, in bytes. If the default value is used, there is no 

        maximum file size.

@since 7.0

*/

void CMdaAudioConvertUtility::SetMaxWriteLength(TInt aMaxWriteLength /* = KMdaClipLocationMaxWriteLengthNone*/)

	{

	ASSERT(iProperties);

	iProperties->SetMaxWriteLength(aMaxWriteLength);

	}

/**

Crops the audio clip from the start of the file to the current position. The audio data

prior to the current position is discarded.

The effects of the function cannot be undone.

The function is synchronous and can leave if there is a problem. The leave code depends on the

configuration.

@since 7.0s

*/

void CMdaAudioConvertUtility::CropFromBeginningL()

	{

	ASSERT(iProperties);

	iProperties->CropL(EFalse);

	}

/**

Constructs and initialises a new instance of the audio converter for converting audio sample data 

from one format to another.

The function leaves if the audio converter object cannot be created.

@param  aObserver

        The class to receive state change events from converter.

@param  aServer

        No longer used, should be NULL.

@param  aPriority

        The Priority Value - this client's relative priority. This is a value between EMdaPriorityMin and 

        EMdaPriorityMax and represents a relative priority. A higher value indicates a more important request.

@param  aPref

        The Priority Preference - an additional audio policy parameter. The suggested default is 

        EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

        values may be supported by given phones and/or platforms, but should not be depended upon by 

        portable code.

@return A pointer to a new instance of CMdaAudioConvertUtility.

@since  5.0

Note: The Priority Value and Priority Preference are used primarily when deciding what to do when

several audio clients attempt to play or record simultaneously. In addition to the Priority Value and Preference, 

the adaptation may consider other parameters such as the SecureId and Capabilities of the client process. 

Whatever, the decision  as to what to do in such situations is up to the audio adaptation, and may

vary between different phones. Portable applications are advised not to assume any specific behaviour. 

*/

EXPORT_C CMdaAudioConvertUtility* CMdaAudioConvertUtility::NewL(MMdaObjectStateChangeObserver& aObserver,

																CMdaServer* /*aServer*/,

																TInt aPriority,

																TInt aPref)

	{

	CMdaAudioConvertUtility* self = new(ELeave) CMdaAudioConvertUtility();

	CleanupStack::PushL(self);

	self->iProperties = new(ELeave) CMMFMdaAudioConvertUtility(self, aObserver);

	self->iProperties->ConstructL(aPriority, aPref);

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor. 

Closes the audio clip and frees resources.

@since  5.0

*/

CMdaAudioConvertUtility::~CMdaAudioConvertUtility()

	{

	delete iProperties;

	}

/**

Ensures that any subsequent calls to OpenXYZ() will create controllers that

share a heap.

The default behaviour is that for each converter utility a controller with its own heap

is created. Each heap uses a chunk, so using this function avoids situations where 

the number of chunks per process is limited.

The default behaviour is generally to be preferred, and should give lower overall

memory usage. However, if many controllers are to be created for a particular thread,

then this function should be used to prevent running out of heaps or chunks.

@since	9.2

*/

EXPORT_C void CMdaAudioConvertUtility::UseSharedHeap()

	{

	ASSERT(iProperties);

	iProperties->UseSharedHeap();

	}

/**

Opens source and target files (both of which must already exist) so that audio sample data can be 

extracted from the source file, converted and appended to the target file.

When opening is complete, successfully or otherwise, the client is notified by 

MMdaObjectStateChangeObserver::MoscoStateChangeEvent(). The callback is initiated by this function 

providing it with state change information and error codes.

@param  aPrimaryFile

        The full path and filename of a file containing audio sample data to be converted.

@param  aSecondaryFile

        The full path and filename of a file to which converted data is appended.

@since  5.0

*/

void CMdaAudioConvertUtility::OpenL(const TDesC& aPrimaryFile, const TDesC& aSecondaryFile)

	{

	ASSERT(iProperties);

	iProperties->OpenL(aPrimaryFile, aSecondaryFile);

	}

/**

Opens an existing audio file so that audio sample data can be extracted from it, converted and 

placed into the target audio object.

When opening is complete, successfully or otherwise, the client is notified by 

MMdaObjectStateChangeObserver::MoscoStateChangeEvent(). The callback is initiated by this function 

providing it with state change information and error codes.

@param  aPrimaryFile

        The full path and filename of a file containing audio sample data to be converted.

@param  aLocation

        The target location for the audio data. This is normally a file (TMdaFileClipLocation) or a 

        descriptor (TMdaDesClipLocation).

@param  aFormat

        The audio format for the target audio object.

@param  aArg1

        The codec to use for the target audio object.

@param  aArg2

        The audio settings for the target audio object.

@since  5.0

*/

void CMdaAudioConvertUtility::OpenL(const TDesC& aPrimaryFile, TMdaClipLocation* aLocation, TMdaClipFormat* aFormat,

									TMdaPackage* aArg1 /*= NULL*/, TMdaPackage* aArg2 /*= NULL*/)

	{

	ASSERT(iProperties);

	iProperties->OpenL(aPrimaryFile, aLocation, aFormat, aArg1, aArg2);

	}

/**

Opens an audio clip for conversion.

@param  aPriLocation

        The source location for audio data. This is normally a file (TMdaFileClipLocation) or a 

        descriptor (TMdaDesClipLocation).

@param  aSecLocation

        The target location for audio data. This is normally a file (TMdaFileClipLocation) or a 

        descriptor (TMdaDesClipLocation).

@param  aPriFormat

        The audio format of the source audio object.

@param  aSecFormat

        The audio format for the target audio object.

@param  aPriArg1

        The codec used by the source audio object.

@param  aPriArg2

        The audio settings of the source audio object.

@param  aSecArg1

        The codec to be used for the target audio object.

@param  aSecArg2

        The audio settings for the target audio object.

@since  5.0

*/

void CMdaAudioConvertUtility::OpenL(TMdaClipLocation* aPriLocation, TMdaClipLocation* aSecLocation,

									TMdaClipFormat* aPriFormat,  TMdaClipFormat* aSecFormat,

									TMdaPackage* aPriArg1 /*= NULL*/, TMdaPackage* aPriArg2 /*= NULL*/,

									TMdaPackage* aSecArg1 /*= NULL*/, TMdaPackage* aSecArg2 /*= NULL*/)

	{

	ASSERT(iProperties);

	iProperties->OpenL(aPriLocation, aSecLocation, aPriFormat, aSecFormat, aPriArg1, aPriArg2, aSecArg1, aSecArg2);

	}

// New functions for 7.0s

/**

Opens source and target audio objects and specifies controller and audio format and codec 

information.

When opening is complete, successfully or otherwise, the client is notified by 

MMdaObjectStateChangeObserver::MoscoStateChangeEvent(). The callback is initiated by this function

providing it with state change information and error codes.

@param  aPriLocation

        The source location for audio data. This is normally a file (TMdaFileClipLocation) or a 

        descriptor (TMdaDesClipLocation).

@param  aSecLocation

        The destination location for the converted audio data. This is normally a file 

        (TMdaFileClipLocation) or a descriptor (TMdaDesClipLocation).

@param  aControllerUid

        The UID of the controller to used for conversion.

@param  aDestFormatUid

        The UID of the destination format.

@param  aDestDataType

        The audio codec to use for the destination data sink.

@since  7.0s

*/

EXPORT_C void CMdaAudioConvertUtility::OpenL(TMdaClipLocation* aPriLocation, TMdaClipLocation* aSecLocation, TUid aControllerUid,

											  TUid aDestFormatUid, TFourCC aDestDataType)

	{

	ASSERT(iProperties);

	iProperties->OpenL(aPriLocation, aSecLocation, aControllerUid, aDestFormatUid, aDestDataType);

	}

/**

Returns a list of the supported data types for the conversion destination.

@param  aSupportedDestinationDataTypes

        A list of four character codes, representing the supported data

        encodings for the conversion destination.

@since  7.0s

*/

EXPORT_C void CMdaAudioConvertUtility::GetSupportedDestinationDataTypesL(RArray<TFourCC>& aSupportedDestinationDataTypes)

	{

	ASSERT(iProperties);

	iProperties->GetSupportedDestinationDataTypesL(aSupportedDestinationDataTypes);

	}

/**

Sets the data type of the destination audio clip.

@param  aCodec

        The four character code, representing the encoding of the destination audio clip

@since  7.0s

*/

EXPORT_C void CMdaAudioConvertUtility::SetDestinationDataTypeL(TFourCC aCodec)

	{

	ASSERT(iProperties);

	iProperties->SetDestinationDataTypeL(aCodec);

	}

/**

Returns the data type of the destination audio clip.

@return The four character code, representing the encoding of the destination audio clip.

@since  7.0s

*/

EXPORT_C TFourCC CMdaAudioConvertUtility::DestinationDataTypeL()

	{

	ASSERT(iProperties);

	return iProperties->DestinationDataTypeL();

	}

/**

Returns the data type of the source audio clip.

@return The four character code, representing the encoding of the source audio clip.

@since  7.0s

*/

EXPORT_C TFourCC CMdaAudioConvertUtility::SourceDataTypeL()

	{

	ASSERT(iProperties);

	return iProperties->SourceDataTypeL();

	}

/**

Sets the bit rate of the destination audio clip.

The bit rate must be one of the supported bit rates of the audio target. Use

GetSupportedConversionBitRatesL() to retrieve a list of supported bit rates.

@param  aBitRate

        The destination bit rate in bits/second.

@since  7.0s

*/

EXPORT_C void CMdaAudioConvertUtility::SetDestinationBitRateL(TUint aBitRate)

	{

	ASSERT(iProperties);

	iProperties->SetDestinationBitRateL(aBitRate);

	}

/**

Returns the bit rate of the destination audio clip.

@return The destination bit rate in bits/second.

@since  7.0s

*/

EXPORT_C TUint CMdaAudioConvertUtility::DestinationBitRateL()

	{

	ASSERT(iProperties);

	return iProperties->DestinationBitRateL();

	}

/**

Gets a list of the supported bit rates for the conversion destination.

@param  aSupportedBitRates