// Copyright (c) 1997-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 <e32base.h>

#include <f32file.h>

#include <s32file.h>

#include <s32mem.h>

#include "FAXSTPAN.H"

#include "FAXSTORE.H"

#include "faxpageinfo.h"

GLDEF_C void Panic (TFaxStorePanic aPanic)

// Panic the process with ETEXT as the category.

 //

{

	User::Panic (_L ("FaxStrm"), aPanic);

}

// END OF COPIED

EXPORT_C TFaxBandHeader::TFaxBandHeader ():

 iNumScanLines (0),

 iStreamId (KNullStreamId)

/**

@capability None

*/

{

}

EXPORT_C TFaxBandHeader::TFaxBandHeader (TStreamId aStreamId):

 iNumScanLines (0),

 iStreamId (aStreamId)

/**

@capability None

*/

{

}

EXPORT_C void TFaxBandHeader::InternalizeL (RReadStream & aStream)

/**

@capability None

*/

{

	iNumScanLines = aStream.ReadInt32L ();

	aStream >> iStreamId;

}

EXPORT_C void TFaxBandHeader::ExternalizeL (RWriteStream & aStream) const

/**

@capability None

*/

{

	aStream.WriteInt32L (iNumScanLines);

	aStream << iStreamId;

}

CFaxPageInfo::CFaxPageInfo ():

iResolution (EFaxNormal)

{

	__DECLARE_NAME (_S ("CFaxPageInfo"));

}

EXPORT_C CFaxPageInfo *CFaxPageInfo::NewL ()

/**

@capability None

*/

{

	CFaxPageInfo *pageinfo = new (ELeave) CFaxPageInfo ();

	CleanupStack::PushL (pageinfo);

	pageinfo->iBandHeaderList = new (ELeave) CArrayFixFlat < TFaxBandHeader > (8);

	CleanupStack::Pop ();

	return pageinfo;

}

EXPORT_C CFaxPageInfo::~CFaxPageInfo ()

{

	delete iBandHeaderList;

}

EXPORT_C void CFaxPageInfo::InternalizeL (RReadStream & aStream)

/**

@capability None

*/

{

	iResolution = (TFaxResolution) aStream.ReadInt8L ();

	aStream >> *iBandHeaderList;

	aStream >> iSenderId;

	iCompression = (TFaxCompression) aStream.ReadInt32L ();

	iReservedFlag2 = aStream.ReadInt32L ();

}

EXPORT_C void CFaxPageInfo::ExternalizeL (RWriteStream & aStream) const

/**

@capability None

*/

{

	aStream.WriteInt8L ((TInt8) iResolution);

	aStream << *iBandHeaderList;

	aStream << iSenderId;

	aStream.WriteInt32L (iCompression);

	aStream.WriteInt32L (iReservedFlag2);

}

/********************************************************************/

CFaxPages::CFaxPages ()

{

	__DECLARE_NAME (_S ("CFaxPages"));

}

EXPORT_C CFaxPages *CFaxPages::NewL ()

/**

@capability None

*/

{

	CFaxPages *faxpages = new (ELeave) CFaxPages ();

	CleanupStack::PushL (faxpages);

	faxpages->iPageStreamIdList = new (ELeave) CArrayFixFlat < TStreamId > (8);

	CleanupStack::Pop ();

	return faxpages;

}

EXPORT_C CFaxPages::~CFaxPages ()

{

	delete iPageStreamIdList;

}

EXPORT_C void CFaxPages::InternalizeL (RReadStream & aStream)

/**

@capability None

*/

{

	aStream >> *iPageStreamIdList;

}

EXPORT_C void CFaxPages::ExternalizeL (RWriteStream & aStream) const

/**

@capability None

*/

{

	aStream << *iPageStreamIdList;

}

/********************************************************************/

CWriteFaxPages::CWriteFaxPages (CStreamStore & aStore, TInt aMaxScanLinesInBand):

iMaxScanLinesInBand (aMaxScanLinesInBand ? aMaxScanLinesInBand : 64),

iStore (&aStore)

{

	__DECLARE_NAME (_S ("CWriteFaxPages"));

}

void CWriteFaxPages::ConstructL ()

