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

 //

 #include "readers.h"

 //

 //

 //

 CFileReader::CFileReader(RFile* aFile)

  :	CBufferReader(iFileBuffer, CReader::EFile),

  	iFile(aFile)

 	{

 	}

 //

 //

 //

 CFileReader::~CFileReader()

 	{

 	}

 //

 //

 //

 CFileReader* CFileReader::NewLC(RFile* aFile)

 	{

 	CFileReader* self = new(ELeave) CFileReader(aFile);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 //

 //

 //

 void CFileReader::ConstructL()

 	{

 	TInt pos = 0;

 	User::LeaveIfError(iFile->Seek(ESeekStart, pos));

 	User::LeaveIfError(iFile->Read(iFileBuffer));

 	}

 //

 // Checks if there is aAmount of data left in the buffer.

 // It is important to call the base-class implementation first

 // to ensure correct operation.

 //

 TBool CFileReader::CheckEnoughData(TInt aAmount)

 	{

 	if (CBufferReader::CheckEnoughData(aAmount))

 		{

 		return ETrue;

 		}

 	// Try to read more data.

 	TInt bufPos = CBufferReader::Position();

 	TInt err = PhysicallySeekAndRead(bufPos - iFileBuffer.Length());

 	if (err == KErrNone)

 		{

 		// The read may have succeeded but that 

 		// still doesn't mean we have enough data.

 		return (aAmount <= iFileBuffer.Length());

 		}

 	return EFalse;

 	}

 //

 //

 //

 void CFileReader::Reset()

 	{

 	CBufferReader::Reset(); // This will reset iBufPos.

 	if (iFilePos != 0)

 		{

 		// We need to seek to the start and fill the buffer.

 		iFilePos = 0;

 		TInt filepos = 0;

 		TInt err = iFile->Seek(ESeekStart, filepos);

 		if (err == KErrNone)

 			{

 			err = iFile->Read(iFileBuffer);

 			}

 		if (err != KErrNone)

 			{

 			iFileBuffer.Zero();

 			}

 		}

 	else

 		{

 		// There's no need to seek and read.

 		iFilePos = 0;

 		}

 	}

 //

 //

 //

 void CFileReader::SeekL(TInt aOffset)

 	{

 	TInt err = CReader::Seek(aOffset);

 	if (err == KErrUnderflow)

 		{

 		TInt bufPos = CBufferReader::Position();

 		aOffset += bufPos - iFileBuffer.Length();

 		User::LeaveIfError(PhysicallySeekAndRead(aOffset));

 		}

 	}

 //

 // It could be possible for a 64-bit field in formats such as MPEG4

 // to have values that would fit in a 32-bit variable. In this case

 // we can use it for seeking. This function checks if a 64-bit value

 // is compatible with RFile's 32-bit operations.

 //

 void CFileReader::SeekL(TInt64 aOffset)

 	{

 	if (aOffset < KMinTInt64)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if (aOffset > KMaxTInt64)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if (aOffset < (TInt64)KMaxTInt)

 	    {

         TInt low = (TInt)I64LOW(aOffset);

         SeekL(low);

 	    }

 	else

 	    {

         TInt err = CReader::Seek(aOffset);

         if (err == KErrUnderflow)

             {

             TInt64 bufPos = CBufferReader::Position();

             aOffset += bufPos - iFileBuffer.Length();

             User::LeaveIfError(PhysicallySeekAndRead(aOffset));

             }

 	    }

 	}

 //

 // This function seeks forward/backward aOffset bytes

 // and fills the buffer from that point.

 //

 TInt CFileReader::PhysicallySeekAndRead(TInt aOffset)

 	{

 	TInt err;

 	// New buffer contents so read from the start of it.

 	CBufferReader::Reset();

 	iFilePos = aOffset;

 	err = iFile->Seek(ESeekCurrent, aOffset);

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	err = iFile->Read(iFileBuffer);

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	return (iFileBuffer.Length() == 0 ? KErrEof : KErrNone);

 	}

 TInt CFileReader::PhysicallySeekAndRead(TInt64 aOffset)

     {

     TInt err;

     // New buffer contents so read from the start of it.

     CBufferReader::Reset();

     iFilePos = aOffset;

     RFile64* tempfile;

     tempfile = static_cast<RFile64*> (iFile);

     err = tempfile->Seek(ESeekCurrent, iFilePos);

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	err = iFile->Read(iFileBuffer);

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	return (iFileBuffer.Length() == 0 ? KErrEof : KErrNone);

 	}