/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "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:
* Ixonos Plc
*
* Description:
*
*/
#ifndef __CPROCINFILEHANDLER_H__
#define __CPROCINFILEHANDLER_H__
#include <e32base.h>
#include <f32file.h>
#include "ProcFrameHandler.h"
#include "ProcWAVFrameHandler.h"
#include "AudCommon.h"
#include "ProcConstants.h"
#include "AudClip.h"
#include "ProcDecoder.h"
class CProcInFileHandler : public CBase
{
public:
/*
* Destructor
*/
virtual ~CProcInFileHandler();
/**
* Gets properties of this input clip
*
* @param aProperties audio clip properties. Needs to be allocated by the caller
* and is filled in by this function
*
*/
virtual void GetPropertiesL(TAudFileProperties* aProperties) = 0;
/*
*
* Is decoding required?
*/
TBool DecodingRequired();
/*
*
* Returns the size of a decoded frame
*/
TInt GetDecodedFrameSize();
/*
*
* Sets whether decoding is required?
*/
void SetDecodingRequired(TBool aDecodingRequired);
/**
* Reads the next audio frame
* This function allocates memory and
* the caller is responsible for releasing it
*
* Possible leave codes:
*
*
* @param aFrame audio frame
* @param aSize size of the retrieved audio frame
* @param aTime duration of the returned frame in milliseconds
* @return ETrue if a frame was read
* EFalse if frame was not read (EOF)
*/
TBool GetAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime, TBool& aRawFrame);
TBool GetRawAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime);
/**
* Sets properties of this in file handler
*
* @param aProperties audio clip properties
*
*/
TBool SetPropertiesL(TAudFileProperties aProperties);
/*
* Set the size of raw audio frames
*
* @param aSize audio size
*
* @return ETrue if successful, EFalse otherwise
*/
TBool SetRawAudioFrameSize(TInt aSize);
/**
* Seeks a certain audio frame for reading
*
* Possible leave codes:
*
* @param aTime time from the beginning of file in milliseconds
*
* @return ETrue if successful
* EFalse if beyond the file
*/
virtual TBool SeekAudioFrame(TInt32 aTime) = 0;
/**
* Seeks a cut in audio frame for reading
*
* Possible leave codes:
*
*
* @return ETrue if successful
*
*/
virtual TBool SeekCutInFrame() = 0;
//virtual TBool GetAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime, TBool& aRawFrame) = 0;
/**
* Generates and returns a silent audio frame
* This function allocates memory and
* the caller is responsible for releasing it.
* The silent frame is generated according to audio
* properties of this input clip
* (e.g. sampling rate, channel configuration, bitrate etc)
*
* Possible leave codes: , at least <code>KErrNotMemory</code>
*
*
* @param aFrame audio frame
* @param aSize size of the silent audio frame
* @param aDuration duration of the returned silent frame in milliseconds
* @return ETrue if a frame was generated
* EFalse if frame was not generated (EOF, no need to release aFrame)
*/
virtual TBool GetSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration, TBool& aRawFrame);
/**
* Gets the priority of this clip
*
* @return priority of this clip
*
*/
TInt Priority() const;
/**
* Gets the current time of the frame reading
*
* @return current time in milliseconds
*
*/
TInt32 GetCurrentTimeMilliseconds();
/**
* Gets the normalizing margin of this clip
*
* @return normalizing margin
*
*/
TInt8 NormalizingMargin() const;
/**
*
* Set priority of this clip
*
* @param aPriority priority >= 0
*
* @return ETrue if priority >= 0
* EFalse otherwise, priority not set
*/
TBool SetPriority(TInt aPriority);
/*
* Sets the normalizing gain of this clip
*
* @param aFrameHandler frame handler
*
* @return ETrue if successful
*/
virtual TBool SetNormalizingGainL(const CProcFrameHandler* aFrameHandler) = 0;
/**
* Gets ReadAudioDecoderSpecificInfo from file (if any)
*
* @param aBytes buffer
* @param aBufferSize maximum size of buffer
*
* @return ETrue if bytes were read (The caller must release aBytes!!)
*
* EFalse if no bytes were read (no memory releasing needed)
*
*/
virtual TBool ReadAudioDecoderSpecificInfoL(HBufC8*& aBytes, TInt aBufferSize);
protected:
// constructL
void ConstructL(const TDesC& aFileName);
// c++ constructor
CProcInFileHandler();
/**
* Reads the next raw frame
* This function allocates memory and
* the caller is responsible for releasing it
*
* Possible leave codes:
*
*
* @param aFrame audio frame
* @param aSize size of the retrieved audio frame
* @param aTime duration of the returned frame in milliseconds
* @return ETrue if a frame was read
* EFalse if frame was not read (EOF)
*/
virtual TBool GetRawSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration);
virtual TBool GetEncAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime) = 0;
virtual TBool GetEncSilentAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration);
TBool GetOneRawAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aDuration);
/**
* Performs all the necessary initializations and memory allocations needed.
* Should be always called by classes inherited from <code>CProcInFileHander</code>
*
* @param aFileName name of the file
* @param aCutInTime cut in time in milliseconds
* @param aReadBufferSize read buffer size
*
* @return ETrue if successful
*
*/
TBool InitAndOpenFileL(const TDesC& aFileName, RFile* aFileHandle, TInt aReadBufferSize);
/**
* Performs all the necessary resource releasing and file closing
*
* should be called if <code>InitAndOpenFileL</code> has been called
*
* @return ETrue if successful
*
*/
void ResetAndCloseFile();
// opens a file for readind
TBool OpenFileForReadingL();
// closes the file if open
TBool CloseFile();
// File reading methods------------------>
TInt BufferedFileRead(TDes8& aDes,TInt aLength);
TInt BufferedFileSetFilePos(TInt aPos);
TInt BufferedFileGetFilePos();
TInt BufferedFileGetSize();
TInt BufferedFileRead(TInt aPos,TDes8& aDes);
TInt BufferedFileRead(TDes8& aDes);
TInt BufferedFileReadChar(TInt aPos, TUint8& aChar);
// <------------------ File reading methods
TBool ManipulateGainL(HBufC8*& aFrameIn);
// function for gain manipulation
TInt8 GetGainNow();
TBool WriteDataToInputBufferL(const TDesC8& aData);
protected:
// is inputfile open?
TBool iFileOpen;
// file name
HBufC* iFileName;
// RFile
RFile iFile;
// file server session
RFs iFs;
// read buffer
HBufC8* iReadBuffer;
// size of the read buffer
TInt iReadBufferSize;
// start offset of the read buffer
TInt iBufferStartOffset;
// end offset of the read buffer
TInt iBufferEndOffset;
// current file position
TInt iFilePos;
// cut in time in milliseconds
TInt32 iCutInTime;
// current read time in milliseconds
TInt32 iCurrentTimeMilliseconds;
// priority of the clip
TInt iPriority;
// normalizing margin in dB/2
TInt8 iNormalizingMargin;
// audio file properties
TAudFileProperties* iProperties;
// silent frame
HBufC8* iSilentFrame;
// duration of the silent frame
TInt32 iSilentFrameDuration;
// raw silent frame
HBufC8* iRawSilentFrame;
// duration of the raw silent frame
TInt iRawSilentFrameDuration;
// if true, this object opens and closes the input file
TBool iOwnsFile;
TInt iTargetSampleRate;
TChannelMode iChannelMode;
CProcFrameHandler* iFrameHandler;
CAudClip* iClip;
TBool iDecodingRequired;
CProcDecoder* iDecoder;
TBool iDecodingPossible;
// We need a temporary storage for extra bytes
// when retrieving raw frames af equal length
HBufC8* iInputBuffer;
TInt iRawFrameLength;
// wav frame handler for time domain gain manipulation
CProcWAVFrameHandler* iWavFrameHandler;
// remainder if audio duration can't be handled accurately in TInt milliseconds, depends on sampling rate
TReal iFrameLenRemainderMilli;
// Counter for decoder errors. Try to continue after one error, but if there are more, stop decoding.
TInt iDecoderErrors;
};
#endif