--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/vedengine/GenManip/src/DCIetd.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,519 @@
+/*
+* 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:
+*
+*/
+
+
+//----IMAAMI----
+//*************************************************************************
+//CDCIETD.cpp
+//Version 2.00
+//
+//Contains:
+// CDCIETD
+// Display specific color contrast enhancement,
+// Image Enhancement for Transflective Displays version 2,
+// IETD 2.
+//
+//History:
+// 23.10.2003 version 2.00 created using existing IMAAMI IETD
+//*************************************************************************
+
+// Include Files
+#include <e32std.h> // The basic definitions
+#include <fbs.h> // For FBS bitmap
+#include "DCIetd.h" // The DCIetd class
+
+
+// MEMBER FUNCTIONS
+//=============================================================================
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ Constructor
+
+ Default constructor, initializes member variables to initial values
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+CDCIetd::CDCIetd()
+{
+ // Set default values for parameters (from init file)
+ iParameters.aWhitePixels = WhitePixels;
+ iParameters.aBlackPixels = BlackPixels;
+ iParameters.aStretchLimit = StretchLimit;
+ iParameters.aSaturationGain = SaturationGain;
+ iParameters.aBitLimit = BitLimit;
+ iParameters.aWBC = WBC;
+ iParameters.aDBC = DBC;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ NewLC
+
+ Factory function to instantiate the class.
+ This function leaves the class pointer to the cleanup stack
+ May leave with KErrNoMemory if no memory available
+
+ Return Values: CDCIetd* self: pointer to the class instance
+
+-----------------------------------------------------------------------------
+*/
+CDCIetd* CDCIetd::NewLC()
+{
+ CDCIetd* self = new (ELeave) CDCIetd();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ NewL
+
+ Factory function to instantiate the class.
+ May leave with KErrNoMemory if no memory available
+
+ Return Values: CDCIetd* self: pointer to the class instance
+
+-----------------------------------------------------------------------------
+*/
+CDCIetd* CDCIetd::NewL()
+{
+ CDCIetd* self = CDCIetd::NewLC();
+ CleanupStack::Pop();
+ return self;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ ConstructL
+
+ Second phase constructor. Does nothing at the moment
+
+ Return Values: none
+
+ -----------------------------------------------------------------------------
+*/
+void CDCIetd::ConstructL()
+{
+ // This function is intentionally left blank.
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ Destructor
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+CDCIetd::~CDCIetd()
+{
+ // This function is intentionally left blank.
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ Analyze
+
+ Analyze image referenced by aBPtr
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+// Analyze image referenced by aBPtr
+void CDCIetd::Analyze(CFbsBitmap& aBPtr)
+{
+
+ //EColor16M image is needed
+ if (aBPtr.DisplayMode() != EColor16M) return;
+
+ //Do analysis
+ GatherHistograms(aBPtr);
+ MakeMappings();
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ ProcessL
+
+ Process image referenced by aImage (modify aImage).
+ May leave with KErrNoMemory if no memory available
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+void CDCIetd::ProcessL (CFbsBitmap& aImage) // image reference
+{
+ TUint r, g, b; // Color components
+ TUint lum; // Brightness estimate
+ TInt dr, dg, db; // Differences to brightness
+ TUint8* dataPtr; // Pointer to data
+
+ //EColor16M image is needed
+ if (aImage.DisplayMode() != EColor16M) return;
+
+ //Line Buffer and pointer to the data
+ TUint imageWidth = aImage.SizeInPixels().iWidth;
+ TUint scanLineLengthInBytes = aImage.ScanLineLength(imageWidth, aImage.DisplayMode());
+
+ //Allocate buffer for scanline
+ iScanLineBuffer = HBufC8::NewMaxL(scanLineLengthInBytes);
+ //Pointer to scanline
+ TPtr8 linePtr = iScanLineBuffer->Des();
+
+ //Step through image pixels and do stretching
+ //and saturation increase
+ //---------------------------------------------
+
+ //Read all lines
+ for (TInt lineNo=0; lineNo<aImage.SizeInPixels().iHeight; ++lineNo)
+ {
+ //Get line
+ aImage.GetScanLine(linePtr, TPoint(0, lineNo), imageWidth, aImage.DisplayMode());
+ //CHECK! CONST_CAST not used in every algorithm which way is better?
+ dataPtr = CONST_CAST(TUint8*, linePtr.Ptr());
+
+ //Step through pixels in line
+ for (TUint x=0; x < imageWidth; ++x)
+ {
+ // Map color componets according to mapping LUTs
+ b = iMap[2][*dataPtr++];
+ g = iMap[1][*dataPtr++];
+ r = iMap[0][*dataPtr++];
+
+ //Compute brightness estimate
+ //lum=0.299r+0.587g+0.114b; //true Y
+ //lum=(32768+19595*r+38470*g+7471*b)>>16; //Y
+ //lum = (r+g+b)/3; //Simple approximation
+ lum=(r+(g<<1)+b)>>2; //More effective simple approximation
+
+ //Compute componentwise differences to luminance
+ dr = r-lum;
+ dg = g-lum;
+ db = b-lum;
+
+ //Increase differences => saturation increases.
+ //Use gain parameter for adjusting the strength of the effect.
+ b += iParameters.aSaturationGain*db/32;
+ g += iParameters.aSaturationGain*dg/32;
+ r += iParameters.aSaturationGain*dr/32;
+
+ //Save data to same image & same pixels
+ dataPtr -= 3;
+
+ //Limit to available dynamic range [0,255].
+ *dataPtr++ = Limit255(b);
+ *dataPtr++ = Limit255(g);
+ *dataPtr++ = Limit255(r);
+ }
+
+ //Save line
+ aImage.SetScanLine(linePtr, lineNo);
+ }
+
+ //Free memory
+ delete(iScanLineBuffer);
+ iScanLineBuffer = 0;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ GatherHistograms
+
+ Gather histograms and make cumulative histogram.
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+void CDCIetd::GatherHistograms (const CFbsBitmap& aImage) // Pointer to the image bitmap
+{
+ const TUint8* dataPtr; //Pointer to data
+ TInt lineNo; //Line number
+ TUint x; //Pixel index
+ TUint color; //Color index
+ TUint count; // Number of colors in each component
+
+ //Compute image width & allocate scan line memory
+ TUint imageWidth = aImage.SizeInPixels().iWidth;
+ TUint histScanLineLengthInBytes = aImage.ScanLineLength(imageWidth, aImage.DisplayMode());
+ iScanLineBuffer = HBufC8::NewMaxL(histScanLineLengthInBytes);
+
+ //Pointer to line
+ TPtr8 linePtr = iScanLineBuffer->Des();
+
+ //Clear histograms
+ Mem::FillZ(iHistogram, sizeof(iHistogram));
+
+ // Read all lines and gather histograms
+ for (lineNo=0; lineNo<aImage.SizeInPixels().iHeight; lineNo++)
+ {
+ //Get line
+ aImage.GetScanLine(linePtr, TPoint(0, lineNo), imageWidth, aImage.DisplayMode());
+ dataPtr = linePtr.Ptr();
+
+ //Step through pixels
+ for (x=imageWidth; x != 0; --x)
+ {
+ ++iHistogram[2][*dataPtr++]; // Increase Blue bin value
+ ++iHistogram[1][*dataPtr++]; // Increase Green bin value
+ ++iHistogram[0][*dataPtr++]; // Increase Red bin value
+ }
+ }
+
+ //Make cumulative histograms & count colors in each histogram
+ for (color=0; color<3; ++color)
+ {
+ // Count used colors
+ count=0;
+ for (x=0; x<256; ++x)
+ {
+ if (iHistogram[color][x]>0) count++;
+ }
+
+ // Compute increased stretch limit if a color component has less colors than iBitLimit.
+ // Otherwise use predetermined stretch limit.
+ if (count<iParameters.aBitLimit)
+ iReducedStretchLimit[color] = (TUint8)(iParameters.aStretchLimit*count/iParameters.aBitLimit+255-255*count/iParameters.aBitLimit);
+ else
+ iReducedStretchLimit[color] = iParameters.aStretchLimit;
+
+ //Make cumulative histogram
+ for (x=1; x<256; ++x)
+ iHistogram[color][x] += iHistogram[color][x-1];
+
+ }
+
+ //Free memory
+ delete(iScanLineBuffer);
+ iScanLineBuffer = 0;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ MakeMappings
+
+ Make mapping function look-up table (LUT).
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+void CDCIetd::MakeMappings()
+{
+ TInt MinBins[3];// Smallest existing values in histogram
+ TInt MaxBins[3];// Largest existing values in histogram
+ TUint minBin; // Minimum of smallest existing values
+ TUint maxBin; // Maximum of largest existing values
+ TUint x; // Index
+
+ // Stretching limit variables
+ TUint minShift;
+ TUint maxShift;
+ TUint totalShift;
+
+ TUint color; //Color index
+
+ //Step through colors
+ for (color=0; color<3; ++color)
+ {
+ // Find smallest existing values in histograms, discard darkest pixels
+ // according to blackpixels parameter
+ x = 0; // Start from fist bin
+ MinBins[color] = iParameters.aBlackPixels * iHistogram[color][255]/1000; // Compute value to be found
+ while (x < 255 && (TUint)iHistogram[color][x] < MinBins[color])
+ ++x; // Find from histogram
+
+ MinBins[color] = x; // Save bin index = start of stretching part of LUT
+
+ // Find largest existing values in histograms, discard brightest pixels
+ // according to whitepixels parameter
+ x = 255; // Start from last bin
+ //Compute value to be found
+ MaxBins[color] = iHistogram[color][255] - iParameters.aWhitePixels * iHistogram[color][255]/1000;
+ while (x > 0 && (TUint)iHistogram[color][x] > MaxBins[color])
+ --x; // Find from histogram
+
+ MaxBins[color] = x; // Save bin index = end of stretching part of LUT
+ }
+
+ //Find minimum of all colors
+ minBin=255;
+ for (color=0; color<3; color++)
+ {
+ if (minBin>MinBins[color]) minBin=MinBins[color];
+ }
+
+ //Find maximum of all colors
+ maxBin=0;
+ for (color=0; color<3; color++)
+ {
+ if (maxBin<MaxBins[color]) maxBin=MaxBins[color];
+ }
+
+ //Adjust white and dark balance within limits given in parameters (maximum correction).
+ //0 means that largest(or smallest) of all values is used => no WBC(or DBC).
+ for (color=0; color<3; color++)
+ {
+ if(maxBin-MaxBins[color]>iParameters.aWBC) MaxBins[color]=maxBin-iParameters.aWBC;
+ if((MinBins[color]-minBin) > iParameters.aDBC) MinBins[color]=minBin+iParameters.aDBC;
+ }
+
+ //Step through color components
+ for (color=0; color<3; color++)
+ {
+ // If histogram has only one nonzero bin maxBin can be less than minBin.
+ // In that case change maxBin value to minBin.
+ if(MaxBins[color]<MinBins[color]) MaxBins[color]=MinBins[color];
+
+ // Limit stretching to narrovest histogram that can be stretched
+ if (MaxBins[color]-MinBins[color] < iReducedStretchLimit[color])
+ {
+ // Compute limiting shifts to measured values.
+ // Compute shifts for dark and bright end in relation
+ // to coresponding available space in dynamic range.
+ totalShift = iReducedStretchLimit[color]-(MaxBins[color]-MinBins[color]);
+ maxShift = totalShift*(255-MaxBins[color])/(255-(MaxBins[color]-MinBins[color]));
+ minShift = totalShift*MinBins[color]/(255-(MaxBins[color]-MinBins[color]));
+
+ // Shift measured values, so that stretching is limited
+ MinBins[color] -= minShift;
+ MaxBins[color] += maxShift;
+
+ // Check that dynamic range is not exceeded
+ // (Should happen only with faulty parameter values)
+ if (MinBins[color]<0)
+ MinBins[color]=0;
+ if (MaxBins[color]>255)
+ MaxBins[color]=255;
+ }
+
+ // Set 0 mapping part of the LUT
+ for (x=0; x<=MinBins[color]; ++x)
+ iMap[color][x] = 0;
+
+ // Set 255 mapping part of the LUT
+ for (x=MaxBins[color]; x<=255; ++x)
+ iMap[color][x] = 255;
+
+ // Compute linear stretching part of the LUT
+ for (x=MinBins[color]+1; x<MaxBins[color]; x++)
+ iMap[color][x] = (TUint8)(255*(x-MinBins[color])/(MaxBins[color]-MinBins[color]));
+ }
+}
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ SetParams
+
+ Set processing parameters
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+void CDCIetd::SetParams(DCIetdParameters* params)
+{
+ iParameters = *params;
+}
+
+
+
+
+/*
+-----------------------------------------------------------------------------
+
+ CDCIetd
+
+ GetParams
+
+ Get current processing parameters
+
+ Return Values: none
+
+-----------------------------------------------------------------------------
+*/
+void CDCIetd::GetParams(DCIetdParameters* params)
+{
+ *params = iParameters;
+}
+//----IMAAMI----