// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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:
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/

#include "graphicsimagecomparison.h"

/**
Compares the contents of a rectangular region of one bitmap with a similarly sized
rectangular region of another bitmap.

@param aCompareSize, a const reference to a TSize object denoting the size of the
rectangular region for comparison.Negative and zero dimensions of this argument can
be passed in without returning a KErrArgument error.
@param aBitmap1Point, a const reference to a TPoint object denoting the top left
point of the rectangle in aBitmap1 used for comparison..
@param aBitmap2Point, a const reference to a TPoint object denoting the top left
point of the rectangle in aBitmap2 used for comparison.
@param aBitmap1, a const reference to the first CFbsBitmap for use in comparison.
@param aBitmap2, a const reference to the second CFbsBitmap for use in comparison.
@param aComparisonMask, a bit mask to be applied to the bitmap pixel data before
performing the comparison, in the form 0xAARRGGBB. Defaults to 0xFFFFFFFF 
@pre The rectanglular comparison region must reside wholly inside both of the bitmaps
@return KErrNone if the pixels contained in the bitmap rectangles are an exact match
or, otherwise, the count of the first unmatched pixel. Pixels are compared from TRUE
top-left to bottom-right in the horizontal direction (TRUE to cope with negative
dimensions of the aCompareSize object) An area of zero size will return KErrNone so
long as the pre-conditions are satisfied.
KErrArgument if the pre-conditions are not met.
*/
EXPORT_C TInt CTGraphicsImageComparison::CompareBitmaps(const TSize& aCompareSize,
                                                        const TPoint& aBitmap1Point,
                                                        const TPoint& aBitmap2Point,
                                                        const CFbsBitmap& aBitmap1,
                                                        const CFbsBitmap& aBitmap2,
                                                        const TUint32 aComparisonMask)
	{
	TInt err = CheckArguments(aCompareSize,
                              aBitmap1Point,
                              aBitmap2Point,
                              aBitmap1,
                              aBitmap2);

	if(err == KErrNone)
		{
		//Take local copies as cannot modify static arguments
		TSize localSize(aCompareSize);
		TPoint localPoint1(aBitmap1Point);
		TPoint localPoint2(aBitmap2Point);

		//Cope with negative aCompareSize dimensions
		if(aCompareSize.iWidth < 0)
			{
			localSize.iWidth = -localSize.iWidth;
			localPoint1.iX = localPoint1.iX - localSize.iWidth;
			localPoint2.iX = localPoint2.iX - localSize.iWidth;
			}

		if(aCompareSize.iHeight < 0)
			{
			localSize.iHeight = -localSize.iHeight;
			localPoint1.iY = localPoint1.iY - localSize.iHeight;
			localPoint2.iY = localPoint2.iY - localSize.iHeight;
			}

        // Set up buffers for obtaining scanlines
        TInt scanLineLength1 = aBitmap1.ScanLineLength(localSize.iWidth, ERgb);
		TUint8* buffer1 = new TUint8[scanLineLength1];
		if(!buffer1)
		    {
		    return KErrNoMemory;
		    }
        TPtr8 scanLine1(buffer1, scanLineLength1, scanLineLength1);
		TInt scanLineLength2 = aBitmap2.ScanLineLength(localSize.iWidth, ERgb);
        TUint8* buffer2 = new TUint8[scanLineLength2];
        if(!buffer2)
            {
            delete[] buffer1;
            return KErrNoMemory;
            }
        TPtr8 scanLine2(buffer1, scanLineLength2, scanLineLength2);

        //Perform scanline to scanline comparison without comparison mask
	    for(TInt y=0; y<localSize.iHeight; y++)
            {
            aBitmap1.GetScanLine(scanLine1, localPoint1+TPoint(0,y), localSize.iWidth, ERgb);
            aBitmap2.GetScanLine(scanLine2, localPoint2+TPoint(0,y), localSize.iWidth, ERgb);
            
            if(aComparisonMask!=0xFFFFFFFF || scanLine1.Compare(scanLine2)!=0)
                {
                //Comparison mask has been set, or scanlines are not equal
                //so perform pixel by pixel comparison using mask
                TRgb pixel1, pixel2;
                for(TInt x=0; x<localSize.iWidth; x++)
                    {
                    pixel1 = *(((TRgb*)buffer1) + x);
                    pixel2 = *(((TRgb*)buffer1) + x);

                    if( (pixel1.Internal()& aComparisonMask) != (pixel2.Internal()& aComparisonMask))
                        {
                        RDebug::Print(_L("x = %d y = %d  pixel1= %x pixel2 = %x"), x, y, pixel1.Internal(), pixel2.Internal());
                        delete[] buffer2;
                        delete[] buffer1;
                        return (y*localSize.iWidth + x) + 1;
                        }
                    }
                }
           }
	    delete[] buffer2;
	    delete[] buffer1;
        }
    return err;
	}