{

	iFaxPages = CFaxPages::NewL ();

	iCurrentPage = CFaxPageInfo::NewL ();

	iFaxT4 = CFaxT4::NewL ();

}

TBool CWriteFaxPages::BandCompleted ()

{

	TInt count = iCurrentPage->iBandHeaderList->Count ();

	return (!count) || ((*iCurrentPage->iBandHeaderList)[count - 1].iNumScanLines == iMaxScanLinesInBand);

}

EXPORT_C CWriteFaxPages *CWriteFaxPages::NewL (CStreamStore & aStore, TInt aMaxScanLinesInBand)

/** Creates a CWriteFaxPages object, which offers the public API for writing fax 

pages to a stream store. 

This function is called by CWriteFaxFile as part of creating a fax file.

@param aStore The store to which fax pages are to be added. 

@param aMaxScanLinesInBand The maximum number of scan lines in a band. Faxes 

pages are stored in bands - to speed up display time. It is recommended 

that developers use 64 - the value used by CWriteFaxFile. 

@leave KErrNoMemory There is insufficient memory to perform the operation.

@return A pointer to the newly created object. 

@capability None

*/

{

	CWriteFaxPages *writefaxpages = new (ELeave) CWriteFaxPages (aStore, aMaxScanLinesInBand);

	CleanupStack::PushL (writefaxpages);

	writefaxpages->ConstructL ();

	CleanupStack::Pop ();

	return writefaxpages;

}

EXPORT_C CWriteFaxPages::~CWriteFaxPages ()

/** Destructor.

Closes the write stream, and frees all resources owned by the object, prior 

to its destruction. */

{

	iWriteStream.Close ();

	delete iFaxT4;

	delete iFaxPages;

	delete iCurrentPage;

}

EXPORT_C void CWriteFaxPages::StartPage (TFaxResolution aResolution, TFaxCompression aCompression, TInt aFlag2)

/**

Initialize fax page, set page parameters.

@param   aResolution     defines fax resolution

@param   aCompression    defines fax compression

@param   aFlag2          reserved flag.

@capability None

*/

{

	iFaxT4->PageInitialize (aResolution, aCompression, aFlag2);

}

EXPORT_C void CWriteFaxPages::EndPageL (TFaxResolution aResolution, TFaxBufSenderId & aSenderId, TFaxCompression aCompression, TInt aFlag2)

/**

Sets parameters for the current page, writes it to the stream and appends to the fax pages set.

@param   aResolution     defines fax resolution

@param   aSenderId       Sender Id.

@param   aCompression    defines fax compression

@param   aFlag2          reserved flag.

@capability None

*/

{

	if (!BandCompleted ())

		{

		iWriteStream.CommitL ();

		iWriteStream.Close ();

		}

	iCurrentPage->iResolution = aResolution;

	iCurrentPage->iSenderId = aSenderId;

	iCurrentPage->iCompression = aCompression;

	iCurrentPage->iReservedFlag2 = aFlag2;

	TStreamId streamid = iWriteStream.CreateL (*iStore);

	iWriteStream << *iCurrentPage;

	iWriteStream.CommitL ();

	iWriteStream.Close ();

	iFaxPages->iPageStreamIdList->AppendL (streamid);

	iCurrentPage->iBandHeaderList->Reset ();

}

EXPORT_C TStreamId CWriteFaxPages::CommitPageL ()

/**

Place FaxPages into write stream.

@return Stream Id.

@capability None

*/

{

	TStreamId streamid = iWriteStream.CreateL (*iStore);

	iWriteStream << *iFaxPages;

	iWriteStream.CommitL ();

	iWriteStream.Close ();

	iStore->CommitL ();

	return streamid;

}

EXPORT_C void CWriteFaxPages::AddScanLineL (const TDesC8 & aScanLine)

/** Adds raw scan lines to the write stream.

The function first encodes the scan line, using the format specified in the 

StartPage() function, and then adds it to the write stream.

@param aScanline The current raw scan line. 

@capability None

*/

{

	iFaxT4->EncodeScanLine (aScanLine, iEncodedScanLine);

	AddEncodedScanLineL (iEncodedScanLine);

}

