/*

* 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:  CJ2kSynthesis class used to perform inverse quantization and

*                inverse DWT.

*

*/

// INCLUDE FILES

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KImageWriter.h"

#include "JP2KEntropyDecoder.h"

#include "JP2KCodeBlock.h"

#include "JP2KPacket.h"

#include "JP2KSubband.h"

#include "JP2KComponentInfo.h"

#include "JP2KSynthesis.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CJ2kSynthesis::CJ2kSynthesis

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CJ2kSynthesis::CJ2kSynthesis() 

    {

    // Set up the filter taps for irreversible filter

    iTapsLow[0] = KFixedLow9x70;

    iTapsLow[1] = KFixedLow9x71;

    iTapsLow[2] = KFixedLow9x72;

    iTapsLow[3] = KFixedLow9x73;

    iTapsHigh[0] = KFixedHigh9x70;

    iTapsHigh[1] = KFixedHigh9x71;

    iTapsHigh[2] = KFixedHigh9x72;

    iTapsHigh[3] = KFixedHigh9x73;

    iTapsHigh[4] = KFixedHigh9x74;

    }

// Destructor

CJ2kSynthesis::~CJ2kSynthesis()

    {

    if ( iInputBuffer )

        {

        iInputBuffer  -= ( KFilterExtension + 1 );

        User::Free( iInputBuffer );

        iInputBuffer = 0;

        }

    if ( iOutputBuffer )

        {

        iOutputBuffer -= ( KFilterExtension + 1 );

        User::Free( iOutputBuffer );

        iOutputBuffer = 0;

        }

    }

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

// CJ2kSynthesis::DecodeTileL

// Decode a single tile

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

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

//

