FCL/sf/os/kernelhwsrv: comparison brdbootldr/ubootldr/inflate2.cpp

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+// base\omap_hrp\h4_bootloader\inflate2.cpp
+// For inflate image which is compressed by Deflate algortihm instead of ZIP
+// (The ROM header un-compressed, the rest part of the image is compressed.)
+//
+//
+#define FILE_ID	0x4C5A4955
+#include <e32def.h>
+#include <e32def_private.h>
+#include <e32cmn.h>
+#include <e32rom.h>
+#include "inflate2.h"
+#include <e32std.h>
+#include <e32std_private.h>
+#include "bootldr.h"
+#include "unzip.h"
+#include <f32file.h>
+#include <e32svr.h>
+#define PTRADD(T,p,x)	((T*)((char*)(p)+(x)))
+#define MIN(a,b)		(((a)<(b))?(a):(b))
+// bit-stream input class
+inline TUint reverse(TUint aVal)
+//
+// Reverse the byte-order of a 32 bit value
+// This generates optimal ARM code (4 instructions)
+//
+	{
+	TUint v=(aVal<<16)|(aVal>>16);
+	v^=aVal;
+	v&=0xff00ffff;
+	aVal=(aVal>>8)|(aVal<<24);
+	return aVal^(v>>8);
+	}
+void HexDump(TUint8 * aStartAddress, TUint aLength)
+{
+TUint index;
+for( index = 0; index != aLength; ++index)
+{
+if( index % 16 == 0)
+{
+PrintToScreen(_L("\r\n0x%08x: "),aStartAddress + index);
+}
+PrintToScreen(_L("%02x "), *(aStartAddress+index));
+}
+PrintToScreen(_L("\r\n\r\n"));
+}
+/******************************************************************************************************
+	Bit input Stream code
+*****************************************************************************************************/
+/** Construct a bit stream input object
+	Following construction the bit stream is ready for reading bits, but will
+	immediately call UnderflowL() as the input buffer is empty.
+*/
+TBitInput::TBitInput()
+:iCount(0)
+	,iRemain(0)
+	{}
+/** Construct a bit stream input object over a buffer
+	Following construction the bit stream is ready for reading bits from
+	the specified buffer.
+	@param aPtr The address of the buffer containing the bit stream
+	@param aLength The length of the bitstream in bits
+	@param aOffset The bit offset from the start of the buffer to the bit stream (defaults to zero)
+*/
+TBitInput::TBitInput(const TUint8* aPtr, TInt aLength, TInt aOffset)
+	{
+	Set(aPtr,aLength,aOffset);
+	}
+/** Set the memory buffer to use for input
+	Bits will be read from this buffer until it is empty, at which point
+	UnderflowL() will be called.
+	@param aPtr The address of the buffer containing the bit stream
+	@param aLength The length of the bitstream in bits
+	@param aOffset The bit offset from the start of the buffer to the bit stream (defaults to zero)
+*/
+void TBitInput::Set(const TUint8* aPtr, TInt aLength, TInt aOffset)
+	{
+	TUint p=(TUint)aPtr;
+	p+=aOffset>>3;			// nearest byte to the specified bit offset
+	aOffset&=7;				// bit offset within the byte
+	const TUint32* ptr=(const TUint32*)(p&~3);	// word containing this byte
+	aOffset+=(p&3)<<3;		// bit offset within the word
+	if (aLength==0)
+		iCount=0;
+	else
+		{
+		// read the first few bits of the stream
+		iBits=reverse(*ptr++)<<aOffset;
+		aOffset=32-aOffset;
+		aLength-=aOffset;
+		if (aLength<0)
+			aOffset+=aLength;
+		iCount=aOffset;
+		}
+	iRemain=aLength;
+	iPtr=ptr;
+	}
+//#define __HUFFMAN_MACHINE_CODED__
+#ifndef __HUFFMAN_MACHINE_CODED__
+/** Read a single bit from the input
+	Return the next bit in the input stream. This will call UnderflowL() if
+	there are no more bits available.
+	@return The next bit in the stream
+	@leave "UnderflowL()" It the bit stream is exhausted more UnderflowL is called
+		to get more data
+*/
+TUint TBitInput::ReadL()
+	{
+	TInt c=iCount;
+	TUint bits=iBits;
+	if (--c<0)
+		return ReadL(1);
+	iCount=c;
+	iBits=bits<<1;
+	return bits>>31;
+	}
+/** Read a multi-bit value from the input
+	Return the next few bits as an unsigned integer. The last bit read is
+	the least significant bit of the returned value, and the value is
+	zero extended to return a 32-bit result.
+	A read of zero bits will always reaturn zero.
+	This will call UnderflowL() if there are not enough bits available.
+	@param aSize The number of bits to read
+	@return The bits read from the stream
+	@leave "UnderflowL()" It the bit stream is exhausted more UnderflowL is called
+		to get more data
+*/
+TUint TBitInput::ReadL(TInt aSize)
+	{
+	if (!aSize)
+		return 0;
+	TUint val=0;
+	TUint bits=iBits;
+	iCount-=aSize;
+	while (iCount<0)
+		{
+		// need more bits
+		val|=bits>>(32-(iCount+aSize))<<(-iCount);	// scrub low order bits
+		aSize=-iCount;	// bits still required
+		if (iRemain>0)
+			{
+			bits=reverse(*iPtr++);
+			iCount+=32;
+			iRemain-=32;
+			if (iRemain<0)
+				iCount+=iRemain;
+			}
+		else
+			{
+			UnderflowL();
+			bits=iBits;
+			iCount-=aSize;
+			}
+		}
+//#ifdef __CPU_X86
+	// X86 does not allow shift-by-32
+//	iBits=aSize==32?0:bits<<aSize;
+//#else
+	iBits=bits<<aSize;
+//#endif
+	return val|(bits>>(32-aSize));
+	}
+/** Read and decode a Huffman Code
+	Interpret the next bits in the input as a Huffman code in the specified
+	decoding. The decoding tree should be the output from Huffman::Decoding().
+	@param aTree The huffman decoding tree
+	@return The symbol that was decoded
+	@leave "UnderflowL()" It the bit stream is exhausted more UnderflowL is called
+		to get more data
+*/
+TUint TBitInput::HuffmanL(const TUint32* aTree)
+	{
+	TUint huff=0;
+	do
+		{
+		aTree=PTRADD(TUint32,aTree,huff>>16);
+		huff=*aTree;
+		if (ReadL()==0)
+			huff<<=16;
+		} while ((huff&0x10000u)==0);
+	return huff>>17;
+	}
+#endif
+/** Handle an empty input buffer
+	This virtual function is called when the input buffer is empty and
+	more bits are required. It should reset the input buffer with more
+	data using Set().
+	A derived class can replace this to read the data from a file
+	(for example) before reseting the input buffer.
+	@leave KErrUnderflow The default implementation leaves
+*/
+void TBitInput::UnderflowL()
+	{
+	}
+/******************************************************************************************************
+	Huffman Code
+*****************************************************************************************************/
+TUint32* HuffmanSubTree(TUint32* aPtr,const TUint32* aValue,TUint32** aLevel)
+//
+// write the subtree below aPtr and return the head
+//
+	{
+	TUint32* l=*aLevel++;
+	if (l>aValue)
+		{
+		TUint32* sub0=HuffmanSubTree(aPtr,aValue,aLevel);	// 0-tree first
+		aPtr=HuffmanSubTree(sub0,aValue-(aPtr-sub0)-1,aLevel);			// 1-tree
+		TInt branch0=(TUint8*)sub0-(TUint8*)(aPtr-1);
+		*--aPtr=KBranch1|branch0;
+		}
+	else if (l==aValue)
+		{
+		TUint term0=*aValue--;						// 0-term
+		aPtr=HuffmanSubTree(aPtr,aValue,aLevel);			// 1-tree
+		*--aPtr=KBranch1|(term0>>16);
+		}
+	else	// l<iNext
+		{
+		TUint term0=*aValue--;						// 0-term
+		TUint term1=*aValue--;
+		*--aPtr=(term1>>16<<16)|(term0>>16);
+		}
+	return aPtr;
+	}
+/** Create a canonical Huffman decoding tree
+	This generates the huffman decoding tree used by TBitInput::HuffmanL() to read huffman
+	encoded data. The input is table of code lengths, as generated by Huffman::HuffmanL()
+	and must represent a valid huffman code.
+	@param aHuffman The table of code lengths as generated by Huffman::HuffmanL()
+	@param aNumCodes The number of codes in the table
+	@param aDecodeTree The space for the decoding tree. This must be the same
+		size as the code-length table, and can safely be the same memory
+	@param  aSymbolBase the base value for the output 'symbols' from the decoding tree, by default
+		this is zero.
+	@panic "USER ???" If the provided code is not a valid Huffman coding
+	@see IsValid()
+	@see HuffmanL()
+*/
+void Huffman::Decoding(const TUint32 aHuffman[],TInt aNumCodes,TUint32 aDecodeTree[],TInt aSymbolBase)
+	{
+#ifdef _DEBUG
+	if(!IsValid(aHuffman,aNumCodes))
+		{
+#ifdef __LED__
+		leds(0xBAD00006);
+#endif
+		}
+#endif
+	TInt counts[KMaxCodeLength];
+	memset1(counts, 0, (sizeof(TInt)*KMaxCodeLength));
+	TInt codes=0;
+	TInt ii;
+	for (ii=0;ii<aNumCodes;++ii)
+		{
+		TInt len=aHuffman[ii];
+		aDecodeTree[ii]=len;
+		if (--len>=0)
+			{
+			++counts[len];
+			++codes;
+			}
+		}
+	TUint32* level[KMaxCodeLength];
+	TUint32* lit=aDecodeTree+codes;
+	for (ii=0;ii<KMaxCodeLength;++ii)
+		{
+		level[ii]=lit;
+		lit-=counts[ii];
+		}
+	aSymbolBase=(aSymbolBase<<17)+(KHuffTerminate<<16);
+	for (ii=0;ii<aNumCodes;++ii)
+		{
+		TUint len=TUint8(aDecodeTree[ii]);
+		if (len)
+			*--level[len-1]|=(ii<<17)+aSymbolBase;
+		}
+	if (codes==1)	// codes==1 special case: incomplete tree
+		{
+		TUint term=aDecodeTree[0]>>16;
+		aDecodeTree[0]=term|(term<<16); // 0- and 1-terminate at root
+		}
+	else if (codes>1)
+		HuffmanSubTree(aDecodeTree+codes-1,aDecodeTree+codes-1,&level[0]);
+	}
+// The decoding tree for the externalised code
+const TUint32 HuffmanDecoding[]=
+	{
+	0x0004006c,
+	0x00040064,
+	0x0004005c,
+	0x00040050,
+	0x00040044,
+	0x0004003c,
+	0x00040034,
+	0x00040021,
+	0x00040023,
+	0x00040025,
+	0x00040027,
+	0x00040029,
+	0x00040014,
+	0x0004000c,
+	0x00040035,
+	0x00390037,
+	0x00330031,
+	0x0004002b,
+	0x002f002d,
+	0x001f001d,
+	0x001b0019,
+	0x00040013,
+	0x00170015,
+	0x0004000d,
+	0x0011000f,
+	0x000b0009,
+	0x00070003,
+	0x00050001
+	};
+/** Restore a canonical huffman encoding from a bit stream
+	The encoding must have been stored using Huffman::ExternalizeL(). The resulting
+	code-length table can be used to create an encoding table using Huffman::Encoding()
+	or a decoding tree using Huffman::Decoding().
+	@param aInput The input stream with the encoding
+	@param aHuffman The internalized code-length table is placed here
+	@param aNumCodes The number of huffman codes in the table
+	@leave TBitInput::HuffmanL()
+	@see ExternalizeL()
+*/
+void Huffman::InternalizeL(TBitInput& aInput,TUint32 aHuffman[],TInt aNumCodes)
+// See ExternalizeL for a description of the format
+	{
+	// initialise move-to-front list
+	TUint8 list[Huffman::KMetaCodes];
+	for (TInt i=0;i<Huffman::KMetaCodes;++i)
+		list[i]=TUint8(i);
+	TInt last=0;
+	// extract codes, reverse rle-0 and mtf encoding in one pass
+	TUint32* p=aHuffman;
+	const TUint32* end=aHuffman+aNumCodes;
+	TInt rl=0;
+	while (p+rl<end)
+		{
+		TInt c=aInput.HuffmanL(HuffmanDecoding);
+		if (c<2)
+			{
+			// one of the zero codes used by RLE-0
+			// update he run-length
+			rl+=rl+c+1;
+			}
+		else
+			{
+			while (rl>0)
+				{
+				*p++=last;
+				--rl;
+				}
+			--c;
+			list[0]=TUint8(last);
+			last=list[c];
+			memcpy1(&list[1],&list[0],c);
+			*p++=last;
+			}
+		}
+	while (rl>0)
+		{
+		*p++=last;
+		--rl;
+		}
+	}
+/** Validate a Huffman encoding
+	This verifies that a Huffman coding described by the code lengths is valid.
+	In particular, it ensures that no code exceeds the maximum length and
+	that it is possible to generate a canonical coding for the specified lengths.
+	@param aHuffman The table of code lengths as generated by Huffman::HuffmanL()
+	@param aNumCodes The number of codes in the table
+	@return True if the code is valid, otherwise false
+*/
+TBool Huffman::IsValid(const TUint32 aHuffman[],TInt aNumCodes)
+	{
+	// The code is valid if one of the following holds:
+	// (a) the code exactly fills the 'code space'
+	// (b) there is only a single symbol with code length 1
+	// (c) there are no encoded symbols
+	//
+	TUint remain=1<<KMaxCodeLength;
+	TInt totlen=0;
+	for (const TUint32* p=aHuffman+aNumCodes; p>aHuffman;)
+		{
+		TInt len=*--p;
+		if (len>0)
+			{
+			totlen+=len;
+			if (len>KMaxCodeLength)
+				return 0;
+			TUint c=1<<(KMaxCodeLength-len);
+			if (c>remain)
+				return 0;
+			remain-=c;
+			}
+		}
+	return remain==0 || totlen<=1;
+	}
+TInt Inflater::Inflate(TBitInput& aBits, TUint8* aBuffer, TInt aSize)
+	{
+	TEncoding encoding;
+	TInt r = Init(aBits, encoding);
+	if (r==KErrNone)
+		r = DoInflate(aBits, encoding, aBuffer, aSize);
+	return r;
+	}
+TInt Inflater::Init(TBitInput& aBits, TEncoding& aEncoding)
+	{
+// read the encoding
+	Huffman::InternalizeL(aBits,aEncoding.iLitLen,KDeflationCodes);
+// validate the encoding
+	if (!Huffman::IsValid(aEncoding.iLitLen,TEncoding::ELitLens) ||
+		!Huffman::IsValid(aEncoding.iDistance,TEncoding::EDistances))
+		return KErrCorrupt;
+// convert the length tables into huffman decoding trees
+	Huffman::Decoding(aEncoding.iLitLen,TEncoding::ELitLens,aEncoding.iLitLen);
+	Huffman::Decoding(aEncoding.iDistance,TEncoding::EDistances,aEncoding.iDistance);
+	return KErrNone;
+	}
+TInt Inflater::DoInflate(TBitInput& aBits, TEncoding& aEncoding, TUint8* aBuffer, TInt aSize)
+	{
+	TUint8* out=aBuffer;
+	TUint8* const end=out+aSize;
+//
+	while (out<end)
+		{
+		// get a huffman code
+		TInt code=aBits.HuffmanL(aEncoding.iLitLen)-TEncoding::ELiterals;
+		if (code<0)
+			{
+			*out++=TUint8(code);
+			continue;			// another literal/length combo
+			}
+		if (code==TEncoding::EEos-TEncoding::ELiterals)
+			{	// eos marker. we're done
+			break;
+			}
+		// get the extra bits for the length code
+		if (code>=8)
+			{
+			TInt xtra=(code>>2)-1;
+			code-=xtra<<2;
+			code<<=xtra;
+			code|=aBits.ReadL(xtra);
+			}
+		TInt len=code+KDeflateMinLength;
+		// get the distance code
+		code=aBits.HuffmanL(aEncoding.iDistance);
+		if (code>=8)
+			{
+			TInt xtra=(code>>2)-1;
+			code-=xtra<<2;
+			code<<=xtra;
+			code|=aBits.ReadL(xtra);
+			}
+		TUint8* dptr = out-(code+1);
+		TInt wlen = MIN(end-out,len);
+		for(TInt i=0;i<wlen;i++)	//this byte by byte copy is required in stead of a memcpy as over lap required. memcopy does
+		    {
+		    *out++=*dptr++;			//not do much better as the length of copies are short ie over the 16 byte threshold
+		    }
+		};
+	return out-aBuffer;
+	}
+TFileInput::TFileInput(TInt aBlockLen, TInt aFileSize)
+:iReadBuf(iBuf1)
+,iPtr(iBuf1,KBufSize)
+,iBlockLen(aBlockLen)
+,iFileSize(aFileSize)
+,iImageReadProgress(0)
+	{
+	// Avoid buffer overrrun
+	if( aBlockLen > KBufSize)
+	    iBlockLen = KBufSize;
+	// issue first read
+	iState=ReadInputData(iReadBuf,iBlockLen);
+	iImageReadProgress += iBlockLen;
+	}
+void TFileInput::Init()
+{
+Set(iReadBuf, iBlockLen*8);
+InitProgressBar(0,(TUint)iFileSize,_L("LOAD"));
+}
+void TFileInput::UnderflowL()
+	{
+	TUint8* b=iReadBuf;
+	ASSERT(b!=NULL);
+	Set(b, iBlockLen*8);
+	// start reading to the next buffer
+	b = iBuf1;
+	iState=ReadInputData(b,iBlockLen);
+	Set(b, iBlockLen*8);
+	iReadBuf=b;
+	// Update progress
+	iImageReadProgress += iBlockLen;
+	UpdateProgressBar(0,(TUint)iImageReadProgress);
+#ifdef __SUPPORT_FLASH_REPRO__
+	NotifyDataAvailable(iImageReadProgress);
+#endif
+	}
+void memcpy1(TAny* aTrg, const TAny* aSrc, unsigned int aLength)
+//
+// Copy from the aSrc to aTrg for aLength bytes.
+//
+	{
+	TInt aLen32=0;
+	TUint32* pT32=(TUint32*)aTrg;
+	const TUint32* pS32=(TUint32 *)aSrc;
+	TInt aLen8;
+	TUint32* pE32;
+	TUint8* pT;
+TUint8* pE;
+TUint8* pS;
+	if (aLength==0)
+		return;//((TUint8*)aTrg);
+	if (((TInt)pT32&3)==0 && ((TInt)pS32&3)==0)
+		aLen32=aLength>>2;
+	aLen8=aLength-(aLen32<<2);
+	pE32=pT32+aLen32;
+	if (aTrg<aSrc)
+		{
+		pS32=(TUint32*)aSrc;
+		while (pT32<pE32)
+			*pT32++=(*pS32++);
+		pT=(TUint8*)pT32;
+		pS=(TUint8*)pS32;
+		pE=(TUint8*)aTrg+aLength;
+		while (pT<pE)
+			*pT++=(*pS++);
+		}
+	else if (aTrg>aSrc)
+		{
+		pT=(TUint8*)(pT32+aLen32);
+		pE=pT+aLen8;
+		pS=(TUint8*)aSrc+aLength;
+		while (pE>pT)
+			*--pE=(*--pS);
+		pS32=(TUint32*)pS;
+		while (pE32>pT32)
+			*--pE32=(*--pS32);
+		}
+	}
+void memset1(void* aTrg, int aValue, unsigned int aLength)
+//
+// Fill memory with aLength aChars.
+//
+	{
+	TInt aLen32=0;
+	TUint32 *pM32=(TUint32 *)aTrg;
+	TUint32 *pE32;
+	TUint c;
+	TUint32 fillChar;
+	TInt aLen8;
+	TUint8 *pM;
+	TUint8 *pE;
+	if (((TInt)aTrg&3)==0)
+		{
+		aLen32=aLength>>2;
+		pE32=pM32+aLen32;
+		c = aValue & 0xff;
+		fillChar=c+(c<<8)+(c<<16)+(c<<24);
+		while (pM32<pE32)
+			*pM32++=fillChar;
+		}
+	aLen8=aLength-(aLen32<<2);
+	pM=(TUint8 *)pM32;
+	pE=pM+aLen8;
+	while (pM<pE)
+		*pM++=(TUint8)(aValue);
+	}
+TInt memcmp1(const TUint8* aTrg, const TUint8* aSrc, TInt aLength)
+//
+// Compare aSrc with aTrg
+//
+	{
+	for (TInt n=0; n<aLength; n++)
+		{
+		if (aTrg[n] != aSrc[n])
+			return -1;
+		}
+	return 0;
+	}
+#ifdef SYMBIAN_CHECK_ROM_CHECKSUM
+TUint Check(const TUint32* aPtr, TInt aSize)
+	{
+	TUint sum=0;
+	aSize/=4;
+	while (aSize-->0)
+		sum+=*aPtr++;
+	return sum;
+	}
+TInt CheckRomChecksum(TRomHeader& aRomHeader)
+	{
+	TInt size = aRomHeader.iUnpagedUncompressedSize;
+	const TUint32* addr = (TUint32*) &aRomHeader;
+#ifdef _DEBUG_CORELDR_
+	PrintVal("ROM addr = ", (TUint32) addr);
+	PrintVal("ROM size = ", (TUint32) size);
+#endif
+	TUint checkSum = Check(addr, size);
+	// modify the checksum because ROMBUILD is broken...
+	checkSum -= (aRomHeader.iRomSize-size)/4; // adjust for missing 0xffffffff
+	checkSum -= aRomHeader.iCompressionType;
+	checkSum -= aRomHeader.iUnpagedCompressedSize;
+	checkSum -= aRomHeader.iUnpagedUncompressedSize;
+	TUint expectedChecksum = 0x12345678;
+#ifdef _DEBUG_CORELDR_
+	PrintVal("Checksum = ", checkSum);
+	PrintVal("expectedChecksum = ", expectedChecksum);
+#endif
+	return (checkSum==expectedChecksum)?0:-2;
+	}
+#endif
+int DoDeflateDownload()
+{
+// Read ROM Loader Header
+TInt r = KErrNone;
+TInt headerSize = TROM_LOADER_HEADER_SIZE;
+if(RomLoaderHeaderExists)
+{
+TUint8 romLoaderHeader[TROM_LOADER_HEADER_SIZE];
+	FileSize -= headerSize;
+	r = ReadInputData((TUint8*)&romLoaderHeader, headerSize);
+	if( KErrNone!=r)
+		{
+		PrintToScreen(_L("Unable to read loader header... (size:%d)\r\n"), headerSize);
+		BOOT_FAULT();
+		}
+}
+	// Read ROM Header
+	TRomHeader* romHeader;
+	romHeader = (TRomHeader*)DestinationAddress();
+	headerSize = sizeof(TRomHeader);
+	r = ReadInputData((TUint8*)romHeader, headerSize);
+	if( KErrNone!=r)
+		{
+PrintToScreen(_L("Unable to read ROM header... (size:%d)\r\n"), headerSize);
+		BOOT_FAULT();
+		}
+	DEBUG_PRINT((_L("headerSize       :%d\r\n"), headerSize));
+	DEBUG_PRINT((_L("iRomHeaderSize   :0x%08x\r\n"), romHeader->iRomHeaderSize));
+	DEBUG_PRINT((_L("iDebugPort       :0x%08x\r\n"), romHeader->iDebugPort));
+	DEBUG_PRINT((_L("iVersion         :%d.%d %d\r\n"), romHeader->iVersion.iMajor, romHeader->iVersion.iMinor, romHeader->iVersion.iBuild));
+	DEBUG_PRINT((_L("iCompressionType :0x%08x\r\n"), romHeader->iCompressionType));
+	DEBUG_PRINT((_L("iCompressedSize  :0x%08x\r\n"), romHeader->iCompressedSize));
+	DEBUG_PRINT((_L("iUncompressedSize:0x%08x\r\n"), romHeader->iUncompressedSize));
+	DEBUG_PRINT((_L("iCompressedUnpagedStart:0x%08x\r\n"), romHeader->iCompressedUnpagedStart));
+	DEBUG_PRINT((_L("iUnpagedCompressedSize:0x%08x\r\n"), romHeader->iUnpagedCompressedSize));
+	DEBUG_PRINT((_L("iUnpagedUncompressedSize:0x%08x\r\n"), romHeader->iUnpagedUncompressedSize));
+	if( romHeader->iCompressionType != KUidCompressionDeflate )
+		{
+		PrintToScreen(_L("Not supported compression method:0x%08x\r\n"), romHeader->iCompressionType);
+	    BOOT_FAULT();
+	}
+TUint8 * pScr = (TUint8 *)DestinationAddress();
+DEBUG_PRINT((_L("Load address:0x%08x.\r\n"), pScr));
+if( romHeader->iCompressedUnpagedStart > (TUint)headerSize )
+	{
+	// Copy uncompressed un-paged part (bootstrap + Page Index Table) to the proper place if it longer than the romHeader
+	TInt unpagedSize = (romHeader->iCompressedUnpagedStart - headerSize);
+	DEBUG_PRINT((_L("Copy uncompressed un-paged part ...\r\n")));
+	DEBUG_PRINT((_L("to   :0x%08x.\r\n"),((TUint8 *)DestinationAddress()+headerSize) ));
+	DEBUG_PRINT((_L("len  :0x%08x.\r\n"),unpagedSize ));
+		r = ReadInputData(((TUint8 *)DestinationAddress()+headerSize), unpagedSize);
+	  	// Modify header size to include the un-paged part such that the inflate code will not need to be modified
+	headerSize = unpagedSize;
+		if( KErrNone!=r)
+			{
+			PrintToScreen(_L("uncompressed un-paged part... (size:%d)\r\n"), headerSize);
+			BOOT_FAULT();
+			}
+}
+pScr += (headerSize + romHeader->iUnpagedUncompressedSize);
+DEBUG_PRINT((_L("Compressed image load address:0x%08x.\r\n"), pScr));
+FileSize = romHeader->iUnpagedCompressedSize;
+#ifdef __SUPPORT_FLASH_REPRO__
+	if (LoadToFlash)
+		ImageSize = ((romHeader->iUnpagedUncompressedSize | 0x3ff) + 1);  // Round it to 0x400 for flashing
+#endif
+ImageReadProgress=0;
+TInt block_size = Max(0x1000,FileSize>>8);
+	DEBUG_PRINT((_L("Compressed image loaded into the RAM for decompress.\r\n")));
+pScr = (TUint8 *)DestinationAddress();
+pScr += (headerSize + romHeader->iUnpagedUncompressedSize);
+TFileInput image(block_size, FileSize);
+image.Init();
+#ifdef __SUPPORT_FLASH_REPRO__
+	if (LoadToFlash)
+		{
+		DEBUG_PRINT((_L("InitFlashWrite. ImageSize:%d (0x%08x).\r\n"), ImageSize, ImageSize));
+		r=InitFlashWrite();
+		if (r!=KErrNone)
+			{
+			PrintToScreen(_L("FAULT due to InitFlashWrite return %d\r\n"), r);
+			BOOT_FAULT();
+			}
+		}
+#endif  // __SUPPORT_FLASH_REPRO__
+	DEBUG_PRINT((_L("(TUint8 *)(DestinationAddress() + headerSize):0x%08x, size:%d.\r\n"),(TUint8 *)(DestinationAddress() + headerSize), romHeader->iUnpagedUncompressedSize));
+TUint nChars = Inflater::Inflate(
+image,
+(TUint8 *)(DestinationAddress() + headerSize),
+romHeader->iUnpagedUncompressedSize
+);
+DEBUG_PRINT((_L("Decompressed %d bytes.\r\n"), nChars));
+if( 0 > (TInt)nChars)
+{
+PrintToScreen(_L("Error in decompression, return code: %d.\r\n"), nChars);
+BOOT_FAULT();
+}
+#ifdef __SUPPORT_FLASH_REPRO__
+	if (LoadToFlash)
+{
+	    DEBUG_PRINT((_L("NotifyDataAvailable. ImageSize:%d (0x%08x).\r\n"), ImageSize, ImageSize));
+		NotifyDataAvailable(ImageSize);
+	DEBUG_PRINT((_L("NotifyDownloadComplete.\r\n")));
+	NotifyDownloadComplete();
+}
+#else
+	DELAY(20000);
+#endif   //  __SUPPORT_FLASH_REPRO__
+return KErrNone;
+}