/*
* 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 "CJpegScale.h"
#include "CJpeg.h"
#include "CJpegSave.h"
#include "CExifParser.h"


CJpegScale::CJpegScale( MJpegScaleCallBack* aCallBack )
	: iTargetScale( 0 )
	, iQuality( 95 )
	, iCallBack( aCallBack )
	{
	}
	

	
CJpegScale::~CJpegScale()
	{
	}
	

	
	
void CJpegScale::ScaleL()
	{
	const TInt KxShift = 14;
	const TInt KxMul = ( 1 << KxShift );
	const TInt KxAnd = KxMul - 1;	
	
	CJpeg* source;
	CJpegSave* target;
	
	// file server session
	RFs fs;
	User::LeaveIfError( fs.Connect() );
	CleanupClosePushL( fs );
	
	// encoded file
	RFile targetFile;
	User::LeaveIfError( targetFile.Replace( fs, iTargetName, EFileWrite ) );
	CleanupClosePushL( targetFile );
	
	// jpeg source
	source = CJpeg::NewL();
	CleanupStack::PushL( source );
	
	// jpeg target
	target = CJpegSave::NewL( &fs, &targetFile );
	CleanupStack::PushL( target );

	source->OpenL( iSourceName );
	
	TJpegData info = source->Info();

	TInt tw = iTargetSize.iWidth;
	TInt th = iTargetSize.iHeight;
	
	TInt sw = info.iSize.iWidth;
	TInt sh = info.iSize.iHeight;

	TInt xscale;
	TInt yscale;

	//
	// Decide scale or target size
	//
	if( iTargetScale != 0 )
		{
		xscale = (TInt)(iTargetScale * KxMul);
		yscale = xscale;
		tw = xscale * sw / KxMul;
		th = yscale * sh / KxMul;
		}
	else
		{
		yscale = KxMul * th / sh;
		xscale = KxMul * tw / sw;
		}

	if( tw>sw || th>sh )
		{
		// no upscaling yet.
		User::Leave( KErrNotSupported );
		}

	//
	// Hardscale is scaling which is done in jpeg decoder
	// possible hardscales are 1:1, 1:2, 1:4 and 1:8
	// hard scaling speeds up things a lot.
	//
	TInt hardScale = 1;
	source->SetScale( EScale1 );

	if( xscale <= KxMul/8 && yscale <= KxMul/8 )
		{
		hardScale = 8;
		source->SetScale( EScale8 );
		}

	else if( xscale <= KxMul/4 && yscale <= KxMul/4 )
		{
		hardScale = 4;
		source->SetScale( EScale4 );
		}

	else if( xscale <= KxMul/2 && yscale <= KxMul/2 )
		{
		hardScale = 2;
		source->SetScale( EScale2 );
		}
	// else hardscale = 1


	sw /= hardScale;
	sh /= hardScale;
	xscale *= hardScale;
	yscale *= hardScale;
	

	//
	// Jpeg store bitmap block
	// Jpeg encoder always uses block size of 16x8 pixels
	//
	TBitmapHandle blk;
	blk.iSize = TSize( 16,8 );
	blk.iData = new( ELeave )TUint32[ 16*8 ];
	CleanupStack::PushL( blk.iData );

	iTargetSize = TSize( tw,th );
		
	CExifParser* parser = CExifParser::NewLC();
	parser->ParseL(source->ExifData());
	
    // ImageWidth - Not used for JPEG images 
    if (parser->TagExist(CExifParser::EIfd0, 0x0100))
    {
        parser->DeleteTag ( CExifParser::EIfd0, 0x0100);
        //iExifParser->AddTagL ( CExifParser::EIfd0, 0x0100, (TUint16)iTargetSize.iWidth);        
    }

    // ImageHeight - Not used for JPEG images 
    if (parser->TagExist(CExifParser::EIfd0, 0x0101))
    {
        parser->DeleteTag ( CExifParser::EIfd0, 0x0101);
        //iExifParser->AddTagL ( CExifParser::EIfd0, 0x0101, (TUint16)iTargetSize.iHeight);
    }
	    
	// PixelXResolution 
    if (parser->TagExist(CExifParser::ESubIfd, 0xA002))
    {
        parser->DeleteTag ( CExifParser::ESubIfd, 0xA002);
        parser->AddTagL ( CExifParser::ESubIfd, 0xA002,(TUint32)iTargetSize.iWidth);
    }
    // PixelYResolution 
    if (parser->TagExist(CExifParser::ESubIfd, 0xA003))
    {
        parser->DeleteTag ( CExifParser::ESubIfd, 0xA003);
        parser->AddTagL ( CExifParser::ESubIfd, 0xA003, (TUint32)iTargetSize.iHeight);
    }

    TPtr8 exif = parser->SaveL(parser->ThumbData());
	
	//
	// Initialize jpeg encoder
	// no exif
	// save buffer ~16KB
	// use iQuality as quality ( values from 0 to 100 )
	//
	target->StartSaveL( iTargetSize, exif, 16000, iQuality );
	
	CleanupStack::PopAndDestroy(); // parser
    	
	TInt yStep = 8;		// jpeg encoder block height
	TInt yPos = 0;		// number of encoded lines
	
	//
	// Reserve scaled buffer
	//
	TInt pixels = tw * ( yStep*2 ); // room for 2 block lines

	TUint32* cr = new( ELeave )TUint32[ pixels ];
	CleanupStack::PushL( cr );
	TUint32* cg = new( ELeave )TUint32[ pixels ];
	CleanupStack::PushL( cg );
	TUint32* cb = new( ELeave )TUint32[ pixels ];
	CleanupStack::PushL( cb );
	TUint32* cm = new( ELeave )TUint32[ pixels ];
	CleanupStack::PushL( cm );

	//
	// Clear scaled buffer
	//
	Mem::FillZ( cr, pixels * sizeof( TUint32 ) );
	Mem::FillZ( cg, pixels * sizeof( TUint32 ) );
	Mem::FillZ( cb, pixels * sizeof( TUint32 ) );
	Mem::FillZ( cm, pixels * sizeof( TUint32 ) );
	

	TInt srcBlockHeight = info.iBlockSize.iHeight;
	
	TInt srcY1 = 0;
	TInt srcY2 = 0;
	TBitmapHandle bm;
	bm.iData = 0;

	for( TInt y=0; y<sh; y++ )
		{
		if( iCallBack )
			{
			iCallBack->JpegStatusCallBack( 100 * y / sh );
			}
		//
		// Fill source buffer when needed
		//
		if( srcY2 <= y )
			{
			delete bm.iData;
			TRect rect( 0,y*hardScale, info.iSize.iWidth, ( y + srcBlockHeight ) * hardScale );
			bm = source->LoadImageL( rect );
			srcY1 = y;
			srcY2 = srcY1 + bm.iSize.iHeight;
			}

		TUint32* srcRgb = (TUint32*)bm.iData;
		srcRgb += (y-srcY1) * bm.iSize.iWidth;

		TInt ty = y * yscale;
		TInt y2 = ty & KxAnd;
		TInt y1 = KxMul - y2;
		ty >>= KxShift;
		
		TInt oy = ( ty - yPos ) * tw;
		TUint32* pr = cr + oy;
		TUint32* pg = cg + oy;
		TUint32* pb = cb + oy;
		TUint32* pm = cm + oy;

		//
		// Add pixels to scaled buffer
		//
		for( TInt x=0; x<sw; x++ )
			{
			TInt tx = x * xscale;
			TInt x2 = tx & KxAnd;
			TInt x1 = KxMul - x2;
			tx >>= KxShift;
			
			TUint32 pixel = *srcRgb++;

			TUint32 m1 = x1*y1 / KxMul;
			TUint32 m2 = x2*y1 / KxMul;
			TUint32 m3 = x1*y2 / KxMul;
			TUint32 m4 = x2*y2 / KxMul;
			
			TInt red = pixel >> 16;
			pr[ tx ] += m1 * red;
			pr[ tx+1 ] += m2 * red;
			pr[ tx+tw ] += m3 * red;
			pr[ tx+tw+1 ] += m4 * red;

			TInt green = ( pixel >> 8 ) & 255;
			pg[ tx ] += m1 * green;
			pg[ tx+1 ] += m2 * green;
			pg[ tx+tw ] += m3 * green;
			pg[ tx+tw+1 ] += m4 * green;

			TInt blue = pixel & 255;
			pb[ tx ] += m1 * blue;
			pb[ tx+1 ] += m2 * blue;
			pb[ tx+tw ] += m3 * blue;
			pb[ tx+tw+1 ] += m4 * blue;

			pm[ tx ] += m1;
			pm[ tx+1 ] += m2;
			pm[ tx+tw ] += m3;
			pm[ tx+tw+1 ] += m4;
			}


		//
		// Transfer scaled buffer block-by-block to jpeg encoder
		//
		if( ty >= yPos + yStep || y == sh-1 )
			{
			yPos += yStep;

			TUint32* trgb = (TUint32*)blk.iData;
			
			for( TInt b=0; b<tw; b += 16 )
				{
				TUint32* p = trgb;
				for( TInt by=0; by<8; by++ )
				for( TInt bx=0; bx<16; bx++ )
					{
					TUint32 pos = b + bx + by*tw;
					TUint32 bcr = cr[ pos ];
					TUint32 bcg = cg[ pos ];
					TUint32 bcb = cb[ pos ];
					TUint32 m = cm[ pos ];
					if( m )
						{
						bcr /= m;
						bcg /= m;
						bcb /= m;
						}
					//trgb[ bx + by * 16 ] = bcr*65536 + bcg*256 + bcb;

					TUint32 c = bcr << 16;
					c += ( bcg << 8 );
					c += bcb;
					*p++ = c;
					}
				target->SaveBlock( blk );
				}

			//
			// move overflow line to first line in scaled buffer
			//
			TInt offset = tw * yStep;
			for( TInt rx=0; rx<tw; rx++ )
				{
				cr[ rx ] = cr[ rx + offset ];
				cg[ rx ] = cg[ rx + offset ];
				cb[ rx ] = cb[ rx + offset ];
				cm[ rx ] = cm[ rx + offset ];

				}

			//
			// clear all but first line from scaled buffer
			//
			TInt clrbytes = tw * yStep * sizeof( TUint32 );
			offset = tw;
			Mem::FillZ( cr+offset, clrbytes );
			Mem::FillZ( cg+offset, clrbytes );
			Mem::FillZ( cb+offset, clrbytes );
			Mem::FillZ( cm+offset, clrbytes );
			}
		}

	target->FinalizeSave();
	
	delete bm.iData;

	CleanupStack::PopAndDestroy( 4 ); // cm,cb,cg,cr
	CleanupStack::PopAndDestroy( blk.iData );
	CleanupStack::PopAndDestroy( target );
	CleanupStack::PopAndDestroy( source );
	CleanupStack::PopAndDestroy( 2 ); // file, fs

	if( iCallBack )
		{
		iCallBack->JpegStatusCallBack( 100 );
		}

	}