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

/**
 @file COMP.CPP
*/

#include "PREDCOMP.H"


// Force export of non-mangled name
extern "C"
    {
/**
@internalComponent
@return an object of CPredCompFactory.
*/
EXPORT_C CPppCompFactory* NewPppCompFactoryL(void)
	{
	LOG(PredLog::Printf(_L("Creating a compressor\r\n")));
	return new (ELeave) CPredCompFactory;
	}

	}

CPredCompFactory::CPredCompFactory()
/**
Constructor
*/
	{
	__DECLARE_NAME(_S("CPredCompFactory"));
	}

void CPredCompFactory::InstallL()
/**
Performs a Compressor initialization.
*/
	{
	}

CPppCompressor* CPredCompFactory::NewPppCompressorL(CPppCcp* aCcp,TInt aMaxFrameLength,const TUint8* /*aMode*/)
/**
@return a poiner to class CPredCompressor.
*/
	{
	CPredCompressor* Comp = new (ELeave) CPredCompressor();
	CleanupStack::PushL(TCleanupItem(CNifFactory::Cleanup,Comp));
	Comp->ConstructL(this, aCcp, aMaxFrameLength);
	CleanupStack::Pop();
//	__LOGTEXT_DEBUG(_L8("New Predictor Compressor\n"));
	return Comp;
	}

void CPredCompressor::ConstructL(CPredCompFactory* aFactory, CPppCcp* aCcp, TInt aMaxFrameLength)
/**
2nd Phase Construction
*/
	{
	// Initializes the guess table
	Reset();
//	__LOGTEXT_DEBUG(_L8("CPredCompressor::ConstructL\r\n"));
	//
	// Set up a contiguous block for data copied from an input chain of buffers
	// + 2 bytes for protocol ID which forms part of the compressed data
	iFrameBuffer = HBufC8::NewL(aMaxFrameLength+2);
	// Set up a contiguous block for output from the compressor method
	// Allow space for :- 2 Byte Length + 2 Byte protocol ID + CRC + possible expansion after compression
	// Compressed data can be bigger than the original frame ie Flag byte
	// every 8 bytes and little or no compression possible.
	iCompressedBuffer = HBufC8::NewL(aMaxFrameLength + 6 + ((aMaxFrameLength+2)/8) + 1);

	iCcp = aCcp;
	iFactory = aFactory;
	iFactory->Open();
	return;
	}


TBool CPredCompressor::ResetCompressor(TInt /*aLength*/, RMBufChain& /*aPacket*/)
	{
	LOG(PredLog::Printf(_L("ResetCompressor\n"));)
	// Initializes the guess table
	Reset();
	return TRUE;
	}

TPppCompressReturnValue CPredCompressor::Compress(RMBufChain& aPacket, TUint16 aPppId)
	{
	TPppCompressReturnValue retCode=EPppCompressedNotOK;
	TInt16	originalLength;

	// Set some convenient references to the class buffers
	TPtr8 dest = iCompressedBuffer->Des();
	TPtr8 src = iFrameBuffer->Des();

	// The copy from packet chain method requires the descriptor to be at the maximum length
	src.SetMax();
	// Copy the packet chain to the contiguous buffer, also prepends the protocol id (aPppId)
	// to the beginning of the packet. 0x0021 for IP
	originalLength = (TInt16) CopyFrameIntoFlatBuf(src,aPacket,aPppId);
	// Set the length of the copied data for the compressor
	src.SetLength(originalLength);
	// Set the destination buffer size to allow for Uncompressed length	
	dest.SetLength(2);
	// Perform the RFC algorithm
	// method sets the size of dest length
	CompressRFC1978(src,&dest);
	// Check to see if it's worth sending compressed data
	TBool setTopBit = TRUE;
	if((dest.Length() - 2) > originalLength)
		{
		// Compressed larger than the original data
		// Reset the length and append the original source data
		dest.SetLength(2);
		dest.Append(src);
		setTopBit = FALSE;
		}

	BigEndian::Put16(const_cast<TUint8*>(dest.Ptr()),originalLength);
	// Calculate the 16bit CRC
	TPppFcs16 fcs;
	// CRC the length
	fcs.Calc(dest.Ptr(),dest.Ptr()+2);
	// We set the top bit if we've compressed the frame
	if(setTopBit)
		dest[0] |= 0x80;
	// CRC the original frame
	fcs.Calc(src.Ptr(),src.Ptr()+originalLength);
	// Make room for the CRC at the end of the buffer
	dest.SetLength(dest.Length()+2);
	// Write the network byte order converted CRC
	dest[dest.Length()-2] = (TUint8)(fcs.Fcs() & 0xff);
	dest[dest.Length()-1] = (TUint8)(fcs.Fcs() >> 8);

	// Formatted a contiguous buffer
	// Now re-make it into a packet chain
	TRAPD(ret, aPacket.AppendL(dest.Length()));
	if(ret == KErrNone)
		{
		aPacket.CopyIn(dest);
		retCode = EPppCompressedOK;
		}
	else
		retCode = EPppCompressedNotOK;

	return retCode;
	}