EXPORT_C void CWriteFaxPages::AddEncodedScanLineL (const TDesC8 & anEncodedScanLine)

/** Adds encoded scan lines to the write stream.

@param anEncodedScanLine The encoded scan line (MH or MR). 

@capability None

*/

{

	if (BandCompleted ())

		{

		TStreamId streamid = iWriteStream.CreateL (*iStore);

		iCurrentPage->iBandHeaderList->AppendL (TFaxBandHeader (streamid));

		}

	TInt count = iCurrentPage->iBandHeaderList->Count ();

	TFaxBandHeader *bandheader = &(*iCurrentPage->iBandHeaderList)[count - 1];

	iWriteStream << anEncodedScanLine;

	bandheader->iNumScanLines++;

	bandheader->iNumBytes += anEncodedScanLine.Length ();

	if (BandCompleted ())

		{

		iWriteStream.CommitL ();

		iWriteStream.Close ();

		}

}

 /********************************************************************/

CWriteFaxFile::CWriteFaxFile ()

{

	__DECLARE_NAME (_S ("CWriteFaxFile"));

}

void CWriteFaxFile::ConstructL ()

{

	User::LeaveIfError (iFs.Connect ());

}

const TUid KUidPsiFaxApp = {268435908};

void CWriteFaxFile::DoOpenL (TInt aMaxScanLinesInBand)

{

	iFileStore = CDirectFileStore::ReplaceL (iFs, iFileName, EFileWrite);

	TUidType type (KDirectFileStoreLayoutUid, TUid::Uid (KFaxFileStoreUidVal), KUidPsiFaxApp);

	iFileStore->SetTypeL (type);

	iWriteFaxPages = CWriteFaxPages::NewL (*iFileStore, aMaxScanLinesInBand);

}

EXPORT_C CWriteFaxFile *CWriteFaxFile::NewL ()

/** Constructs a CWriteFaxFile object, which offers the public API for creating 

a fax store file.

As part of the construction process, the object opens a session with the file 

server.

@return A pointer to the newly created object. 

@capability None

*/

{

	CWriteFaxFile *writefaxfile = new (ELeave) CWriteFaxFile;

	CleanupStack::PushL (writefaxfile);

	writefaxfile->ConstructL ();

	CleanupStack::Pop ();

	return writefaxfile;

}

EXPORT_C CWriteFaxFile::~CWriteFaxFile ()

/** Destructor.

Closes the session with the file server, and frees all resources owned by 

the object, prior to its destruction. */

{

	Close ();

	iFs.Close ();

}

LOCAL_C void DoAbort (TAny * aPtr)

{

	((CWriteFaxFile *) aPtr)->AbortWrite ();

}

EXPORT_C void CWriteFaxFile::OpenL (const TDesC & aFileName, TInt aMaxScanLinesInBand)

/** Creates and opens a fax file for writing.

The function also allocates memory to create a CWriteFaxPages object which 

is pointed to by the class data member. This object defines the API for writing 

pages to the file store.

Fax files which have been opened should be paired with a Close() function.

@param aFileName The name of the new fax file. 

@param aMaxScanLinesInBand The maximum number of scan lines in a band. Fax 

pages are stored in bands for quick retrieval/display. If zero is passed then 

it will default to 64 otherwise the passed value will take effect. 

@capability None

*/

{

	iFileName = aFileName;

	CleanupStack::PushL (TCleanupItem (DoAbort, this));

	DoOpenL (aMaxScanLinesInBand);

	CleanupStack::Pop ();

}

EXPORT_C void CWriteFaxFile::CommitL ()

/** Commits the current fax page created using the CWriteFaxPages API  to 

the fax file.

Committing a page writes it to the fax file, rather than storing it in temporary 

memory. The function should be called after each page is added, to ensure 

that only one fax page can be lost if there is an out of memory error. 

@capability None

*/

{

	TStreamId streamid = iWriteFaxPages->CommitPageL ();

	iFileStore->SetRootL (streamid);

	iFileStore->CommitL ();

}

EXPORT_C void CWriteFaxFile::Close ()

