/*

* 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:  TJ2kStreamReader class is to implement the

*                MJ2kPacketHeaderReader interface for reading the

*                packet header and packet body from the stream

*                buffer provided by ICL framework.

*

*/

// INCLUDE FILES

#include <icl/imageprocessor.h>

#include <icl/imagecodec.h>

#include <icl/imagecodecdata.h>

#include "JP2KImageUtils.h"

#include "JP2KFormat.h"

#include "JP2KStreamReader.h"

#include "JP2KCodec.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// TJ2kStreamReader::UpdateMainHeader

// Update the codestream length read and offset of SOT marker

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

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

//

void TJ2kStreamReader::UpdateMainHeader()

    {

    if ( iCSLength )

        {

        // Codestream left

        iCSLength -= ( iPtr - iPtrStartMarker );

        }

    iStartSOT += ( iPtr - iPtrStartMarker );

    }

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

// TJ2kStreamReader::UpdateTileHeader

// Update the codestream length read and length of data consumed

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

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

//

void TJ2kStreamReader::UpdateTileHeader()

    {

    if ( iCSLength )

        {

        // Codestream left

        iCSLength -= ( iPtr - iPtrStartMarker );

        }

    iDataUsed += ( iPtr - iPtrStartMarker );

    }

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

// TJ2kStreamReader::ReadEPHMarker

// Try to consume the EPH marker if there is one

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

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

//

TUint8 TJ2kStreamReader::ReadEPHMarker()

    {

    if ( ( iPtrEnd - iPtr ) < 2 )

        {

        // EPH marker should be tried on next read

        iTryEPHMarker = ETrue;

        }

    else

        {

        iTryEPHMarker = EFalse;

        // Try to consume the EPH marker

        if ( PtrReadUtil::ReadBigEndianUint16( iPtr ) == KEPH )

            {

            iPtr += 2;

            }

        }

    return EFalse;

    }

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

// TJ2kStreamReader::ReadBit

// Read a bit from the packet header stream.

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

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

//

TUint8 TJ2kStreamReader::ReadBit( TUint8& aBit )

    {

    if ( iPos == 0 )

        {

        if ( iPtr < iPtrEnd )

            {

            // Buffer contains some packet header data

            iData = *iPtr++;

            iPos = iNextPos;

            if ( iNextPos == 0x08 && iData == 0xff )

                {

                iNextPos = 0x07;

                }

            else

                {

                iNextPos = 0x08;

                }

            }

        else

            {

            // No more data

            return ETrue;

            }

        }

    aBit = (TUint8)( ( iData >> ( --iPos ) ) & 0x01 );

    return EFalse;

    }

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

// TJ2kStreamReader::ReadBits

// Read some bits from the packet header stream.

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

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

//

TUint8 TJ2kStreamReader::ReadBits( TUint8& aBit, TUint8 aBitLen )

    {

    aBit = (TUint8)0;

    TUint8 bit;

    for ( TInt8 index = (TInt8)( aBitLen - 1 ); index >= 0; --index )

        {

        if ( !ReadBit( bit ) )

            {

            aBit |= ( bit << index );

            }

        else

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// TJ2kStreamReader::ReadBits

// Read some bits from the packet header stream.

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

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

//

TUint8 TJ2kStreamReader::ReadBits( TUint32& aBit, TUint8 aBitLen )

    {

    aBit = (TUint32)0;

    TUint8 bit = 0;

    for ( TInt8 index = ( TInt8 )( aBitLen - 1 ); index >= 0; --index )

        {

        if ( !ReadBit( bit ) )

            {

            aBit |= ( bit << index );

            }

        else

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// TJ2kStreamReader::StartReadBit

// Start reading from packet header stream.

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

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

//

TUint8 TJ2kStreamReader::StartReadBit()

    {

    if ( iAlign )

        {

        // Byte alignment is required

        ++iPtr;

        iAlign = 0;

        }

    if ( iPtr < iPtrEnd )

        {

        // Buffer contains some packet header data

        iData = *iPtr++;

        iPos = iNextPos = 0x08;

        if ( iData == 0xff )

            {

            iNextPos = 0x07;

            }

        return EFalse;

        }

    return ETrue;

    }

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

// TJ2kStreamReader::AlignReader

// Align the stream to the next byte boundary if necessary.

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

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

//

void TJ2kStreamReader::AlignReader()

    {

    iAlign = 0;

    if ( iNextPos == 0x07 )

        {

        if ( iPtr < iPtrEnd )

            {

            ++iPtr;

            }

        else

            {

            // byte alignment is required on next read

            iAlign = 1;

            }

        }

    iData = iPos = iNextPos = 0;

    }

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

// TJ2kStreamReader::ReadSOPMarker

// Try to consume the SOP marker if there is one

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

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

//

TUint8 TJ2kStreamReader::ReadSOPMarker()

    {

    if ( ( iPtrEnd - iPtr ) < 6 )

        {

        return ETrue;

        }

    else

        {

        if ( PtrReadUtil::ReadBigEndianUint16( iPtr ) == KSOP )

            {

            iPtr += 2;

            if ( PtrReadUtil::ReadBigEndianUint16( iPtr ) == KSOP_LEN )

                {

                // SOP marker found

                iPtr += 4;

                }

            else

                {

                // SOP marker not found, backup the iterator

                iPtr -= 2;

                }

            }

        return EFalse;

        }

    }

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

// TJ2kStreamReader::TryReadEPHMarker

// Try to consume the EPH marker after failure on previous try

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

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

//

TUint8 TJ2kStreamReader::TryReadEPHMarker()

    {

    if ( iTryEPHMarker )

        {

        if ( ( iPtrEnd - iPtr ) < 2 )

            {

            return ETrue;

            }

        else

            {

            if ( PtrReadUtil::ReadBigEndianUint16( iPtr ) == KEPH )

                {

                iPtr += 2;

                }

            iTryEPHMarker = EFalse;

            }

        }

    return EFalse;

    }

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

// TJ2kStreamReader::TryReAlignReader

// Try to align to byte boundary after failure on previous try

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

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

//

TUint8 TJ2kStreamReader::TryReAlignReader()

    {

    if ( iAlign )

        {

        if ( ( iPtrEnd - iPtr ) < 1 )

            {

            return ETrue;

            }

        else

            {

            ++iPtr;

            iAlign = 0;

            }

        }

    return EFalse;

    }