void CJ2kSynthesis::DecodeTileL( CJ2kImageWriter& aImageWriter, 

                                 CJ2kEntropyDecoder& aEntropyDecoder,

                                 CJ2kImageInfo& aImageInfo,

                                 CJ2kTileInfo& aTile )

    {

    if ( aImageInfo.Crop() )

        {

        // If this tile doesn't belong to the crop area, continue

        if ( !aImageInfo.TileMaskAt( aTile.SotMarker().iIsot ) )

            {

            return;

            }

        }

    CJ2kComponentInfo* componentInfo = 0;

    TInt32 maxSize = 0;

    TUint16 compIndex = 0;

    TUint16 numOfComponents = aImageInfo.NumOfComponents();

    // Find the largest width or height

    for ( compIndex = 0; compIndex < numOfComponents; ++compIndex )

        {

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

        maxSize = Max( maxSize, Max( componentInfo->ComponentCanvas().Height(), 

                                     componentInfo->ComponentCanvas().Width() ) );

        }

    maxSize += 2 * ( KFilterExtension + 1 );

    AllocBufferL( maxSize );

    TSize   subbandSize( 0, 0 );

    TUint16 bandIndex = 0;

    TUint16 blockIndex = 0;

    CJ2kSubband*   subband = 0;

    CJ2kPacket*    packet = 0;

    CJ2kCodeBlock* codeblock = 0;

    TUint8  quantStyle = 0;

    TUint8  bitDepth = 0;

    TUint8  cblkStyle = 0;

    TUint8  levelIndex = 0;

    TUint32 packetIndex = 0;

    CJ2kWriterComponentInfo* component = 0;

    RPointerArray<CJ2kPacket>* packetList;

    aEntropyDecoder.SetNewSizeL( aImageInfo.MaxBlockSize() );

    // For each component in the tile

    for ( compIndex = 0; compIndex < aImageInfo.NumOfComponents(); ++compIndex )

        {

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

        // Skip the component when height or width is 0

        if ( componentInfo->ComponentCanvas().Height() == 0 ||

             componentInfo->ComponentCanvas().Width() == 0  )

            {

            continue;   //lint !e960    Continue is OK.

            }

        // Check for component truncation

        if ( aImageInfo.ComponentDrop() )

            {

            if ( aImageWriter.SingleFileOutput() )

                {

                if ( compIndex == ( aImageInfo.ComponentDrop() - 1 ) )

                    {

                    numOfComponents = compIndex;

                    }

                else

                    {

                    continue;   //lint !e960    Continue is OK.

                    }

                }

            else

                {

                if ( compIndex != ( aImageInfo.ComponentDrop() - 1 ) )

                    {

                    continue;   //lint !e960    Continue is OK.

                    }

                }

            }

        // Get the resolution level for this component

        iWaveletLevels = (TInt16)( componentInfo->Levels() - aImageInfo.LevelDrop() );

        TInt32 stepSize = 1;

        if ( iWaveletLevels < 0 )

            {

            TInt32 i;

            // Compute the output step size, the stepSize indicates how much more 

            // resolution has to be dropped if the image didn't have enough wavelet

            // levels to begin with. One indicates no extra resolution drop (write

            // each sample) and for each extra drop skip half of the samples, i.e.

            // stepSize is 2^extraLevels in case extra drop is needed.

            // Adjust the tile starting points and the stepSize

            for ( i = 0; i < (-iWaveletLevels); i++ )

                {

                // Double the step size for every extra level dropped.

                stepSize *= 2;

                }

            iWaveletLevels = 0;

            }

        // Get the top subband ( original image )

        subband = CONST_CAST( CJ2kSubband*, componentInfo->SubbandAt( (TUint8)iWaveletLevels ) );

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

            {

            subband = subband->Parent();

            }

        subbandSize = subband->SubbandCanvasSize();

        // Skip the component when subband's height or width is 0

        if ( subbandSize.iWidth == 0 || subbandSize.iHeight == 0 )

            {

            continue;   //lint !e960    Continue is OK.

            }

        component = CONST_CAST( CJ2kWriterComponentInfo*, &aImageWriter.WriterComponentAt( compIndex ) );

        // Have to allocate memory for each component in the image writer

        component->AllocDataL( subbandSize );

        bitDepth = aImageInfo.DepthOfComponent( compIndex );

        // Get the right number of levels and transform type 

        // reversible == 1 for 5x3 filter and == 0 for 9x7 filter

        iReversible = componentInfo->IsReversible();

        iROIShift   = componentInfo->RoiShift();

        quantStyle  = componentInfo->QuantizationStyle();

        cblkStyle   = componentInfo->CodeBlockStyle();

        // For each resolution level in the component

        for ( levelIndex = 0; levelIndex <= iWaveletLevels; levelIndex++ )

            {

            subband = CONST_CAST( CJ2kSubband*, componentInfo->SubbandAt( levelIndex ) );

            // For each subband in the resolution level

            do    

                {

                bandIndex = ( quantStyle == 1 ) ? (TUint16)0 : subband->SubbandTreeIndex();

                // Get the right magnitude bits for this band

                iMagnitudeBitsHere = componentInfo->MagnitudeBits( bandIndex );

                // Compute the Quantization parameters here, so we don't repeat that for every codeblock/precinct

                ComputeQuantizationParameters( *componentInfo, bandIndex, subband->SubbandGain(), bitDepth );

                // Set the lookup table for entropy decoder

                aEntropyDecoder.SetCurrentZCLUT( (TUint8)( subband->SubbandType() ) );

                packetList = CONST_CAST( RPointerArray<CJ2kPacket>*, &subband->PacketList() );    //lint !e665 the first parameter cannot be parenthesized here

                // For each packet in the subband

                for ( packetIndex = 0; packetIndex < componentInfo->NumOfPackets( levelIndex ); ++packetIndex )

                    {

                    packet = ( *packetList )[packetIndex];

                    // For each codeblock in the packet

                    for ( blockIndex = 0; blockIndex < packet->NumOfBlocks(); ++blockIndex )

                        {

                        codeblock = CONST_CAST( CJ2kCodeBlock*, &packet->CodeBlockAt( blockIndex ) );

                        // There is coded data in the codeblock

                        if ( codeblock->DataLength() )

                            {

                            // Decode the codeblock

                            aEntropyDecoder.DecodeCodeblock( *codeblock, cblkStyle, (TUint8)( iMagnitudeBitsHere + iROIShift ) );

                            // Copy data from the decoded codeblock for inverse quantization and ROI shifting

                            CopyDataToImage( aEntropyDecoder, component->Data(), *subband, *codeblock, quantStyle );

                            }

                        } // end of each codeblock

                    }  // end of each packet

                // Get the sibling subband

                subband = subband->NextSubbandRaster();

                } while ( subband ); // end of each subband in the resolution level

            }  // end of each resolution level in the component

        // Point to the LL-band before calling inverse wavelet transform

        subband = CONST_CAST( CJ2kSubband*, componentInfo->SubbandAt( 0 ) );

        // Perform a full inverse wavelet transformation

        FullWaveletInverse( component->Data(), subband );

        // Check whether extra downsampling is needed

        if(stepSize > 1)

            {

            TInt32 i,j;

            TInt32 iStep,jStep;

            // If the stepSize is larger than one it means that we have to downsample

            // the output. This is because there were not enough wavelet levels to do

            // the resolution dropping for this component.

            // The reason why downsampling is done here and not in the ImageWriter is

            // that different components might have different number of wavlet levels

            // and thus it is easier to downsample the components here (so that we can 

            // just write out the samples normally in ImageWriter.

            for(i = 0,iStep = 0; iStep < subbandSize.iHeight; i++,iStep += stepSize)

                {

                for(j = 0,jStep = 0; jStep < subbandSize.iWidth; j++,jStep += stepSize)

                    {

                    // Downsample the component so that downsampled image is in the

                    // upper left-hand corner.

                    component->Data()[i][j] = component->Data()[iStep][jStep];

                    }

                }

            }

        if ( numOfComponents >= 3 ) 

            {

            if ( aTile.ColorTransformation() || 

                ( aImageWriter.CSCode() == 18 || aImageWriter.CSCode() == 16 ) )

                {

                // Wait til we finish decoding all components before writing out the image

                if ( compIndex < 2 )

                    {

                    continue;   //lint !e960    Continue is OK.

                    }

                }

            else if ( aImageWriter.CSCode() == 0 )

                {

                // This case is also valid when no CSCode is defined, e.g. no file format is present

                if( numOfComponents <= 3 )

                    {

                    if ( compIndex < 2 )

                        {

                        continue;   //lint !e960    Continue is OK.

                        }

                    }

                else

                    {

                    // Proceed to outputImageL

                    }

                }

            }   //lint !e961    no else is needed here at the end of if...else if

        // Write out the tile image

        aImageWriter.OutputImageL( aTile, compIndex );

        }   // end of each component in the tile

    }

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

