/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "CJpeg.h"

#include <e32svr.h>

const TUint8 KQuantIndex[ 3 ] = { 0,1,1 };

const TUint8 KHuffIndex[ 3 ] = { 0,1,1 };

const TUint8 KZigZag[] = {

						 0, 8,   1,  2,  9, 16, 24, 17,

						10, 3,   4, 11, 18, 25, 32, 40,

						33, 26, 19, 12,  5,  6, 13, 20,

						27, 34, 41, 48, 56, 49, 42, 35,

						28, 21, 14,  7, 15, 22, 29, 36,

						43, 50, 57, 58, 51, 44, 37, 30,

						23, 31, 38, 45, 52, 59, 60, 53,

						46, 39, 47, 54, 61, 62, 55, 63

						};

/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */

/* IMPORTANT: these are only valid for 8-bit data precision! */

const TUint8 bits_dc_luminance[17] =

{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };

const TUint8 val_dc_luminance[] =

{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

const TUint8 bits_dc_chrominance[17] =

{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

const TUint8 val_dc_chrominance[] =

{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

const TUint8 bits_ac_luminance[17] =

{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };

const TUint8 val_ac_luminance[] =

{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,

  0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,

  0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,

  0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,

  0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,

  0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,

  0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,

  0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

  0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,

  0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,

  0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,

  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,

  0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,

  0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,

  0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,

  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,

  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,

  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

  0xf9, 0xfa 

};

const TUint8 bits_ac_chrominance[17] =

{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };

const TUint8 val_ac_chrominance[] =

{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,

  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

  0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,

  0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,

  0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,

  0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,

  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,

  0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,

  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,

  0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,

  0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,

  0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,

  0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,

  0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,

  0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,

  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,

  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,

  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

  0xf9, 0xfa 

};

const TUint8 KExifHeader[] = "Exif";

class THuffman

	{

	public:

		TInt8 iLength[ 256 ];

		TUint8 iSymbol[ 256 ];

		TUint8 iSearch[ 65536 ];

	};

CJpeg* CJpeg::NewL()

	{

	CJpeg* self = NewLC();

	CleanupStack::Pop( self );

	return self;

	}

CJpeg* CJpeg::NewLC()

	{

	CJpeg* self = new( ELeave )CJpeg();

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

CJpeg::~CJpeg()

	{

	delete iHuffman[ 0 ];

	delete iHuffman[ 1 ];

	delete iHuffman[ 2 ];

	delete iHuffman[ 3 ];

	delete iQt[ 0 ];

	delete iQt[ 1 ];

	delete iQt[ 2 ];

	delete iQt[ 3 ];

	iCurrentQt = NULL;

	iExifData = NULL;

	//iBlock.Reset();

	delete iBlock;

	delete iBuffer;

	delete iC[ 0 ];

	delete iC[ 1 ];

	delete iC[ 2 ];

	//iDebug.Close();

	//iFs.Close();

	}

CJpeg::CJpeg()

	{

	}

void CJpeg::ConstructL()

	{

	}

void CJpeg::OpenL( const TFileName& aFile )

	{

	if (iBuffer)

		{

		delete iBuffer;

		iBuffer = NULL;

		}

	RFs fs;

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

	CleanupClosePushL( fs );

	RFile file;

	TInt err = file.Open( fs, aFile, EFileRead | EFileShareReadersOnly );

	if (KErrNone != err)

		{

		User::LeaveIfError( file.Open( fs, aFile, EFileRead | EFileShareAny ) );

		}

	CleanupClosePushL( file );

	TInt size;

	file.Size( size );

	iBuffer = new( ELeave )TUint8[ size + 2 ];

	TPtr8 ptr( iBuffer, size );

	file.Read( ptr );

	CleanupStack::PopAndDestroy( 2 ); // file, fs

	OpenL( ptr );

	}

void CJpeg::OpenL( const TPtr8& aData )

	{

	//iFs.Connect();

	//iDebug.Replace( iFs, _L("e:\\TestData\\jpdeb.txt"), EFileWrite );

	EnableRgvConv();

	iBuffer = (TUint8*)aData.Ptr();

	// if used again, all variables should be cleared

	iBuf = 0;

	iBufBits = 0;

	delete iHuffman[ 0 ];

	delete iHuffman[ 1 ];

	delete iHuffman[ 2 ];

	delete iHuffman[ 3 ];

	iHuffman[ 0 ] = 0;

	iHuffman[ 1 ] = 0;

	iHuffman[ 2 ] = 0;

	iHuffman[ 3 ] = 0;

	//iDebug.Write( _L8("d1\n") );

	//

	// This is only needed if no huffman tables found

	//

	//CreateDefaultHuffmanL();

	iQt[ 0 ] = 0;

	iQt[ 1 ] = 0;

	iQt[ 2 ] = 0;

	iQt[ 3 ] = 0;

	//

	//TBitmapHandle bm;

	//bm.iData = 0;

	TBool moreChunks = ETrue;

	TBool possibleChunk = EFalse;

//	TInt pos;

	while( moreChunks )

		{

		TUint8 b = iBuffer[ iBufPos++ ];

		if( possibleChunk )

			{

			possibleChunk = EFalse;

			switch( b )

				{

				case 0xd8: // start of image

					{

				    //RDebug::Print( _L("--Jpeg start of image") );

					//iDebug.Write( _L8("d2\n") );

					break;

					}

				case 0xe0: // JFIF application segment

					{

					//RDebug::Print( _L("--Jpeg application segment") );

					//iDebug.Write( _L8("d3\n") );

					break;

					}

				case 0xe1: // APP1 segment, possible EXIF

					{

					//iDebug.Write( _L8("d4\n") );

					//RDebug::Print( _L("--Jpeg app1 segment") );

					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					l -= 2;

					// this could be used to read exif data:

					//TPtrC8 exifData( iBuffer + iBufPos, l );

					// Check that there is "Exif" header in the data

					const TUint8* pos = &iBuffer[ iBufPos ];

					if (Mem::Compare(pos, 2, &KExifHeader[0], 2 ))

					{

						iBufPos += l;

						break;

					}

					// suppose there is exif here

					// exif header is 6 bytes ( 45 78 69 66 00 00 "Exif.." )

					iBufPos += 6;

					l -= 6;

					iExifData = iBuffer + iBufPos;

					iExifDataLength = l;

					iBufPos += l;

					break;

					}

				case 0xe2:

				case 0xe3:

				case 0xe4:

				case 0xe5:

				case 0xe6:

				case 0xe7:

				case 0xe8:

				case 0xe9:

				case 0xea:

				case 0xeb:

				case 0xec:

				case 0xed:

				case 0xee:

				case 0xef:

					{

					//iDebug.Write( _L8("d5\n") );

					//

					// Unused segment, skip

					// 

					//RDebug::Print( _L("--Jpeg unused tag %x"), b );

					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					iBufPos += l-2;

					break;

					}

				case 0xdb: // Quantization table

					{

					//iDebug.Write( _L8("d6\n") );

					//RDebug::Print( _L("--Jpeg quant table") );

					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					////RDebug::Print( _L("Start:%x length:%d"), iBufPos-2, l );

					TInt nqt = l / 65;

					TInt i;

					// one or more quantization table

					for( i=0; i<nqt; i++ )

						{

						TUint8 t = iBuffer[ iBufPos++ ];

						TInt n = t & 15;

						// not used:

						// TInt precision = n >> 4; 

						if (iQt[ n ])

						{

							delete iQt[ n ];

							iQt[ n ] = NULL;							

						}

						iQt[ n ] = new( ELeave )TUint8[ 64 ];

						TInt j;

						for( j=0; j<64; j++ )

							{

							iQt[ n ][ j ] = iBuffer[ iBufPos++ ];

							//RDebug::Print( _L("Quant %d:first=%d"), j, iQt[ n ][ j ] );

							}

						}

					break;

					}

				case 0xc0: // start of frame ( SOF )

					{

					//iDebug.Write( _L8("d7\n") );

					//RDebug::Print( _L("--Jpeg start of frame") );

					//TInt length = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; 

					iBufPos += 2;

					////RDebug::Print( _L("Start:%x length:%d"), iBufPos-2, length );

					// not used:

					// TInt precision = iBuffer[ iBufPos ];

					iBufPos++; 

					// height

					TInt t = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					iData.iSize.iHeight = t;

					// width

					t = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					iData.iSize.iWidth = t;

					// component data

					iNumComponents = iBuffer[ iBufPos++ ];

					TInt i;

					for( i=0; i<iNumComponents; i++ )

						{

						TInt compID = iBuffer[ iBufPos++ ];

						TInt samplingFactor = iBuffer[ iBufPos++ ];

						TInt quantizationTable = iBuffer[ iBufPos++ ];

						iComponent[ i ].iXFactor = samplingFactor >> 4;

						iComponent[ i ].iYFactor = samplingFactor & 15;

						iComponent[ i ].iQuantTable = quantizationTable;

						iComponent[ i ].iID = compID;

						//RDebug::Print( _L("component %d = %d"), i, compID );

						//RDebug::Print( _L("component %d quanttable=%d"), i, quantizationTable );

						//RDebug::Print( _L("component %d factor = %d,%d"), iComponent[ i ].iXFactor, iComponent[ i ].iYFactor );

						}

					TInt xBlocks = 0;

					TInt yBlocks = 0;

					for( i=0; i<iNumComponents; i++ )

						{

						TInt x = iComponent[ i ].iXFactor;

						TInt y = iComponent[ i ].iYFactor;

						if( x > xBlocks )

							{

							xBlocks = x;

							}

						if( y > yBlocks )

							{

							yBlocks = y;

							}

						}

					iData.iBlockSize.iWidth = xBlocks * 8;

					iData.iBlockSize.iHeight = yBlocks * 8;

					TSize size = iData.iSize;

					size.iWidth /= iData.iBlockSize.iWidth;

					size.iHeight /= iData.iBlockSize.iHeight;

					if( iData.iSize.iWidth & ( iData.iBlockSize.iWidth - 1 ) )

						{

						size.iWidth++;

						}

					if( iData.iSize.iHeight & ( iData.iBlockSize.iHeight - 1 ) )

						{

						size.iHeight++;

						}

					iData.iSizeInBlocks = size;

					break;

					}

				case 0xc1:

					{

					//iDebug.Write( _L8("d8\n") );

					//RDebug::Print( _L("--Jpeg tag 0xc1, extended sequential, unsupported") );

					// Extended sequential Jpeg, not supported

					User::Leave( KErrNotSupported );

					break;

					};

				case 0xc2:

					{

					//iDebug.Write( _L8("d9\n") );

					//RDebug::Print( _L("--Jpeg tag 0xc2, Progressive DCT, unsupported") );

					// Progressive DCT jpeg, not supported

					User::Leave( KErrNotSupported );

					break;

					};

				case 0xc3:

					{

					//iDebug.Write( _L8("d10\n") );

					//RDebug::Print( _L("--Jpeg tag 0xc1, Lossless, unsupported") );

					// Lossless ( sequential ) Jpeg, not supported

					User::Leave( KErrNotSupported );

					break;

					};

				case 0xc5:

				case 0xc6:

				case 0xc7:

				case 0xc8:

				case 0xc9:

				case 0xca:

				case 0xcb:

				case 0xcc:

				case 0xcd:

				case 0xce:

				case 0xcf:

					{

					//iDebug.Write( _L8("d11\n") );

					//RDebug::Print( _L("--Jpeg tag %x, unknown"), b );

					User::Leave( KErrNotSupported );

					break;

					};

				case 0xc4: // huffman table

					{

					//iDebug.Write( _L8("d12\n") );

					//RDebug::Print( _L("--Jpeg huffman table") );

					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					TInt table = 0;

					TInt n = 0;

					// one or more huffman tables

					while( n<l-2 )

						{

						THuffman* huff = new( ELeave )THuffman;

						table = iBuffer[ iBufPos++ ];

						n++;

						TInt huffSize[ 16 ];

						TInt numSymbols = 0;

						TInt i;

						for( i=0; i<16; i++ )

							{

							TInt size = iBuffer[ iBufPos++ ];

							huffSize[ i ] = size;

							numSymbols += size;

							n++;

							}

						////RDebug::Print( _L("       # of symbols %d"), numSymbols );

						for( i=0; i<numSymbols; i++ )

							{

							TUint8 v = iBuffer[ iBufPos++ ];

							huff->iSymbol[ i ] = v;