/*

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

*

*/

//

// Jpeg encoder class

#include "CJpegSave.h"

#include <fbs.h>

#include <e32math.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

						};

//Table K.1 from JPEG specification

const int jpeg_luma_quantizer[64] = {

        16, 11, 10, 16, 24, 40, 51, 61,

        12, 12, 14, 19, 26, 58, 60, 55,

        14, 13, 16, 24, 40, 57, 69, 56,

        14, 17, 22, 29, 51, 87, 80, 62,

        18, 22, 37, 56, 68, 109, 103, 77,

        24, 35, 55, 64, 81, 104, 113, 92,

        49, 64, 78, 87, 103, 121, 120, 101,

        72, 92, 95, 98, 112, 100, 103, 99

};

// Table K.2 from JPEG specification

const int jpeg_chroma_quantizer[64] = {

        17, 18, 24, 47, 99, 99, 99, 99,

        18, 21, 26, 66, 99, 99, 99, 99,

        24, 26, 56, 99, 99, 99, 99, 99,

        47, 66, 99, 99, 99, 99, 99, 99,

        99, 99, 99, 99, 99, 99, 99, 99,

        99, 99, 99, 99, 99, 99, 99, 99,

        99, 99, 99, 99, 99, 99, 99, 99,

        99, 99, 99, 99, 99, 99, 99, 99

};

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

	};

// Jpeg store huffman lookup

class TSHuffman

	{

	public:

		TUint8 iLength[ 256 ];

		TInt8 iCode[ 256 ];

	};

CJpegSave* CJpegSave::NewL( RFs* aFs, RFile* aFile )

	{

	CJpegSave* self = NewLC( aFs, aFile );

	CleanupStack::Pop( self );

	return self;

	}

CJpegSave* CJpegSave::NewLC( RFs* aFs, RFile* aFile )

	{

	CJpegSave* self = new( ELeave )CJpegSave( aFs, aFile );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}	

CJpegSave::~CJpegSave()

	{

	delete iHuffman[ 0 ];

	delete iHuffman[ 1 ];

	delete iHuffman[ 2 ];

	delete iHuffman[ 3 ];

	delete iSaveBuf;

	iFs = NULL;

	iSaveFile = NULL;

	iCurrentHuffman = NULL;

	iCurrentQuant = NULL;

	}

CJpegSave::CJpegSave( RFs* aFs, RFile* aFile )

	: iFs( aFs )

	, iSaveFile( aFile )

	{

	}

void CJpegSave::ConstructL()

	{

	TSHuffman* huff = new( ELeave )TSHuffman;

	CleanupStack::PushL(huff);

	CreateHuffmanL( huff, bits_dc_luminance, val_dc_luminance );

	iHuffman[ 0 ] = huff;

	CleanupStack::Pop();

	huff = new( ELeave )TSHuffman;

	CleanupStack::PushL(huff);

	CreateHuffmanL( huff, bits_dc_chrominance, val_dc_chrominance );

	iHuffman[ 1 ] = huff;

	CleanupStack::Pop();

	huff = new( ELeave )TSHuffman;

	CleanupStack::PushL(huff);

	CreateHuffmanL( huff, bits_ac_luminance, val_ac_luminance );

	iHuffman[ 2 ] = huff;

	CleanupStack::Pop();

	huff = new( ELeave )TSHuffman;

	CleanupStack::PushL(huff);

	CreateHuffmanL( huff, bits_ac_chrominance, val_ac_chrominance );

	iHuffman[ 3 ] = huff;

	CleanupStack::Pop();

	iSaveByte = 0;

	iSaveBufPos = 0;

	iSaveBufBitPos = 0;

	}