/** Closes the fax file, and deletes the resources owned by the object. 

Although this function is called in the destructor, it is good programming 

practice to invoke it manually to pair previous OpenL() calls. 

@capability None

*/

{

	delete iWriteFaxPages;

	iWriteFaxPages = NULL;

	delete iFileStore;

	iFileStore = NULL;

}

EXPORT_C void CWriteFaxFile::AbortWrite ()

/** Aborts the creation of the fax store file, and then deletes the file. 

It can be called by developer programs, and is called automatically if OpenL() 

leaves. 

@capability None

*/

{

	Close ();

	iFs.Delete (iFileName);

}

/********************************************************************/

CReadFaxPages::CReadFaxPages (CStreamStore & aStore):

iStore (&aStore)

{

	__DECLARE_NAME (_S ("CReadFaxPages"));

}

void CReadFaxPages::ConstructL (TStreamId aStreamId)

{

	iFaxPages = CFaxPages::NewL ();

	iCurrentPage = CFaxPageInfo::NewL ();

	iFaxT4 = CFaxT4::NewL ();

	iReadStream.OpenL (*iStore, aStreamId);

	iReadStream >> *iFaxPages;

	iReadStream.Close ();

	SetPageL (0);

}

EXPORT_C CReadFaxPages *CReadFaxPages::NewL (CStreamStore & aStore, TStreamId aStreamId)

/** Creates a CReadFaxPages object, which offers the public API for reading fax 

pages from a stream store. 

This function is called by CReadFaxFile when opening a fax file.

@param aStore The store from which fax pages are to be read. 

@param aStreamId The root ID of the stream store. 

@leave KErrNoMemory There is insufficient memory to perform the operation. 

@return A pointer to the newly created object. 

@capability None

*/

{

	CReadFaxPages *readfaxpages = new (ELeave) CReadFaxPages (aStore);

	CleanupStack::PushL (readfaxpages);

	readfaxpages->ConstructL (aStreamId);

	CleanupStack::Pop ();

	return readfaxpages;

}

EXPORT_C CReadFaxPages::~CReadFaxPages ()

/** Destructor.

Closes the stream, and frees all resources owned by the object, prior to its 

destruction. */

{

	iReadStream.Close ();

	delete iFaxT4;

	delete iFaxPages;

	delete iCurrentPage;

}

EXPORT_C TInt CReadFaxPages::NumPages () const

/** Gets the number of pages in the store.

@return The number of fax pages in the store. 

@capability None

*/

{

	return iFaxPages->iPageStreamIdList->Count ();

}

EXPORT_C void CReadFaxPages::SetPageL (TInt aNum)

/** Sets a selected page to be the current page, and resets the current scan line 

to the first scan line in the page.

@param aNum The number of the new page. 

@capability None

*/

{

	__ASSERT_DEBUG ((aNum >= 0) && (aNum < iFaxPages->iPageStreamIdList->Count ()), Panic (EFaxPageIndexOutOfRange));

	iReadStream.Close ();

	iReadStream.OpenL (*iStore, (*iFaxPages->iPageStreamIdList)[aNum]);

	iReadStream >> *iCurrentPage;

	iReadStream.Close ();

	iFaxT4->PageInitialize (iCurrentPage->iResolution, iCurrentPage->iCompression, iCurrentPage->iReservedFlag2);

	SeekScanLineL (0);

}

EXPORT_C TFaxPageInfo CReadFaxPages::CurrentPageInfo () const

/** Gets the information for the current fax page, where the current page was set 

in a previous call to the SetPageL() function.

@return The information for the current fax page 

@capability None

*/

{

	TFaxPageInfo info;

	info.iResolution = iCurrentPage->iResolution;

	info.iSenderId = iCurrentPage->iSenderId;

	info.iCompression = iCurrentPage->iCompression;

	info.iReservedFlag2 = iCurrentPage->iReservedFlag2;

	info.iNumScanLines = 0;

	TInt count = iCurrentPage->iBandHeaderList->Count ();

	for (TInt i = 0; i < count; i++)

		info.iNumScanLines += (*iCurrentPage->iBandHeaderList)[i].iNumScanLines;

	return info;

}

EXPORT_C void CReadFaxPages::SeekScanLineL (TInt anIndex)