/*
* 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:
* Implementation of class CYuv2Rgb12.
* YUV to EColor4K colorspace converter concrete classes.
*
*/
/*
-----------------------------------------------------------------------------
DESCRIPTION
-----------------------------------------------------------------------------
*/
// EXTERNAL RESOURCES
// Include Files
#include <e32math.h>
#include "yuvconverter.h"
#include "yuv2rgb12.h"
#include "brightnesscontrast.h"
// MEMBER FUNCTIONS
//=============================================================================
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
CYuv2Rgb12()
Standard C++ constructor
-----------------------------------------------------------------------------
*/
CYuv2Rgb12::CYuv2Rgb12()
{
iRgbLookupTable = 0;
iGamma = 65536;
iBrightnessContrast = KMedBrightnessContrastIndex;
}
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
~CYuv2Rgb12()
Standard C++ destructor
-----------------------------------------------------------------------------
*/
CYuv2Rgb12::~CYuv2Rgb12()
{
User::Free(iRgbLookupTable);
}
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
ConstructL()
Standard Symbian OS second-phase constructor. Initializes the object.
-----------------------------------------------------------------------------
*/
void CYuv2Rgb12::ConstructL(TUint aWidth, TUint aHeight, TUint aMaxWidth, TUint aMaxHeight)
{
// Remember the dimensions
// __ASSERT_ALWAYS(((aWidth & 3) == 0) && ((aHeight & 3) == 0),
// User::Leave(KErrArgument));
iWidth = aWidth;
iHeight = aHeight;
if ( iWidth > aMaxWidth ) {
iCropWidth = (iWidth-aMaxWidth)/2;
iWidth = aMaxWidth;
}
else {
iCropWidth = 0;
}
if ( iHeight > aMaxHeight ) {
iCropHeight = (iHeight-aMaxHeight)/2;
iHeight = aMaxHeight;
}
else {
iCropHeight = 0;
}
// Allocate the RGB saturate/gamma lookup table
iRgbLookupTable = (TUint8*) User::AllocL(ESaturateLength);
// Initialize brightness & contrast value, this will calculate the conversion table
// Since this uses the median index, it makes no difference if the preferred
// enhancement is this or gamma. Furthermore, changes to the value will be done using
// the appropriate method.
SetBrightnessContrast(KMaxBCInputIndex/2);
}
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
SetGamma()
Sets the conversion gamma value and recalculates the look-up table
Please use the SetBrightnessContrast method for Series 60 display
-----------------------------------------------------------------------------
*/
void CYuv2Rgb12::SetGamma(TInt aGamma)
{
TInt i, v;
TReal vNorm;
// Remember gamma and convert it to floating point
iGamma = aGamma;
TReal fGamma = TReal(iGamma) / TReal(65536);
// Calculate table entries for all possible RGB values:
for ( i = 0; i < ESaturateLength; i++ )
{
// Actual RGB value for this table index
v = 298 * (i - ESaturateOffset - 16) / 256;
// (see Convert())
// Saturate if <0 or >255, otherwise calculate gamma
if ( v < 0 )
v = 0;
else if ( v > 255 )
v = 255;
else
{
// Normalize v:
vNorm = TReal(v) / TReal(255);
// Gamma-correct: v = v ^ gamma
Math::Pow(vNorm, vNorm, fGamma);
// Scale back to [0..255] and clamp:
vNorm = (TReal(255) * vNorm) + 0.5;
v = (TInt) vNorm;
if ( v < 0 ) v = 0;
if ( v > 255 ) v = 255;
}
// 12bpp RGB has range [0..15] for all components, store to table:
iRgbLookupTable[i] = (TUint8) (v >> 4);
}
}
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
SetBrightnessContrast()
Sets the index to the predefined brightness&contrast lookup table
(KBrightnessContrastEnhParam) and recalculates the RGB look-up table
The algorithm was developed by IMAAMI for Kenny display.
-----------------------------------------------------------------------------
*/
void CYuv2Rgb12::SetBrightnessContrast(TInt aBCIndex)
{
TInt i, v;
TReal vNorm;
// Convert & remember brightness-contrast index. aBCIndex == 0 to KMaxBCInputIndex.
iBrightnessContrast = (aBCIndex*KMaxBrightnessContrastIndex)/KMaxBCInputIndex;
// Calculate table entries for all possible RGB values:
for ( i = 0; i < ESaturateLength; i++ )
{
// Actual RGB value for this table index
v = 298 * (i - ESaturateOffset - 16) / 256;
// (see Convert())
// Saturate if <0 or >255, otherwise calculate value
if ( v < 0 )
v = 0;
else if ( v > 255 )
v = 255;
else
{
// Normalize v:
vNorm = TReal(v) / TReal(255);
vNorm = KBrightnessContrastEnhParam[iBrightnessContrast].a * vNorm + KBrightnessContrastEnhParam[iBrightnessContrast].b;
if ( vNorm < 0 )
vNorm = 0;
else if ( vNorm > 1 )
vNorm = 1;
Math::Pow( vNorm, vNorm, KBrightnessContrastEnhParam[iBrightnessContrast].g );
// Scale back to [0..255] and clamp:
vNorm = (TReal(255) * vNorm) + 0.5;
v = (TInt) vNorm;
if ( v < 0 ) v = 0;
if ( v > 255 ) v = 255;
}
// 12bpp RGB has range [0..15] for all components, store to table:
iRgbLookupTable[i] = (TUint8) (v >> 4);
}
}
/*
-----------------------------------------------------------------------------
CYuv2Rgb12
Convert()
Converts a YUV frame to a ERgb12 frame
-----------------------------------------------------------------------------
*/
void CYuv2Rgb12::Convert(const TUint8 *aYBuf, const TUint8 *aUBuf,
const TUint8 *aVBuf,
TUint aBufWidth, TUint aBufHeight,
TUint8 *aTarget, TUint aTargetScanlineLength)
{
TUint cols;
TUint rows = iHeight;
TUint8 *target;
TUint8 *target2;
const TUint8 *yb, *yb2;
TInt y;
TInt uval, vval;
TUint8 val;
TUint8 *rgbLookup = iRgbLookupTable + ESaturateOffset;
TUint8 *rLookup, *gLookup, *bLookup;
__ASSERT_ALWAYS((aBufWidth >= iWidth) && (aBufHeight >= iHeight),
User::Invariant());
// cropping needed?
if ( iCropWidth > 0 ) {
// sets offset to buffers; from now on increments below will always result
// the same offset, since the increment is aBufWidth
aYBuf += iCropWidth;
aUBuf += iCropWidth/2;
aVBuf += iCropWidth/2;
}
if ( iCropHeight > 0 ) {
// skip lines on top
aYBuf += iCropHeight*aBufWidth;
aUBuf += (iCropHeight/2)*aBufWidth/2;
aVBuf += (iCropHeight/2)*aBufWidth/2;
}
// We don't interpolate the chrominance values at all, since that way we
// can save a lot of multiplications. This actually doesn't affect the
// subjective picture quality much, if at all, with natural images.
// Conversion is done 2x2 pixels at a time
// Luminance-only conversion?
if ( (aUBuf != NULL) && (aVBuf != NULL) )
{
// Full conversion
// Convert all rows, two at a time
while ( rows )
{
// Convert all pixels in this row, two at a time
cols = iWidth;
target = aTarget;
target2 = aTarget + aTargetScanlineLength;
yb = aYBuf;
yb2 = aYBuf + aBufWidth;
while ( cols )
{
// Traditional conversion:
// R = 1.1643828125 * (Y-16) + 1.59602734375 * (Cr-128)
// G = 1.1643828125 * (Y-16) + -0.39178515625 * (Cb-128) + -0.81296875 * (Cr-128)
// B = 1.1643828125 * (Y-16) + 2.01723046875 * (Cb-128)
// =>
// R = 1.1643828125 * (Y - 16 + 1.370706718285 * (Cr-128))
// G = 1.1643828125 * (Y - 16 + -0.336474527143 * (Cb-128) + -0.6981971 * (Cr-128))
// B = 1.1643828125 * (Y - 16 + 1.732446105434 * (Cb-128))
// We'll create a lookup-table for 1.1643828125 * (x - 16). The
// range needs go from -222 to 476 plus room for dithering.
// Component lookups based on chrominance values for this 2x2
// block
vval = ((TInt) aVBuf[0]) - 128;
//verified: shift to right is arithmetic in ARM-GCC => shifting of signed values is allowed
rLookup = &rgbLookup[(351 * vval) >> 8];
uval = ((TInt) aUBuf[0]) - 128;
gLookup = &rgbLookup[(-86*uval - 179*vval) >> 8];
bLookup = &rgbLookup[(444 * uval) >> 8];
// Bitmap format: ggggbbbb xxxxrrrr
// Upper left pixel
y = yb[0];
target[0] = (TUint8) ((gLookup[y] << 4) | bLookup[y]);
target[1] = rLookup[y];
// Upper right pixel
y = yb[1] + 8;
target[2] = (TUint8) ((gLookup[y] << 4) | bLookup[y]);
target[3] = rLookup[y];
// Lower left:
y = yb2[0] + 12;
target2[0] = (TUint8) ((gLookup[y] << 4) | bLookup[y]);
target2[1] = rLookup[y];
// Lower right:
y = yb2[1] + 4;
target2[2] = (TUint8) ((gLookup[y] << 4) | bLookup[y]);
target2[3] = rLookup[y];
// Next two pixels:
target += 4;
target2 += 4;
yb += 2;
yb2 += 2;
aUBuf++;
aVBuf++;
cols -= 2;
}
// Next rows
rows -= 2;
aYBuf += 2*aBufWidth;
aUBuf += (aBufWidth - iWidth)/2;
aVBuf += (aBufWidth - iWidth)/2;
aTarget += 2*aTargetScanlineLength;
}
}
else
{
// No chrominance given, do a luminance-only conversion
// Convert all rows, two at a time
while ( rows )
{
// Convert all pixels in this row, two at a time
cols = iWidth;
target = aTarget;
target2 = aTarget + aTargetScanlineLength;
yb = aYBuf;
yb2 = aYBuf + aBufWidth;
while ( cols )
{
// Upper left:
val = rgbLookup[yb[0]];
target[0] = (TUint8) ((val << 4) | val);
target[1] = val;
// Upper right:
val = rgbLookup[yb[1] + 8];
target[2] = (TUint8) ((val << 4) | val);
target[3] = val;
// Lower left:
val = rgbLookup[yb[0] + 12];
target2[0] = (TUint8) ((val << 4) | val);
target2[1] = val;
// Lower right:
val = rgbLookup[yb[1] + 4];
target2[2] = (TUint8) ((val << 4) | val);
target2[3] = val;
// Next two pixels:
target += 4;
target2 += 4;
yb += 2;
yb2 += 2;
cols -= 2;
}
// Next row
rows -= 2;
aYBuf += aBufWidth;
aTarget += aTargetScanlineLength;
}
}
}
// End of File