void CJpegSave::StartSaveL( const TSize& aSize, TPtr8 aExif, TInt aSaveBufferSize, TInt aQuality )

	{

	iSaveBufSize = aSaveBufferSize;

	if (iSaveBuf)

		{

		delete iSaveBuf;

		iSaveBuf = NULL;

		}

	iSaveBuf = new( ELeave )TUint8[ iSaveBufSize ];

	// create quantization tables

	MakeTables( aQuality, iYQuant, iUVQuant );

	TSize size = aSize;

	TInt len;

	// D8 Start Of Image

	WriteSaveBuffer( (TUint16)0xffd8 );

	//

	// Exif ( if any )

	// 

	if( aExif.Length() != 0 )

		{

		WriteSaveBuffer( (TUint16) 0xffe1 );

		TUint32 l = aExif.Length() + 6 + 2; // +header+tagsize

		WriteSaveBuffer( (TUint16) l );

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

		l -= ( 6+2 ); // minus header, minus tag size

		// save exif chunck

		WriteSaveBuffer( aExif.Ptr(), l );

		}

	else

		{

		//

		// if no exif, standard application segment here

		//

		// E0 jpeg application segment

		WriteSaveBuffer( (TUint16)0xffe0 );

		// segment length

		WriteSaveBuffer( (TUint16)16 );

		// 0x4a, 0x46, 0x49, 0x46, 0x00 JFIF #0

		WriteSaveBuffer( (TUint8) 0x4a );

		WriteSaveBuffer( (TUint8) 0x46 );

		WriteSaveBuffer( (TUint8) 0x49 );

		WriteSaveBuffer( (TUint8) 0x46 );

		WriteSaveBuffer( (TUint8) 0x00 );

		WriteSaveBuffer( (TUint8) 0x01 );	// major revision number

		WriteSaveBuffer( (TUint8) 0x01 );	// minor revision number

		// 0=aspect ratio, 1=dots/inch, 2=dots/cm

		WriteSaveBuffer( (TUint8) 0x01 );

		TInt dpi = 72;

		// x dpi

		WriteSaveBuffer( (TUint16) dpi );

		// y dpi

		WriteSaveBuffer( (TUint16) dpi );

		// thumbnail width

		WriteSaveBuffer( (TUint8) 0 );

		// thumbnail height

		WriteSaveBuffer( (TUint8) 0 );

		}

	//

	// quant table

	//

	TUint8 quant[ 2 ][ 64 ];

	TInt i;

	TInt n;

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

		{

		quant[ 0 ][ i ] = iYQuant[ i ];

		quant[ 1 ][ i ] = iUVQuant[ i ];

		}

	for( n=0; n<2; n++ )

		{

		WriteSaveBuffer( (TUint16) 0xffdb );

		len = 2 + 1 * 65;

		// chunk length

		WriteSaveBuffer( (TUint16) len );

		// quantization table #

		WriteSaveBuffer( (TUint8) n );

		// quantization table

		WriteSaveBuffer( quant[ n ], 64 );

		}

	//

	// Huffman Table

	//

	const TUint8* nBits[ 4 ];

	const TUint8* values[ 4 ];

	nBits[ 0 ] = bits_dc_luminance;

	nBits[ 1 ] = bits_dc_chrominance;

	nBits[ 2 ] = bits_ac_luminance;

	nBits[ 3 ] = bits_ac_chrominance;

	values[ 0 ] = val_dc_luminance;

	values[ 1 ] = val_dc_chrominance;

	values[ 2 ] = val_ac_luminance;

	values[ 3 ] = val_ac_chrominance;

	for( n=0; n<4; n++ )

		{

		WriteSaveBuffer( (TUint16) 0xffc4 );

		TInt numSymbols = 0;

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

			{

			TUint8 size = nBits[ n ][ i + 1 ];

			numSymbols += size;

			}

		len = 2 + 1 + 16 + numSymbols;

		// chunk length

		WriteSaveBuffer( (TUint16) len );

		// huffman table #

		WriteSaveBuffer( (TUint8)( ( n / 2 ) * 16 + ( n & 1 ) ) );

		// bit lengths for huffman table codes

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

			{

			TUint8 size = nBits[ n ][ i + 1 ];

			WriteSaveBuffer( size );

			}

		// huffman table symbols

		WriteSaveBuffer( values[ n ], numSymbols );

		}

	//

	// Start of frame

	//

	WriteSaveBuffer( (TUint16)0xffc0 );

	len = 8 + 3 * 3;

	// chunk length

	WriteSaveBuffer( (TUint16)len );

	// precision

	WriteSaveBuffer( (TUint8)8 );

	// image height

	WriteSaveBuffer( (TUint16)size.iHeight );

	// image width

	WriteSaveBuffer( (TUint16)size.iWidth );

	// number of components

	WriteSaveBuffer( (TUint8)3 );

	// component 0:

	WriteSaveBuffer( (TUint8)1 );				// number of component

	WriteSaveBuffer( (TUint8) ( 1 + 16*2 ) );	// sampling factor

	WriteSaveBuffer( (TUint8)0 );				// number of quantization table

	// component 1:

	WriteSaveBuffer( (TUint8)2 );				// number of component

	WriteSaveBuffer( (TUint8) ( 1 + 16*1 ) );	// sampling factor

	WriteSaveBuffer( (TUint8)1 );				// number of quantization table

	// component 2:

	WriteSaveBuffer( (TUint8)3 );				// number of component

	WriteSaveBuffer( (TUint8) ( 1 + 16*1 ) );	// sampling factor

	WriteSaveBuffer( (TUint8)1 );				// number of quantization table

	//

	// Start Of Scan ( SOS )

	//

	WriteSaveBuffer( (TUint16)0xffda );

	len = 3 + 3*2 + 3;

	// chunk length

	WriteSaveBuffer( (TUint16)len );

	// number of components

	WriteSaveBuffer( (TUint8)3 );	

	/// component1:

	// component ID

	WriteSaveBuffer( (TUint8)1 );

	// component huffman table ac(low4) dc(hi4)

	WriteSaveBuffer( (TUint8)0 );

	/// component2:

	// component ID

	WriteSaveBuffer( (TUint8)2 );

	// component huffman table ac(low4) dc(hi4)

	WriteSaveBuffer( (TUint8)17 );

	/// component3:

	// component ID

	WriteSaveBuffer( (TUint8)3 );

	// component huffman table ac(low4) dc(hi4)

	WriteSaveBuffer( (TUint8)17 );

	// stuffing ( actually dctsize-1 can be stored )

	WriteSaveBuffer( (TUint8)0 );

	WriteSaveBuffer( (TUint8)63 );	// dctsize - 1

	WriteSaveBuffer( (TUint8)0 );

	iDy = 0;

	iDu = 0;

	iDv = 0;

	}

