// Copyright (c) 1998-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:
//
#ifndef ___IMAGEPROCESSOR_H__
#define ___IMAGEPROCESSOR_H__
#include <gdi.h>
#include <fbs.h>
/**
@publishedAll
*/
enum TImageBitmapUtilPanic
{
ECorrupt
};
/**
@publishedAll
@released
Interface to colour conversion classes for various display modes.
Manages the mapping between RGB/Greyscale values and the index
into the color palette for the given display mode.
*/
class TColorConvertor
{
public:
IMPORT_C static TColorConvertor* NewL(TDisplayMode aDisplayMode);
/**
Returns the colour index corresponding to the supplied RGB value.
Operates in the context of the current display mode.
This is a virtual function that each derived class must implement.
@param aColor
The colour in RGB format.
@return The colour index.
*/
virtual TInt ColorIndex(TRgb aColor) const = 0;
/**
Returns the RGB value corresponding to the supplied colour index.
Operates in the context of the current display mode.
This is a virtual function that each derived class must implement.
@param aColorIndex
The colour in RGB format.
@return The RGB value.
*/
virtual TRgb Color(TInt aColorIndex) const = 0;
/**
Gets an array of colour indices from a corresponding array of RGB values.
Operates in the context of the current display mode.
This is a virtual function that each derived class must implement.
@param aIndexBuffer
A pointer to the first element in destination array.
@param aColorBuffer
A pointer to the first element in the source array.
@param aCount
The number of elements to get.
*/
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const = 0;
inline static TInt RgbToMonochrome(TRgb aRgb);
};
/**
@publishedAll
@released
Bitmap utility class.
*/
class TImageBitmapUtil
{
public:
IMPORT_C TImageBitmapUtil();
IMPORT_C void Begin();
IMPORT_C TBool Begin(const TPoint& aPosition);
IMPORT_C void End();
IMPORT_C void SetBitmapL(CFbsBitmap* aBitmap);
IMPORT_C void SetPixel(TUint32 aPixelIndex);
IMPORT_C void SetPixels(TUint32* aPixelIndex,TInt aNumberOfPixels);
IMPORT_C TBool SetPos(const TPoint& aPosition);
private:
union TDataPointer
{
TUint32* iWordPos;
TUint8* iBytePos;
};
private:
CFbsBitmap* iBitmap;
TSize iSize;
TPoint iPosition;
TDataPointer iData;
TDataPointer iBase;
TInt iBpp;
TInt iBppShift;
TInt iPixelShift;
TInt iPixelsPerWord;
TInt iBitShift;
TInt iScanlineWordLength;
TUint32 iMask;
TBool iWordAccess;
};
class CImageProcessor;
class CImageProcessorExtension;
/**
@publishedAll
@released
Utility class providing static factory functions for creating instances of
CImageProcessor derived classes.
*/
class ImageProcessorUtility
{
public:
IMPORT_C static TInt ReductionFactor(const TSize& aOriginalSize,const TSize& aReducedSize);
IMPORT_C static CImageProcessor* NewImageProcessorL(const CFbsBitmap& aBitmap,const TSize& aImageSize,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion);
IMPORT_C static CImageProcessor* NewImageProcessorL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion);
IMPORT_C static CImageProcessorExtension* NewImageProcessorExtensionL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion);
private:
TBool static UseErrorDiffuser(const TDisplayMode& aBitmapDisplayMode, const TDisplayMode& aImageDisplayMode);
TBool static IsMonochrome(const TDisplayMode& aBitmapDisplayMode, const TDisplayMode& aImageDisplayMode);
};
/**
@publishedAll
@released
Interface to image processing classes used by CImageDecoder plugins. This is not a application client API.
*/
class CImageProcessor : public CBase
{
public:
// Setup
/**
Initialises internal data structures prior to conversion.
This is a virtual function that each derived class must implement.
@param aBitmap
A reference to a fully constucted bitmap with the required
display mode and size.
@param aImageRect
The region of the image to convert.
*/
virtual void PrepareL(CFbsBitmap& aBitmap,const TRect& aImageRect) = 0;
/**
Initialises internal data structures prior to the manipulation of the specified pixel block.
This overloaded version allows specification of a block size
for those formats which support blocked pixel data eg. JPEG
This is a virtual function that each derived class must implement.
@param aBitmap
A reference to a fully constucted bitmap with the required
display mode and size.
@param aImageRect
The region of the image to convert.
@param aRgbBlockSize
The size of the block to use.
*/
virtual void PrepareL(CFbsBitmap& aBitmap,const TRect& aImageRect,const TSize& aRgbBlockSize) = 0;
/**
Sets the number of pixels by which to increment the current position in
the Y-axis. This is used when rendering images supporting interlacing.
eg GIF
This is a virtual function that each derived class must implement.
@param aYInc
The number of pixels.
*/
virtual void SetYPosIncrement(TInt aYInc) = 0;
/**
Sets the number times the current line should be repeated. The lines
are repeated in the same direction as set by SetYPosIncrement(). This
is used to fill blank lines when rendering interlaced images. eg GIF.
@param aLineRepeat The number of times the current line should be repeated
*/
virtual void SetLineRepeat(TInt aLineRepeat) = 0;
/**
Sets the pixel padding to the value specified by aNumberOfPixels.
This is a virtual function that each derived class must implement.
@param aNumberOfPixels
The number of pixels to use for padding.
*/
virtual void SetPixelPadding(TInt aNumberOfPixels) = 0;
// Color pixel writing
/**
Sets the pixel at the current position to aColor.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@param aColor
The RGB value to set the current pixel to.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetPixel(TRgb aColor) = 0;
/**
Sets aCount number of pixels to the value given by aColor, starting at
the current position.
This is a virtual function that each derived class must implement.
@post
On success, the current position is updated.
@param aColor
The RGB value to set the pixels to.
@param aCount
The number of pixels to set.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetPixelRun(TRgb aColor,TInt aCount) = 0;
/**
Updates the bitmap with colour information from the array of colour values.
Uses the array of colour values supplied by aColorBuffer, whose length
is specified by aBufferLength, to update successive pixels with values in the
buffer, starting at the current position.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@param aColorBuffer
A pointer to the first element in the array.
@param aBufferLength
The number of elements in the array.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetPixels(TRgb* aColorBuffer,TInt aBufferLength) = 0;
/**
Sets the current pixel block using the data supplied in aColorBuffer.
Note:
For use with image types that support blocking of pixels eg JPEG.
This is a virtual function that each derived class must implement.
@param aColorBuffer
A pointer to a buffer representing a block of pixel color values.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetPixelBlock(TRgb* aColorBuffer) = 0;
// Monochrome pixel writing
/**
Sets the pixel at the current position to aGray256.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@param aGray256
The greyscale value to set the current pixel to.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetMonoPixel(TInt aGray256) = 0;
/**
Sets the number of pixels specified by aCount to the value given by aGray256, starting at
the current position.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@param aGray256
The greyscale value to set the pixels to.
@param aCount
The number of pixels to set.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetMonoPixelRun(TInt aGray256,TInt aCount) = 0;
/**
Updates the bitmap with greyscale information from the array of greyscale values.
The array of values supplied by aGray256Buffer, whose length
is specified in aBufferLength, is used to update successive pixels with the
greyscales values.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@param aGray256Buffer
A pointer to the first element in the array of greyscale values.
@param aBufferLength
The number of elements in the array.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetMonoPixels(TUint32* aGray256Buffer,TInt aBufferLength) = 0;
/**
Sets a specified number of pixels to the specified greyscale value.
For image types which support blocking of pixels eg JPEG, the current
pixel block is set using the data supplied in aGray256Buffer.
This is a virtual function that each derived class must implement.
@param aGray256Buffer
A pointer to a buffer representing a block of pixel color values.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetMonoPixelBlock(TUint32* aGray256Buffer) = 0;
// Processor flow control
/**
Sets the current position in the bitmap to aPosition.
This is a virtual function that each derived class must implement.
@param aPosition
A reference to TPoint object defining the position to move to.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool SetPos(const TPoint& aPosition) = 0;
/**
Commits the changes made to the current bitmap by flushing the buffer.
This is a virtual function that each derived class must implement.
@post
The current position is updated.
@return A boolean indicating if the operation was successful. ETrue if the operation succeeded,
otherwise EFalse.
*/
virtual TBool FlushPixels() = 0;
private:
// Future proofing
IMPORT_C virtual void ReservedVirtual1();
IMPORT_C virtual void ReservedVirtual2();
IMPORT_C virtual void ReservedVirtual3();
IMPORT_C virtual void ReservedVirtual4();
};
/**
@publishedAll
@released
Flag used to determine the type of transformation which is the result of
single or multiple transformation operations requested via calls to
COperationExtension::AddOperationL.
8 unique orientations:
@code
normal 90 180 270
00 10 01 00 11 01 10 11
01 11 11 10 10 00 00 01
V flip 90 180 270
10 00 11 10 =Hflip =Hflip+90
11 01 01 00
H flip 90 180 270
01 11 00 01 =Vflip =Vflip+90
00 10 10 11
@endcode
@see COperationExtension::AddOperationL
*/
enum TTransformOptions
{
/** Normal Decode
*/
EDecodeNormal = 0x11011000,
/** Rotate 90 degrees.
*/
EDecodeRotate90 = 0x10110001,
/** Rotate 180 degrees.
*/
EDecodeRotate180 = 0x00100111,
/** Rotate 270 degrees.
*/
EDecodeRotate270 = 0x01001110,
/** Horizontal flip.
*/
EDecodeHorizontalFlip = 0x10001101,
/** Horizontal flip and rotate 90 degrees.
*/
EDecodeHorizontalFlipRotate90 = 0x11100100,
/** Vertical flip.
*/
EDecodeVerticalFlip = 0x01110010,
/** Vertical flip and rotate 90 degrees.
*/
EDecodeVerticalFlipRotate90 = 0x00011011
};
/**
@publishedAll
@released
Class that provides support for Framework Extensions.
@see CImageProcessor
@see CImageReadCodec
@see CImageDecoderPlugin
*/
class CImageProcessorExtension : public CImageProcessor
{
public:
IMPORT_C virtual ~CImageProcessorExtension();
IMPORT_C void SetClippingRect(const TRect& aRect);
IMPORT_C void SetScaling(TInt aScalingCoeff);
IMPORT_C void SetScaling(const TSize& aDesiredSize);
IMPORT_C void SetOperation(TTransformOptions aOperation);
IMPORT_C void SetInitialScanlineSkipPadding(TInt aNumberOfScanlines);
protected:
IMPORT_C CImageProcessorExtension();
protected:
/** Clipping rectangle */
TRect iClippingRect;
/** Scaling coefficient */
TInt iScalingCoeff;
/** Desired size after scaling */
TSize iDesiredSize;
/** Operations to apply to image */
TTransformOptions iOperation;
/** Position in destination at which start rendering */
TPoint iStartPosition;
/** Position in destination at which rendering is complete */
TPoint iEndPosition;
/** An initial one-off number of scanlines to be skipped */
TInt iNumberOfScanlinesToSkip;
};
inline TInt TColorConvertor::RgbToMonochrome(TRgb aRgb)
{
TInt value = aRgb.Internal();
TInt r = value&0xFF0000;
TInt g = value&0xFF00;
value = (value&0xFF)<<16; // blue<<16
value += r<<1; // + (red<<16)*2
value += g<<(16+2-8); // + (green<<16)*4
value += g<<(16+0-8); // + (green<<16)
return value>>(16+3); // total/8
}
#endif //___IMAGEPROCESSOR_H__