CPredCompressor::CPredCompressor()
/**
Constructor
*/
	{
	}

CPredCompressor::~CPredCompressor()
/**
Destructor
*/
	{

	delete iCompressedBuffer;
	delete iFrameBuffer;
	//
	// Close the factory and delete the container??
	//
	if(iFactory)
		iFactory->Close();
	}

/**
Copies the frame into a contiguous buffer.

@param aDest Output descriptor
@param aPacketQ Data to copy
@param aPppId PPP protocol ID to prepend to the output
	
@return Length of output data or 0 on an error
*/
TUint CPredCompressor::CopyFrameIntoFlatBuf(TPtr8& aDest, RMBufChain& aPacketQ, TUint16 aPppId)
	{
	const TUint	maxLength = aDest.Length();
	TUint8*		ptr = const_cast<TUint8*>(aDest.Ptr());
	
	// Store the protocol ID at the beginning of the uncompressed buffer
	BigEndian::Put16(ptr, aPppId);
	TUint Offset = 2;

	RMBuf* Temp;
	while((Temp=aPacketQ.Remove()) != NULL)
		{
		// Make sure we don't copy past the end of the buffer
		if ((Offset + Temp->Length()) > maxLength)
			{
			LOG(PredLog::Printf(_L("Input packet too long\r\n")));
			Offset = 0;	// This is the only indication of an error
			break;
			}
		Mem::Copy(ptr+Offset, Temp->Ptr(), Temp->Length());
		Offset += Temp->Length();
		Temp->Free();
		}

	// Make sure to free the buffers in case we exited the loop early
	aPacketQ.Free();
	return Offset;
	}


void TRFC1978Table::CompressRFC1978(const TDesC8& aSrc,TDes8* aDest)
/**
Compression logic from RFC 1978
Modified to use descriptors

@param aSrc Data to compress
@param aDest Compressed output buffer, or NULL to synchronise the guess table
without writing the output
*/
	{
	TInt len = aSrc.Length();
	TInt srcIndex = 0;
	TInt flagIndex = 0;
	while(len)
		{
		if(aDest)
			flagIndex = aDest->Length();
		TUint8 flags = 0;
		if(aDest)
			aDest->Append(flags);
		TUint8 bitMask;
		TInt j;
		for(bitMask = 1,j = 0;j < 8 && len ;j++,bitMask <<= 1)
			{
			TUint8 src = aSrc[srcIndex];

			if(iGuessTable[iHash] == src)
				{
				flags |= bitMask;
				}
			else
				{
				iGuessTable[iHash] = src;
				if(aDest)
					aDest->Append(src);
				}
			Hash(src);
			srcIndex++;
			len--;
			}
			if(aDest)
				{
				TUint8* ptr = const_cast<TUint8*>(aDest->Ptr() + flagIndex);
				*ptr = flags;
				}
		}
	}