void CJpegSave::SaveBlock( const TBitmapHandle& aBitmap )

	{

	//

	// Macroblocks:

	//

	TInt by[ 256 ];

	TInt bu[ 64 ];

	TInt bv[ 64 ];

	TInt dct[ 64 ];

	Rgb2Yuv( (TUint32*)aBitmap.iData, aBitmap.iSize.iWidth, by, bu, bv );

	iCurrentQuant = (TUint8*)iYQuant;

	Dct( by, dct );

	dct[ 0 ] -= iDy;

	iDy += WriteDct( dct, iHuffman[ 0 ], iHuffman[ 2 ] );

	Dct( by+64, dct );

	dct[ 0 ] -= iDy;

	iDy += WriteDct( dct, iHuffman[ 0 ], iHuffman[ 2 ] );

	iCurrentQuant = (TUint8*)iUVQuant;

	Dct( bu, dct );

	dct[ 0 ] -= iDu;

	iDu += WriteDct( dct, iHuffman[ 1 ], iHuffman[ 3 ] );

	Dct( bv, dct );

	dct[ 0 ] -= iDv;

	iDv += WriteDct( dct, iHuffman[ 1 ], iHuffman[ 3 ] );

	}

void CJpegSave::FinalizeSave()

	{

	//

	// End Of Image ( EOI )

	//

	// flush last bits to save buffer

	if( iSaveBufBitPos )

		{

		WriteBits( 0, 8-iSaveBufBitPos );

		}

	// end of image tag

	WriteSaveBuffer( (TUint16)0xffd9 );

	// there might still be stuff in save buffer

	FlushSaveBuf();		

	}

TPtrC8 CJpegSave::Finalize()

	{