// CJ2kSynthesis::DecodeTileBlockL

// Decode a single tile with lower memory using 256x256 blocks 

// for the inverse wavelet transform

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

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

//

void CJ2kSynthesis::DecodeTileBlockL( CJ2kImageWriter& aImageWriter, 

                                      CJ2kEntropyDecoder& aEntropyDecoder,

                                      CJ2kImageInfo& aImageInfo,

                                      CJ2kTileInfo& aTile )

    {

    if ( aImageInfo.Crop() )

        {

        // If this tile doesn't belong to the crop area, continue

        if ( !aImageInfo.TileMaskAt( aTile.SotMarker().iIsot ) )

            {

            return;

            }

        }

    CJ2kComponentInfo* componentInfo = 0;

    TInt32  maxSize = 0;

    TUint16 compIndex = 0;

    TUint16 numOfComponents = aImageInfo.NumOfComponents();

    // Find the largest width or height

    for ( compIndex = 0; compIndex < numOfComponents; ++compIndex )

        {

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

        maxSize = Max( maxSize, Max( componentInfo->ComponentCanvas().Height(), 

                                     componentInfo->ComponentCanvas().Width() ) );

        }

    maxSize = KMaxBlockSupportSize;

    maxSize += 2 * ( KFilterExtension + 1 );

    AllocBufferL( maxSize );

    TSize subbandSize( 0, 0 );

    TUint16 bandIndex = 0;

    TUint16 blockIndex = 0;

    CJ2kSubband* subband = 0;

    CJ2kPacket* packet = 0;

    CJ2kCodeBlock* codeblock = 0;

    TUint8  quantStyle = 0;

    TUint8  bitDepth = 0;

    TUint8  cblkStyle = 0;

    TUint8  levelIndex = 0;

    TUint32 packetIndex = 0;

    TUint32 blockXCoord = 0;

    TUint32 blockYCoord = 0;

    TUint32 compXCoord = 0;

    TUint32 compYCoord = 0;

    TInt32 blockXEnd = 0;

    TInt32 blockYEnd = 0;

    TRect supportRegion( 0, 0, 0 , 0 );

    TRect parentSupportRegion( 0, 0, 0 , 0 );

    TPoint regionOffset( 0, 0 );

    TInt16 tmpLevelIndex = 0;

    TSize thisCompSize( 0, 0 );

    TSize firstCompSize( 0, 0 );

    TSize regionSize( 0, 0 );

    TPoint tileEndPoint( 0, 0 );

    TPoint tileStartPoint( 0, 0 );

    TPoint blockStepSize( 0, 0 );

    CJ2kWriterComponentInfo* component = 0;

    RPointerArray<CJ2kPacket>* packetList;

    TSizMarker& sizMarker = CONST_CAST( TSizMarker&, aImageInfo.SizMarker() );

    aEntropyDecoder.SetNewSizeL( aImageInfo.MaxBlockSize() );

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

    // Get the resolution level for this component

    iWaveletLevels = (TInt16)( componentInfo->Levels() - aImageInfo.LevelDrop() );

    if ( iWaveletLevels < 0 )

        {

        iWaveletLevels = 0;

        }

    // Get the top subband ( original image )

    subband = CONST_CAST( CJ2kSubband*, componentInfo->SubbandAt( (TUint8)iWaveletLevels ) );

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

        {

        subband = subband->Parent();

        }

    subbandSize = subband->SubbandCanvasSize();

    tileEndPoint.iX = subbandSize.iWidth;

    tileEndPoint.iY = subbandSize.iHeight;

    tileStartPoint.iX = componentInfo->ComponentCanvas().iTl.iX;

    tileStartPoint.iY = componentInfo->ComponentCanvas().iTl.iY;

    // Loop on 256x256 blocks to reduce the memory required to perform the inverse wavelet

    // First set as starting point the canvas coordinates of this component

    blockXCoord = 0;

    blockYCoord = 0;

    blockStepSize.iX = KWaveletBlockSize;

    blockStepSize.iY = KWaveletBlockSize;

    for ( ; blockYCoord < (TUint32)tileEndPoint.iY; blockYCoord += KWaveletBlockSize )

        {

        // Start from the left border of this tile

        blockXCoord = 0;

        for ( ; blockXCoord < ( TUint32 )tileEndPoint.iX; blockXCoord += KWaveletBlockSize )

            {

            // For each component in the tile

            for ( compIndex = 0; compIndex < aImageInfo.NumOfComponents(); ++compIndex )

                {

                compXCoord = blockXCoord;

                compYCoord = blockYCoord;

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

                // Skip the component when height or width is 0

                if ( componentInfo->ComponentCanvas().Height() == 0 ||

                     componentInfo->ComponentCanvas().Width() == 0  )

                    {

                    continue;   //lint !e960    Continue is OK.

                    }

                // Here we have to add a check that if we have sub sampled component together with color transform,

                // we have to subsample also the block dimensions ( so that the inverse color transform is performed

                // correctly.

                blockStepSize.iX = KWaveletBlockSize;

                blockStepSize.iY = KWaveletBlockSize;

                if ( aImageInfo.NumOfComponents() == 3 )

                    {

                    if ( sizMarker.iXRsiz[1] == 2 * sizMarker.iXRsiz[0] &&

                         sizMarker.iXRsiz[2] == 2 * sizMarker.iXRsiz[0] )

                        {

                        if ( sizMarker.iXRsiz[1] == 2 * sizMarker.iXRsiz[0] &&

                             sizMarker.iXRsiz[2] == 2 * sizMarker.iXRsiz[0] )

                            {

                            if( compIndex == 1 || compIndex == 2 )

                                {

                                blockStepSize.iX = KWaveletBlockSize >> 1;

                                blockStepSize.iY = KWaveletBlockSize >> 1;

                                compXCoord >>= 1;

                                compYCoord >>= 1;

                                }

                            }

                        else

                            {

                            if( compIndex == 1 || compIndex == 2 )

                                {

                                blockStepSize.iX = KWaveletBlockSize >> 1;

                                compXCoord >>= 1;

                                blockStepSize.iY = KWaveletBlockSize;

                                }

                            }

                        }

                    }

                // Check for component truncation

                if ( aImageInfo.ComponentDrop() )

                    {

                    if ( aImageWriter.SingleFileOutput() )

                        {

                        if ( compIndex == ( aImageInfo.ComponentDrop() - 1 ) )

                            {

                            numOfComponents = compIndex;

                            }

                        else

                            {

                            continue;   //lint !e960    Continue is OK.

                            }

                        }

                    else

                        {

                        if ( compIndex != ( aImageInfo.ComponentDrop() - 1 ) )

                            {

                            continue;   //lint !e960    Continue is OK.

                            }

                        }