diff -r 000000000000 -r 5752a19fdefe imaging/imagingfws/src/ImageProcessorUtil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imaging/imagingfws/src/ImageProcessorUtil.cpp Wed Aug 25 12:29:52 2010 +0300 @@ -0,0 +1,364 @@ +// Copyright (c) 1999-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: +// + +#include +#include "ImageProcessorPriv.h" +#include "ImageUtils.h" +#include "ImageClientMain.h" + +// +// ImageProcessorUtility +// + +/** +Static function to calculate a reduction factor based on the input parameters. +This function is deprecated. It is recommended to use CImageDecoder::ReductionFactor or CImageReadCodec::ReductionFactor(for Plugin writers only) to calculate +the reduction factor and then use CImageDecoder::ReducedSize to find the size of the decoded bitmap. + +@param aOriginalSize + A reference to the original size of an item. +@param aReducedSize + A reference to the new size of an item. +@deprecated - Replaced by CImageDecoder::ReductionFactor +@return The reduction factor. + +@see CImageDecoder::ReductionFactor +@see CImageDecoder::ReducedSize +@see CImageReadCodec::ReductionFactor +*/ +EXPORT_C TInt ImageProcessorUtility::ReductionFactor(const TSize& aOriginalSize,const TSize& aReducedSize) + { + if( (aReducedSize.iWidth<=0) || (aReducedSize.iHeight<=0)) + return 0; + + TInt reductionFactor = 0; + + while( ((aOriginalSize.iWidth-1)>>reductionFactor) >= aReducedSize.iWidth || ((aOriginalSize.iHeight-1)>>reductionFactor) >= aReducedSize.iHeight) + reductionFactor++; + + return reductionFactor; + } + + +/** +Static factory function for creating instances of CImageProcessor derived classes. +This fuction is deprecated. It is recommended for plugin writers to use default implementation of CImageReadCodec::ReductionFactor to calculate the +reduction factor and then use NewImageProcessorL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) + +@param aBitmap + A reference to the bitmap used. +@param aImageSize + The size of image to use. +@param aImageDisplayMode + The display mode to use. +@param aDisableErrorDiffusion + A flag indicating whether error diffusion should be disabled. +@deprecated - Replaced by CImageReadCodec::ReductionFactor & NewImageProcessorL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) +@return A pointer to a fully constructed CImageProcessor derived object. + +@see CImageReadCodec::ReductionFactor +@see ImageProcessorUtility::NewImageProcessorL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) +*/ +EXPORT_C CImageProcessor* ImageProcessorUtility::NewImageProcessorL(const CFbsBitmap& aBitmap,const TSize& aImageSize,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) + { + TInt reductionFactor = ImageProcessorUtility::ReductionFactor(aImageSize,aBitmap.SizeInPixels()); + return NewImageProcessorL(aBitmap,reductionFactor, aImageDisplayMode, aDisableErrorDiffusion); + } + +/** +Static factory function for creating instances of CImageProcessor derived classes. + +@param aBitmap + A reference to the bitmap used. +@param aReductionFactor + The value indicating how much to shrink the bitmap. +@param aImageDisplayMode + The display mode to use. +@param aDisableErrorDiffusion + A flag indicating whether error diffusion should be disabled. + +@return A pointer to a fully constructed CImageProcessor derived object. +*/ +EXPORT_C CImageProcessor* ImageProcessorUtility::NewImageProcessorL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) + { + TBool useErrorDiffuser = EFalse; + if(!aDisableErrorDiffusion) + { + useErrorDiffuser = ImageProcessorUtility::UseErrorDiffuser(aBitmap.DisplayMode(), aImageDisplayMode); + } + + TBool monochrome = ImageProcessorUtility::IsMonochrome(aBitmap.DisplayMode(), aImageDisplayMode); + + CImageProcessorExtension* imageProcessor = NULL; + + if(monochrome) + { + if(useErrorDiffuser) + { + imageProcessor = CMonochromeErrorDiffuser::NewL(); + } + else + { + imageProcessor = CMonochromePixelWriter::NewL(); + } + } + else + { + if(useErrorDiffuser) + { + imageProcessor = CErrorDiffuser::NewL(); + } + else + { + imageProcessor = CPixelWriter::NewL(); + } + } + + if(aReductionFactor) + { + CleanupStack::PushL(imageProcessor); + + if(monochrome) + { + imageProcessor = CMonochromeThumbnailProcessor::NewL(imageProcessor,aReductionFactor); + } + else + { + imageProcessor = CThumbnailProcessor::NewL(imageProcessor,aReductionFactor); + } + + CleanupStack::Pop(); + } + + return imageProcessor; + } + +/** +@publishedAll +@released + +Static factory function for creating instances of CImageProcessorExtension derived classes. + +@param aBitmap + A reference to the bitmap used. +@param aReductionFactor + The value indicating how much to shrink the bitmap. +@param aImageDisplayMode + The display mode to use. +@param aDisableErrorDiffusion + A flag indicating whether error diffusion should be disabled. + +@return A pointer to a fully constructed CImageProcessorExtension derived object. +*/ +EXPORT_C CImageProcessorExtension* ImageProcessorUtility::NewImageProcessorExtensionL(const CFbsBitmap& aBitmap,TInt aReductionFactor,TDisplayMode aImageDisplayMode, TBool aDisableErrorDiffusion) + { + TBool useErrorDiffuser = EFalse; + if(!aDisableErrorDiffusion) + { + useErrorDiffuser = ImageProcessorUtility::UseErrorDiffuser(aBitmap.DisplayMode(), aImageDisplayMode); + } + + TBool monochrome = ImageProcessorUtility::IsMonochrome(aBitmap.DisplayMode(), aImageDisplayMode); + + CImageProcessorExtension* imageProcessor = NULL; + + if(monochrome) + { + if(useErrorDiffuser) + { + imageProcessor = CMonochromeErrorDiffuser::NewL(); + } + else + { + imageProcessor = CMonochromePixelWriter::NewL(); + } + } + else + { + if(useErrorDiffuser) + { + imageProcessor = CErrorDiffuser::NewL(); + } + else + { + imageProcessor = CPixelWriter::NewL(); + } + } + + if(aReductionFactor) + { + CleanupStack::PushL(imageProcessor); + + if(monochrome) + { + imageProcessor = CMonochromeThumbnailProcessor::NewL(imageProcessor,aReductionFactor); + } + else + { + imageProcessor = CThumbnailProcessor::NewL(imageProcessor,aReductionFactor); + } + + CleanupStack::Pop(); + } + + return imageProcessor; + } + +/** +Private static funcion to determine whether an error diffusing image processor is to be created. +*/ +TBool ImageProcessorUtility::UseErrorDiffuser(const TDisplayMode& aBitmapDisplayMode, const TDisplayMode& aImageDisplayMode) + { + TBool useErrorDiffuser = EFalse; + + if((aBitmapDisplayMode != EGray256) && + (aBitmapDisplayMode != EColor16M) && + (aBitmapDisplayMode != ERgb) && + (aBitmapDisplayMode != EColor16MU) && + (aBitmapDisplayMode != EColor16MA)) + { + switch(aImageDisplayMode) + { + case EGray2: + break; + + case EGray4: + if(aBitmapDisplayMode < aImageDisplayMode) + { + useErrorDiffuser = ETrue; + } + break; + + case EGray16: + if((aBitmapDisplayMode < aImageDisplayMode)||(aBitmapDisplayMode == EColor16)) + { + useErrorDiffuser = ETrue; + } + break; + + case EGray256: + useErrorDiffuser = ETrue; + break; + + case EColor16: + if(aBitmapDisplayMode < aImageDisplayMode) + { + useErrorDiffuser = ETrue; + } + break; + + case EColor256: + if(aBitmapDisplayMode < aImageDisplayMode) + { + useErrorDiffuser = ETrue; + } + break; + + case EColor64K: + if(aBitmapDisplayMode == EColor4K) + { + useErrorDiffuser = ETrue; + } + if(aBitmapDisplayMode < aImageDisplayMode) + { + useErrorDiffuser = ETrue; + } + break; + + case EColor16M: + case ERgb: + case EColor16MU: + useErrorDiffuser = ETrue; + break; + + case EColor4K: + if(aBitmapDisplayMode < EColor64K) + { + useErrorDiffuser = ETrue; + } + break; + + default: + break; + } + } + return useErrorDiffuser; + } + +/** +Private static funcion to determine whether a monochrome image processor is to be created. +*/ +TBool ImageProcessorUtility::IsMonochrome(const TDisplayMode& aBitmapDisplayMode, const TDisplayMode& aImageDisplayMode) + { + return aBitmapDisplayMode <= EGray256 || aImageDisplayMode <= EGray256; + } + +/** +Intended for future proofing - will panic if called + +@panic EReservedCall +*/ +EXPORT_C void CImageProcessor::ReservedVirtual1() + { + Panic(EReservedCall); + } + +/** +Intended for future proofing - will panic if called + +@panic EReservedCall +*/ +EXPORT_C void CImageProcessor::ReservedVirtual2() + { + Panic(EReservedCall); + } + +/** +Intended for future proofing - will panic if called + +@panic EReservedCall +*/ +EXPORT_C void CImageProcessor::ReservedVirtual3() + { + Panic(EReservedCall); + } + +/** +Intended for future proofing - will panic if called + +@panic EReservedCall +*/ +EXPORT_C void CImageProcessor::ReservedVirtual4() + { + Panic(EReservedCall); + } + +// +// CErrorDiffuser +// + +/** + * @internalComponent + * Static factory function to create CErrorDiffuser objects. + * + * @return Pointer to a fully constructed CErrorDiffuser object. + */ +//Exported for CBitmapConverter in MediaClientImage +EXPORT_C CErrorDiffuser* CErrorDiffuser::NewL() + { + return new(ELeave) CErrorDiffuser; + } + +