/**
Compares the contents of a rectangular region of a bitmap with a reference colour.

@param aCompareSize, a const reference to a TSize object denoting the size of the
rectangular region for comparison.Negative and zero dimensions of this argument can
be passed in without returning a KErrArgument error.
@param aBitmapPoint, a const reference to a TPoint object denoting the top left
point of the rectangle in aBitmap1 used for comparison..
@param aBitmap, a const reference to the CFbsBitmap for use in comparison.
@param aColor, the colour to test for
@param aComparisonMask, a bit mask to be applied to both the bitmap pixel data and the
colour data before performing the comparison, in the form 0xAARRGGBB. Defaults to 0xFFFFFFFF 
@pre The rectanglular comparison region must reside wholly inside the bitmap
@return KErrNone if the pixels contained in the bitmap rectangles are an exact match
to the reference colour or, otherwise, the count of the first unmatched pixel. Pixels
are compared from TRUE top-left to bottom-right in the horizontal direction (TRUE to
cope with negative dimensions of the aCompareSize object) An area of zero size will
return KErrNone so long as the pre-conditions are satisfied.
KErrArgument if the pre-conditions are not met.
*/
EXPORT_C TInt CTGraphicsImageComparison::CompareBitmaps(const TSize& aCompareSize,
                                                        const TPoint& aBitmapPoint,
                                                        const CFbsBitmap& aBitmap,
                                                        const TRgb& aColor,
                                                        const TUint32 aComparisonMask)
	{
	TInt err = CheckArgumentBitmap(aCompareSize,
                                   aBitmapPoint,
                                   aBitmap);

	if(err == KErrNone)
		{
		//Take local copies as cannot modify static arguments
		TSize localSize(aCompareSize);
		TPoint localPoint(aBitmapPoint);

		//Cope with negative aCompareSize dimensions
		if(aCompareSize.iWidth < 0)
			{
			localSize.iWidth = -localSize.iWidth;
			localPoint.iX = localPoint.iX - localSize.iWidth;
			}

		if(aCompareSize.iHeight < 0)
			{
			localSize.iHeight = -localSize.iHeight;
			localPoint.iY = localPoint.iY - localSize.iHeight;
			}

        // Set up buffers for obtaining scanlines
        TInt scanLineLength = aBitmap.ScanLineLength(localSize.iWidth, ERgb);
        TUint8* buffer = new TUint8[scanLineLength];
        if(!buffer)
            {
            return KErrNoMemory;
            }
        TPtr8 scanLine(buffer, scanLineLength, scanLineLength);

        //Perform the pixel by pixel comparison
        TRgb pixel;
		for(TInt y=0; y<localSize.iHeight; y++)
	 		{
            aBitmap.GetScanLine(scanLine, localPoint+TPoint(0,y), localSize.iWidth, ERgb);
	 		for(TInt x=0; x<localSize.iWidth; x++)
				{
                pixel = *(((TRgb*)buffer) + x);

                if( (pixel.Internal()& aComparisonMask) != (aColor.Internal()& aComparisonMask))
					{
					RDebug::Print(_L("x = %d y = %d  pixel= %x reference colour = %x"), x, y, pixel.Internal(), aColor.Internal());
                    delete[] buffer;
					return (y*localSize.iWidth + x) + 1;
					}
				}
	 		}
	    delete[] buffer;
		}
    return err;
	}

TInt CTGraphicsImageComparison::CheckArguments(const TSize& aCompareSize,
                                               const TPoint& aBitmap1Point,
                                               const TPoint& aBitmap2Point,
                                               const CFbsBitmap& aBitmap1,
                                               const CFbsBitmap& aBitmap2)
	{
	//Test that the arguments are valid for both bitmaps
	TInt err = CheckArgumentBitmap(aCompareSize, aBitmap1Point, aBitmap1);

	if(err == KErrNone)
		{
		err = CheckArgumentBitmap(aCompareSize, aBitmap2Point, aBitmap2);
		}

	return err;
	}

TInt CTGraphicsImageComparison::CheckArgumentBitmap(const TSize& aSize,
                                                    const TPoint& aPoint,
                                                    const CFbsBitmap& aBitmap)
	{
	//Top left-hand corner of the comparison rectangle is outside of the bitmap
	if( (aPoint.iX < 0) || (aPoint.iY < 0) )
		{
		return KErrArgument;
		}

	if(aSize.iWidth >= 0)
		{
		//Comparison rectangle is outside of the bitmap (rhs)
		if(aPoint.iX + aSize.iWidth > aBitmap.SizeInPixels().iWidth)
			{
			return KErrArgument;
			}
		}
	else
		{
		//Comparison rectangle is outside of the bitmap (lhs)
		if(aPoint.iX + aSize.iWidth < 0)
			{
			return KErrArgument;
			}
		}

	if(aSize.iHeight >= 0)
		{
		//Comparison rectangle is outside of the bitmap (bottom)
		if(aPoint.iY + aSize.iHeight > aBitmap.SizeInPixels().iHeight)
			{
			return KErrArgument;
			}
		}
	else
		{
		//Comparison rectangle is outside of the bitmap (top)
		if(aPoint.iY + aSize.iHeight < 0)
			{
			return KErrArgument;
			}
		}

	return KErrNone;
	}
