// Copyright (c) 2006-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:

//

#ifndef READERS_H

#define READERS_H

#include "constants.h"

#include "mmruf.h"

static const TInt KAACFrameHeaderSize = 7;

static const TInt KMP3FrameHeaderSize = 4;

static const TInt KBufSize = 64;

//

// This class provides a level of abstraction that allows

// for parsing data. It is necessary because AppArc may

// only provide a buffer that contains a limited snapshot

// of the beginning of a file, or a file handle that allows

// the whole file to be parsed.

//

class CReader : public CBase

	{

public:

	//

	// Enums used so that CParsers can determine

	// the type of reader they've been given.

	//

	typedef enum

		{

		EUnknown = 0,

		EBuffer = 1,

		EFile = 2

		}

	TReaderType;

	//

	// This function resets the reader such that the next

	// read operation will be performed from the start of

	// the source.

	// For a CFileReader the buffer is filled from the start

	// of the file, for a CBufferReader the position in the 

	// buffer is set to zero.

	//

	virtual void Reset() { iBufPos = 0; }

	//

	// Seeks within the source.

	// This function tries to support 64-bit compatible file

	// formats as much as possible, but there may be some

	// instances when the operation cannot be performed due to

	// limitations of the file server.

	//

	virtual void SeekL(TInt64 aOffset) = 0;

	//

	// Seeks within the source.

	//

	virtual void SeekL(TInt aOffset) = 0;

	//

	// Returns the current position in the buffer.

	//

	virtual TInt Position() { return iBufPos; }

	//

	// Data reading routines.

	//

	TBool Match(const TDesC8& aPattern);

	void Read64L(TInt64& aData, TBool aLittleEndian = EFalse);

	void Read32L(TUint32& aData, TBool aLittleEndian = EFalse);

	void Read16L(TUint16& aData, TBool aLittleEndian = EFalse);

	void ReadByteL(TUint8& aData);

	void ReadBytesL(TDes8& aData);

	//

	// Gets the type of Reader being used.

	//

	inline TReaderType Type() { return iType; }

protected:

	CReader(const TDesC8& aBuffer, CReader::TReaderType aType);

	//

	// Returns ETrue if there is aAmount of unread bytes available,

	// EFalse otherwise.

	//

	virtual TBool CheckEnoughData(TInt aAmount);

	//

	// Non-leaving Seek

	//

	TInt Seek(TInt aOffset);

	TInt Seek(TInt64 aOffset);

private:

	const TDesC8& iBuffer;		// The buffer that contains the source data.

	TInt iBufPos;				// The current position in the data source.

	CReader::TReaderType iType;	// The type of reader it is.

	};

//

// This class allows reading and seeking operations to be

// performed on a data buffer. This is used when no file

// handle is available to the recogniser.

//

class CBufferReader : public CReader

	{

public:

	static CBufferReader* NewLC(const TDesC8& aBuffer);

	virtual ~CBufferReader();

	void Reset();

	void SeekL(TInt aOffset);				// CReader

	void SeekL(TInt64 aOffset);				// CReader

protected:

	CBufferReader(const TDesC8& aBuffer);

	CBufferReader(const TDesC8& aBuffer, TReaderType aType);

	void ConstructL();

	};

//

// This class allows reading and seeking operations to be

// performed on a file handle. This is used when a file

// handle is available to the recogniser.

//

class CFileReader : public CBufferReader

	{

public:

	static CFileReader* NewLC(RFile* aFile);

	virtual ~CFileReader();

	void Reset();

	//

	// CReader::Position() override.

	//

	TInt Position() { return CBufferReader::Position() + iFilePos; }

	void SeekL(TInt aOffset);			// CReader

	void SeekL(TInt64 aOffset);			// CReader

protected:

	CFileReader(RFile* aFile);

	void ConstructL();

	TBool CheckEnoughData(TInt aAmount);	// CReader

	//

	// Seeks to a new file location and fills the buffer from there.

	//

	TInt PhysicallySeekAndRead(TInt aAmount);

	TInt PhysicallySeekAndRead(TInt64 aOffset);

private:

	RFile* iFile;

	TInt64 iFilePos;

	TBuf8<KBufSize> iFileBuffer;

	};

#endif