/*

* 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 "CJpRotate.h"

#include "MJpRotateCallBack.h"

#include "CExifParser.h"

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

						};

const TUint8 KReZig[] = {

						0,2,1,5,4,3,9,8,

						7,6,14,13,12,11,10,20,

						19,18,17,16,15,27,26,25,

						24,23,22,21,35,34,33,32,

						31,30,29,28,42,41,40,39,

						38,37,36,48,47,46,45,44,

						43,53,52,51,50,49,57,56,

						55,54,60,59,58,62,61,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 ];

	};

CJpRotate* CJpRotate::NewL( RFs& aFs, RFile* aSaveFile, TInt aSaveBufSize )

	{

	CJpRotate* self = NewLC( aFs, aSaveFile, aSaveBufSize );

	CleanupStack::Pop( self );

	return self;

	}

CJpRotate* CJpRotate::NewLC( RFs& aFs, RFile* aSaveFile, TInt aSaveBufSize )

	{

	CJpRotate* self = new( ELeave )CJpRotate( aFs, aSaveFile, aSaveBufSize );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

CJpRotate::~CJpRotate()

	{

	delete iHuffman[ 0 ];

	delete iHuffman[ 1 ];

	delete iHuffman[ 2 ];

	delete iHuffman[ 3 ];

	delete iSaveHuffman[ 0 ];

	delete iSaveHuffman[ 1 ];

	delete iSaveHuffman[ 2 ];

	delete iSaveHuffman[ 3 ];

	delete iQt[ 0 ];

	delete iQt[ 1 ];

	delete iQt[ 2 ];

	delete iQt[ 3 ];

	if( iOwnBuffer )

		{

		delete iBuffer;

		}

	delete iSaveBuf;

	iBasicBlock.Reset();

	if( &iSaveFile != NULL )

		{

		iSaveFile.Flush();

		iSaveFile.Close();

		}

	}

CJpRotate::CJpRotate( RFs& aFs, RFile* aSaveFile, TInt aSaveBufSize )

	: iCancelled(EFalse)

	, iFs( aFs )

	, iSaveFile( *aSaveFile )

	, iSaveBufSize( aSaveBufSize )

	{

	}

void CJpRotate::ConstructL()

	{

	}

void CJpRotate::SetCallBack( MJpRotateCallBack* aCallBack )

	{

	iCallBack = aCallBack;

	}

void CJpRotate::Cancel()

    {

    iCancelled = ETrue;

    }

void CJpRotate::RotateL( const TFileName& aFile, TBool aRotate, TBool aFlip, TBool aMirror )

	{

	iCancelled = EFalse;

	if (iBuffer)

	{

		delete iBuffer;

		iBuffer = NULL;		

	}

	RFile file;

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

	if (KErrNone != err)

		{

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

		}

	CleanupClosePushL( file );

	TInt size;

	file.Size( size );

	iOwnBuffer = true;

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

	TPtr8 ptr( iBuffer, size );

	file.Read( ptr );

	CleanupStack::PopAndDestroy( 1 ); // file

	RotateL( ptr, aRotate, aFlip, aMirror );

	}

void CJpRotate::RotateL( const TPtrC8& aData, TPtrC8& aTarget, TBool aRotate, TBool aFlip, TBool aMirror )

	{

	iOwnBuffer = false;

	RotateL( aData, aRotate, aFlip, aMirror );

	aTarget.Set( iSaveBuf, iSaveBufPos );

	}

void CJpRotate::RotateL( const TPtrC8& aData, TBool aRotate, TBool aFlip, TBool aMirror )

	{

	iFlip = aFlip;

	iMirror = aMirror;

	iRotate = aRotate;

	if( iRotate )

		{

		if( iFlip )

			{

			iFlip = false;

			}

		else

			{

			iFlip = true;

			}

		}

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

	iSaveBuf = new( ELeave )TUint8[ iSaveBufSize ];

	//Mem::FillZ( iSaveBuf, iS );

	iSaveByte = 0;

	iSaveBufPos = 0;

	iSaveBufBitPos = 0;

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

	//CreateDefaultHuffmanL();

	iQt[ 0 ] = 0;

	iQt[ 1 ] = 0;

	iQt[ 2 ] = 0;

	iQt[ 3 ] = 0;

	TBool moreChunks = ETrue;

	TBool possibleChunk = EFalse;

	while( moreChunks )

		{

		if (iCancelled)

		    {

		    return;

		    }

		TUint8 b = iBuffer[ iBufPos++ ];

		if( possibleChunk )

			{

			possibleChunk = EFalse;

			switch( b )

				{

				case 0xd8: // start of image

					{

					WriteSaveBuffer( (TUint16)0xffd8 );

					break;

					}

				case 0xe0: // JFIF application segment

					{

					WriteSaveBuffer( (TUint16)0xffe0 );

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

					WriteSaveBuffer( (TUint16)l );

					WriteSaveBuffer( iBuffer + iBufPos, l-2 );

					iBufPos += l-2;

					break;

					}

				case 0xe1: // APP1 segment, possible EXIF

					{

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

					iBufPos += 2;

					l -= 2;

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

					}

					iBufPos += 6;

					l -= 6;

					iExifData = iBuffer + iBufPos;

					iExifDataLength = l;

					CExifParser* p = CExifParser::NewLC();

					TRAP_IGNORE(p->ParseL( TPtrC8( iExifData, iExifDataLength ) ););

					TPtrC8 thumb( p->ThumbData() );

					TPtrC8 saveThumb( 0,0 );

					TUint8* thumbPtr = 0;

					if( iRotate )

						{

						//

						// swap width and height ( if exists )

						//

						if( p->TagExist( CExifParser::ESubIfd, 0xa002 ) &&

							p->TagExist( CExifParser::ESubIfd, 0xa003 ) )

							{

							TUint16 width = p->TagValue( CExifParser::ESubIfd, 0xa002 );

							TUint16 height = p->TagValue( CExifParser::ESubIfd, 0xa003 );

							p->DeleteTag( CExifParser::ESubIfd, 0xa002 );

							p->DeleteTag( CExifParser::ESubIfd, 0xa003 );

							p->AddTagL( CExifParser::ESubIfd, 0xa002, height );

							p->AddTagL( CExifParser::ESubIfd, 0xa003, width );

							}

						}

					//

					// Rotate thumbnail ( if exists )

					//

					if( thumb.Ptr() )

						{

						CJpRotate* r = CJpRotate::NewLC( iFs, NULL, 0x10000 );

						TPtrC8 target;

						r->RotateL( thumb, target, aRotate, aFlip, aMirror );

						thumbPtr = new( ELeave )TUint8[ target.Length() ];

						Mem::Copy( thumbPtr, target.Ptr(), target.Length() );

						saveThumb.Set( thumbPtr, target.Length() );

						CleanupStack::PopAndDestroy( r );

						CleanupStack::PushL( thumbPtr );

						}

					TPtrC8 exif = p->SaveL( saveThumb );

					WriteSaveBuffer( (TUint16)0xffe1 );	// APP1 segment

					TUint16 l2 = exif.Length() + 6 + 2; // +header+tagsize

					WriteSaveBuffer( l2 );

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

					WriteSaveBuffer( (TUint8)0x45 );

					WriteSaveBuffer( (TUint8)0x78 );

					WriteSaveBuffer( (TUint8)0x69 );

					WriteSaveBuffer( (TUint8)0x66 );

					WriteSaveBuffer( (TUint8)0x00 );

					WriteSaveBuffer( (TUint8)0x00 );

					WriteSaveBuffer( exif.Ptr(), exif.Length() );

					if( thumbPtr )

						{

						CleanupStack::PopAndDestroy( thumbPtr );

						}

					CleanupStack::PopAndDestroy( p );

					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:

					{

					WriteSaveBuffer( (TUint8)0xff );

					WriteSaveBuffer( (TUint8)b );

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

					WriteSaveBuffer( (TUint16)l );

					WriteSaveBuffer( iBuffer + iBufPos, l-2 );

					iBufPos += l-2;

					break;

					}

				case 0xdb: // Quantization table

					{

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

					WriteSaveBuffer( (TUint16)0xffdb );

					WriteSaveBuffer( (TUint16)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;

						WriteSaveBuffer( t );

						// 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++ ];

							}

						TUint8 qt[ 64 ];

						ConvertQuants( iQt[ n ], qt );

						WriteSaveBuffer( qt, 64 );

						}

					break;

					}

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

					{

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

					WriteSaveBuffer( (TUint16)0xffc0 );

					WriteSaveBuffer( (TUint16)length );

					// not used:

					TUint8 precision = iBuffer[ iBufPos ];

					WriteSaveBuffer( precision );

					iBufPos++; 

					// height

					TUint16 h = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					iData.iSize.iHeight = h;

					// width

					TUint16 w = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

					iData.iSize.iWidth = w;

					if( iRotate )

						{

						WriteSaveBuffer( w );

						WriteSaveBuffer( h );

						}

					else

						{

						WriteSaveBuffer( h );

						WriteSaveBuffer( w );

						}

					// component data

					iNumComponents = iBuffer[ iBufPos++ ];

					WriteSaveBuffer( (TUint8)iNumComponents );

					TInt i;

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

						{

						TUint8 comp = iBuffer[ iBufPos++ ] - 1;

						TUint8 samplingFactor = iBuffer[ iBufPos++ ];

						TUint8 quantizationTable = iBuffer[ iBufPos++ ];

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

						iComponent[ comp ].iYFactor = samplingFactor & 15;

						iComponent[ comp ].iQuantTable = quantizationTable;