// 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