/*

* 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 CYuv2Rgb24.

* YUV to EColor16M colorspace converter concrete classes. 

*

*/

//  EXTERNAL RESOURCES  

//  Include Files  

#include <e32math.h>

#include "yuvconverter.h"

#include "yuv2rgb24.h"

#include "brightnesscontrast.h"

//  MEMBER FUNCTIONS

//=============================================================================

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    CYuv2Rgb24()

    Standard C++ constructor

-----------------------------------------------------------------------------

*/

CYuv2Rgb24::CYuv2Rgb24()

{

    iRgbLookupTable = 0;

    iGamma = 65536;

    iBrightnessContrast = KMedBrightnessContrastIndex;

}

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    ~CYuv2Rgb24()

    Standard C++ destructor

-----------------------------------------------------------------------------

*/

CYuv2Rgb24::~CYuv2Rgb24()

{

    User::Free(iRgbLookupTable);

}

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    ConstructL()

    Standard Symbian OS second-phase constructor. Initializes the object.

-----------------------------------------------------------------------------

*/

void CYuv2Rgb24::ConstructL(TUint aWidth, TUint aHeight, TUint aMaxWidth, TUint aMaxHeight)

{

    // Remember the dimensions

//    __ASSERT_ALWAYS(((aWidth & 1) == 0) && ((aHeight & 1) == 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);

}

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    SetGamma()

    Sets the conversion gamma value and recalculates the look-up table

-----------------------------------------------------------------------------

*/

void CYuv2Rgb24::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 = i - ESaturateOffset;

        // 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;

        }

        // 24bpp RGB has range [0..255] for all components, store to table:

        iRgbLookupTable[i] = (TUint8) v;

    }

}

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    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 CYuv2Rgb24::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;

        }

        // 24bpp RGB has range [0..255] for all components, store to table:

        iRgbLookupTable[i] = (TUint8) v;

    }

}

/*

-----------------------------------------------------------------------------

    CYuv2Rgb24

    Convert()

    Converts a YUV frame to a EColor16M frame

-----------------------------------------------------------------------------

*/

void CYuv2Rgb24::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 rc, gc, bc;

    TInt y;

    TInt uval, vval;

    TUint8 val;

    __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 )

            {

                // Charles Poynton: Color FAQ

                // (http://www.inforamp.net/~poynton/ColorFAQ.html)

                // 30. How do I encode Y'CBCR components from computer R'G'B' ?

                // [normalized]

                // 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)

                // We'll use fixed-point with 16 bits of fractional part for

                // accuracy. Besides, 24bpp RGB is not likely to be used in

                // low-CPU devices in the near future...

                // Red chrominance part for this 2x2 block:

                vval = ((TInt) aVBuf[0]) - 128;

                rc =  104597 * vval;

                // Green chrominance:

                uval = ((TInt) aUBuf[0]) - 128;

                gc = -25676*uval - 53279*vval;

                // Blue chrominance:

                bc = 132201 * uval;

                // Upper left pixel y part for all components:

                y = 76309 * (((TInt) yb[0]) - 16) + 32768; // round up

                // Calculate components and store:

                // Bitmap format: bbbbbbbb gggggggg rrrrrrrr

                target[0] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset];

                target[1] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset];

                target[2] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset];

                // Upper right pixel:

                y = 76309 * (((TInt) yb[1]) - 16) + 32768;

                target[3] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset];

                target[4] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset];

                target[5] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset];

                // Lower left:

                y = 76309 * (((TInt) yb2[0]) - 16) + 32768;

                target2[0] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset];

                target2[1] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset];

                target2[2] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset];

                // Lower right:

                y = 76309 * (((TInt) yb2[1]) - 16) + 32768;

                target2[3] = iRgbLookupTable[((y+bc) >> 16) + ESaturateOffset];

                target2[4] = iRgbLookupTable[((y+gc) >> 16) + ESaturateOffset];

                target2[5] = iRgbLookupTable[((y+rc) >> 16) + ESaturateOffset];

                // Next two pixels:

                target += 6;

                target2 += 6;

                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

        while ( rows )

        {

            // Convert all pixels in this row, two at a time

            cols = iWidth;

            target = aTarget;

            while ( cols )

            {

                // Do a pixel:

                y = 76309 * (((TInt) aYBuf[0]) - 16) + 32768;

                val = iRgbLookupTable[(y >> 16) + ESaturateOffset];

                target[0] = val;

                target[1] = val;

                target[2] = val;

                // And another one:

                y = 76309 * (((TInt) aYBuf[1]) - 16) + 32768;

                val = iRgbLookupTable[(y >> 16) + ESaturateOffset];

                target[3] = val;

                target[4] = val;

                target[5] = val;

                // Next two pixels:

                target += 6;

                aYBuf += 2;

                cols -= 2;

            }

            // Next row

            rows--;

            aYBuf += aBufWidth - iWidth;

            aTarget += aTargetScanlineLength;

        }

    }

}

//  End of File