/*

* Copyright (c) 2003, 2004 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:  CJ2kImageWriter class used to perform inverse transformation and

*                writing decoded image data to bitmap.

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <fbs.h>

#include "JP2KImageUtils.h"

#include "JP2KFormat.h"

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KSubband.h"

#include "JP2KComponentInfo.h"

#include "JP2KImageWriter.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

#define INT2BYTE( n ) ( ( n ) < 0 ? (TUint8)0 : ( ( n ) > 255 ? (TUint8)255 : (TUint8)( n ) ) )

#define CLIPINT( n,bitdepth ) ( ( n >= ( 1 << bitdepth ) ) ? ( ( 1<<bitdepth ) - 1 ) : ( n < 0 ) ? 0 : n )

#define CLIP2BITDEPTH( n, maxValue ) ( ( n > maxValue ) ? ( maxValue ) : ( n < 0 ) ? 0 : n )

#define CLIP2RANGE( n, minValue, maxValue ) ( ( n > maxValue ) ? ( maxValue ) : ( n < minValue ) ? minValue : n )

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// LOCAL CONSTANTS AND MACROS

// ============================ MEMBER FUNCTIONS ===============================

// Destructor

CJ2kWriterComponentInfo::~CJ2kWriterComponentInfo()

    {

    iTileStartList.Close();

    FreeData();

    }

// -----------------------------------------------------------------------------

// CJ2kWriterComponentInfo::AllocDataL

// Allocate 2-D data array with a size

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kWriterComponentInfo::AllocDataL( const TSize& aSize )

    {

    FreeData();

    iData = TJ2kUtils::Alloc2DArrayL( aSize.iHeight, aSize.iWidth );

    }

// -----------------------------------------------------------------------------

// CJ2kWriterComponentInfo::FreeData

// Free the 2-D data array

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kWriterComponentInfo::FreeData()

    {

    if ( iData )

        {

        TJ2kUtils::Free2DArray( iData );

        iData = 0;

        }

    }

// -----------------------------------------------------------------------------

// CJ2kWriterComponentInfo::Data

// Get the 2-D data array

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TPrecInt** CJ2kWriterComponentInfo::Data()

    {

    return iData;

    }

// -----------------------------------------------------------------------------

// CJ2kWriterComponentInfo::TileStartAt

// Get the starting point of a tile

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TPoint& CJ2kWriterComponentInfo::TileStartAt( TUint16 aTileIndex )

    {

    return iTileStartList[aTileIndex];

    }

// -----------------------------------------------------------------------------

// CJ2kWriterComponentInfo::UpdateNextTileStartAtL

// Update the starting point of next tile

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kWriterComponentInfo::UpdateNextTileStartAtL( TUint16 aTileIndex, 

                                                     const TSize& aSize,

                                                     CJ2kImageInfo& aImageInfo )

    {

    TUint16 numOfHorizTiles = aImageInfo.NumOfHorizTilesL();

    TUint16 numOfVertTiles  = aImageInfo.NumOfVertTilesL();

    // Calculate the p and q of a tile

    TDiv tDiv = TJ2kUtils::DivL( aTileIndex, numOfHorizTiles );

    if ( tDiv.rem != ( numOfHorizTiles - 1 ) )

        {

        iTileStartList[aTileIndex + 1].iX = iTileStartList[aTileIndex].iX + aSize.iWidth;

        }

    if ( tDiv.quot != ( numOfVertTiles - 1 ) )

        {

        iTileStartList[aTileIndex + numOfHorizTiles].iY = iTileStartList[aTileIndex].iY + aSize.iHeight;

        }

    }

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CJ2kImageWriter::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CJ2kImageWriter* CJ2kImageWriter::NewL( CImageProcessor* aImageProcessor,

                                        CJ2kImageInfo& aImageInfo,

                                        TJ2kInfo& aJ2kInfo )

    {

    CJ2kImageWriter *self = new ( ELeave ) CJ2kImageWriter( aImageProcessor, aImageInfo, aJ2kInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CJ2kImageWriter::~CJ2kImageWriter()

    {

    iComponents.ResetAndDestroy();

    delete iLinearsRGBLut;

    iLinearsRGBLut = 0;

    User::Free( iGrayTRCLut );

    User::Free( iRedTRCLut );

    User::Free( iGreenTRCLut );

    User::Free( iBlueTRCLut ); 

    User::Free( iMonoPixelBlock );

    User::Free( iColorPixelBlock );

    }

// -----------------------------------------------------------------------------

// CJ2kImageWriter::WriterComponentAt

// Get the component of the image writer

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

const CJ2kWriterComponentInfo& CJ2kImageWriter::WriterComponentAt( TUint16 aIndex ) const

    {

    return *iComponents[aIndex];

    }

// -----------------------------------------------------------------------------

// CJ2kImageWriter::OutputImageL

// Output the image related to the component of the tile

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kImageWriter::OutputImageL( CJ2kTileInfo& aTile, TUint16 aComponentIndex )

    {

    TUint8  bitdepth = 0;

    TUint16 c = 0;

    CJ2kComponentInfo& componentInfo = CONST_CAST( CJ2kComponentInfo&, aTile.ComponentAt( aComponentIndex ) );

    TInt16 reducedLevels = (TInt16)( componentInfo.Levels() - iImageInfo.LevelDrop() );

    if ( reducedLevels < 0 )

        {

        reducedLevels = 0;

        }

    CJ2kSubband* subband = CONST_CAST( CJ2kSubband*, componentInfo.SubbandAt( (TUint8)reducedLevels ) );

    if ( subband->SubbandResLevel() != 0 )

        {

        subband = subband->Parent();

        }

    TSize subbandSize = subband->SubbandCanvasSize();

    // Note that in case of component truncation color transform is not performed

    if ( iImageInfo.ComponentDrop() )

        {

        iNumComponents = 1;    

        }

    else  // Only perform color transform if we don't drop components

        {

        // Perform the color transfrom

        if ( aComponentIndex == 2 && aTile.ColorTransformation() )

            {

            // Perform the inverse color transform

            if ( aTile.ComponentAt( 0 ).IsReversible() )  // If RCT is used

                {

                PerformInverseRCT( subbandSize );

                }

            else

                {

                PerformInverseICT( subbandSize );

                }

            }

        }

    // Check if palettes are used. If so, get the number of output channels 

    if ( iJ2kInfo.iCMPList.Count() )

        {

        TUint16 numCSComp = iImageInfo.NumOfComponents();

        // Allocate more memory for data if needed

        if ( iNumComponents > numCSComp )

            {

            for ( c = numCSComp; c < iNumComponents; c++ )

                {

                // Allocate memory for component data

                iComponents[c]->AllocDataL( subbandSize );

                }

            }

        // Check if we have all the necessary channels for component mapping

        if ( aComponentIndex == ( numCSComp - 1 ) )

            {

            MapComponentsL( numCSComp, reducedLevels, subbandSize, aTile );

            }

        }

    // We start the output of files:

    if ( iSingleFileOutput )

        {

        if ( iNumComponents == 3 ) // 3 comp to combine

            {

            // Compute the subbandSize from the first component since others might be downsampled.

            TInt16 tempNumLevels = (TUint16)( aTile.ComponentAt( 0 ).Levels() - iImageInfo.LevelDrop() );

            if ( tempNumLevels < 0 )

                {

                tempNumLevels = 0;

                }

            CJ2kSubband* tempSubband = CONST_CAST( CJ2kSubband*, aTile.ComponentAt( 0 ).SubbandAt( (TUint8)tempNumLevels ) );

            if ( tempSubband->SubbandResLevel() != 0 )

                {

                tempSubband = tempSubband->Parent();

                }

            subbandSize = tempSubband->SubbandCanvasSize();

            if( !iColorPixelBlock )

                {

                // Allocate memory for block of color pixels

                iColorPixelBlock = STATIC_CAST( TRgb*, User::AllocL( 2 * KPixelsBlock * sizeof( TRgb ) ) );

                }

            CombineOutputFileL( aTile, subbandSize );

            for ( c = 0; c < iNumComponents; c++ )

                {

                iComponents[c]->FreeData();

                }

            }

        else // 1 comp to output

            {

            if ( iImageInfo.ComponentDrop() )

                {

                c = ( TUint16 )( iImageInfo.ComponentDrop() - 1 );

                }

            else

                {

                c = aComponentIndex;

                }

            bitdepth = iImageInfo.DepthOfComponent( c );

            if( !iMonoPixelBlock )

                {

                // Allocate memory for block of grayscale pixels

                iMonoPixelBlock = STATIC_CAST( TUint32*, User::AllocL( KPixelsBlock * sizeof( TUint32 ) ) );

                }

            // Output a single component

            WriteOutputFileL( aTile, c, subbandSize, bitdepth );

            iComponents[c]->FreeData();

            }

        }

    else

        {

        // Write out three independent output files

        if( !iMonoPixelBlock )

            {

            // Allocate memory for block of grayscale pixels

            iMonoPixelBlock = STATIC_CAST( TUint32*, User::AllocL( KPixelsBlock * sizeof( TUint32 ) ) );

            }

        if ( aComponentIndex == 2 && aTile.ColorTransformation() )

            {

            for ( c = 0; c < 3; c++ )

                {

                bitdepth = iImageInfo.DepthOfComponent( c );

                // Output single files 

                WriteOutputFileL( aTile, c, subbandSize, bitdepth );

                iComponents[c]->FreeData();

                }

            }

        else if ( iJ2kInfo.iCMPList.Count() )

            {

            for ( c = 0; c < iNumComponents; c++ ) 

                {

                // Bitdepth is the lowest seven bits plus one for palettes

                bitdepth = ( TUint8 )( ( iJ2kInfo.iPalette.iBList[0] & 0x7f )+1 );

                // Output single files 

                WriteOutputFileL( aTile, c, subbandSize, bitdepth );

                iComponents[c]->FreeData();

                }

            }

        else

            {

            bitdepth = iImageInfo.DepthOfComponent( aComponentIndex );

            // Output only the first component to screen

            if( aComponentIndex == 0 )

                {

                WriteOutputFileL( aTile, aComponentIndex, subbandSize, bitdepth );

                }

            iComponents[aComponentIndex]->FreeData();

            }

        }

    }

// -----------------------------------------------------------------------------

// CJ2kImageWriter::OutputImageL

// Output the image related to the component of the tile

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kImageWriter::OutputImageL( CJ2kTileInfo& aTile, TUint16 aComponentIndex,

                                    const TSize& aSize )

    {

    TUint8  bitdepth = 0;

    TUint16 c = 0;

    CJ2kComponentInfo& componentInfo = CONST_CAST( CJ2kComponentInfo&, aTile.ComponentAt( aComponentIndex ) );

    TInt16 reducedLevels = (TInt16)( componentInfo.Levels() - iImageInfo.LevelDrop() );

    if ( reducedLevels < 0 )

        {

        reducedLevels = 0;

        }

    CJ2kSubband* subband = CONST_CAST( CJ2kSubband*, componentInfo.SubbandAt( (TUint8)reducedLevels ) );

    if ( subband->SubbandResLevel() != 0 )

        {

        subband = subband->Parent();

        }

    TSize subbandSize = aSize;

    // Note that in case of component truncation color transform is not performed

    if ( iImageInfo.ComponentDrop() )

        {

        iNumComponents = 1;    

        }

    else  // Only perform color transform if we don't drop components

        {

        // Perform the color transfrom

        if ( aComponentIndex == 2 && aTile.ColorTransformation() )

            {

            // Perform the inverse color transform

            if ( aTile.ComponentAt( 0 ).IsReversible() )  // If RCT is used

                {

                PerformInverseRCT( subbandSize );

                }

            else

                {

                PerformInverseICT( subbandSize );

                }

            }

        }

    // Check if palettes are used. If so, get the number of output channels 

    if ( iJ2kInfo.iCMPList.Count() )

        {

        TUint16 numCSComp = iImageInfo.NumOfComponents();

        // Allocate more memory for data if needed

        if ( iNumComponents > numCSComp )

            {

            for ( c = numCSComp; c < iNumComponents; c++ )

                {

                // Allocate memory for component data

                iComponents[c]->AllocDataL( subbandSize );

                }

            }

        // Check if we have all the necessary channels for component mapping

        if ( aComponentIndex == ( numCSComp - 1 ) )

            {

            MapComponentsL( numCSComp, reducedLevels, subbandSize, aTile );

            }

        }

    // We start the output of files:

    if ( iSingleFileOutput )

        {

        if ( iNumComponents == 3 ) // 3 comp to combine

            {

            if( !iColorPixelBlock )

                {

                // Allocate memory for block of color pixels

                iColorPixelBlock = STATIC_CAST( TRgb*, User::AllocL( 2 * KPixelsBlock * sizeof( TRgb ) ) );

                }

            CombineOutputFileL( aTile, subbandSize );

            for ( c = 0; c < iNumComponents; c++ )

                {

                iComponents[c]->FreeData();

                }

            }

        else // 1 comp to output

            {

            if ( iImageInfo.ComponentDrop() )

                {

                c = (TUint16)( iImageInfo.ComponentDrop() - 1 );

                }

            else

                {

                c = aComponentIndex;

                }

            bitdepth = iImageInfo.DepthOfComponent( c );

            if( !iMonoPixelBlock )

                {

                // Allocate memory for block of grayscale pixels

                iMonoPixelBlock = STATIC_CAST( TUint32*, User::AllocL( KPixelsBlock * sizeof( TUint32 ) ) );

                }

            // Output a single component

            WriteOutputFileL( aTile, c, subbandSize, bitdepth );

            iComponents[c]->FreeData();

            }

        }

    else

        {

        // Write out three independent output files

        if( !iMonoPixelBlock )

            {

            // Allocate memory for block of grayscale pixels

            iMonoPixelBlock = STATIC_CAST( TUint32*, User::AllocL( KPixelsBlock * sizeof( TUint32 ) ) );

            }

        if ( aComponentIndex == 2 && aTile.ColorTransformation() )

            {

            for ( c = 0; c < 3; c++ )

                {

                bitdepth = iImageInfo.DepthOfComponent( c );

                // Output single files 

                WriteOutputFileL( aTile, c, subbandSize, bitdepth );

                iComponents[c]->FreeData();

                }

            }

        else if ( iJ2kInfo.iCMPList.Count() )

            {

            for ( c = 0; c < iNumComponents; c++ ) 

                {

                // Bitdepth is the lowest seven bits plus one for palettes

                bitdepth = (TUint8)( ( iJ2kInfo.iPalette.iBList[0] & 0x7f )+1 );

                // Output single files 

                WriteOutputFileL( aTile, c, subbandSize, bitdepth );

                iComponents[c]->FreeData();

                }

            }

        else

            {

            bitdepth = iImageInfo.DepthOfComponent( aComponentIndex );

            // Output only the first component to screen

            if( aComponentIndex == 0 )

                {

                WriteOutputFileL( aTile, aComponentIndex, subbandSize, bitdepth );

                }

            iComponents[aComponentIndex]->FreeData();

            }

        }

    }

// -----------------------------------------------------------------------------

// CJ2kImageWriter::OutputBlockL

// Output the image related to the component of the tile

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CJ2kImageWriter::OutputBlockL( CJ2kTileInfo& aTile, TUint16 aComponentIndex, 

                                    TInt32 aBlockXCoord, TInt32 aBlockYCoord,