/*

* Copyright (c) 2002-2007 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:  Bit manipulator.

*

*/

#include    "TSatBitOP.h"

#include    "SatLog.h"

const TUint8 KBitsInByte( 8 );

const TUint8 KBitsInWord( 16 );

const TUint8 KHighBitInByte( 7 );

const TUint8 KHighBitInWord( 15 );

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

// Extracts bits from bit sequence. First bit is 0 index.

// The lsb of extracted bits is set to 0 bit.

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

//

TUint8 TSatBitOP::ExtractBits(

    TInt aBitIndex,

    TUint8 aBitCount,

    const TDesC8& aBytes )

    {

    LOG( DETAILED, "SATENGINE: TSatBitOP::ExtractBits calling" )

    // Calculate the byte where aBitIndex is pointing.

    const TInt byteIndex( static_cast<TInt>( aBitIndex / KBitsInByte ) );

    if ( byteIndex > 0 ) // aBitIndex is pointing other than first byte.

        {

        LOG( DETAILED, "SATENGINE: TSatBitOP::ExtractBits byteIndex > 0" )

        // Change the aBitIndex to point the bits 0 to 7, because

        // we know which byte it is indexing.

        aBitIndex -= byteIndex * KBitsInByte;

        }

    TUint8 result( 0 );

    // Check if the bits to be extracted is in two bytes.

    // ie. Part of the bits is in one byte and another

    // part is in the following byte.

    const TUint8 lastBit( static_cast<TUint8>( aBitIndex + aBitCount ) );

    LOG2( DETAILED, "SATENGINE: TSatBitOP::ExtractBits lastBit: %i", lastBit )

    if ( lastBit > KBitsInByte )

        {

        // The bits to be extracted reside in two bytes.

        // Take the bytes.

        const TUint16 word( static_cast<TUint16>(

            ( aBytes[byteIndex] << KBitsInByte ) + aBytes[byteIndex + 1] ) );

        // Create the mask, which extracts the bits.

        const TUint16 mask(

            CreateMask16Bit( static_cast<TUint8>( aBitIndex ), aBitCount ) );

        // Extract the bits from the word.

        // Result will be shifted so that the lsb bit of the extracted bits

        // will be in bit 0.

        result =

            static_cast<TUint8>( ( word & mask ) >> ( KBitsInWord - lastBit ) );

        }

    else

        {

        // Bits can be extracted from single byte.

        // Create the mask.

        const TUint8 mask(

            CreateMask8Bit( static_cast<TUint8>( aBitIndex ), aBitCount ) );

        const TUint8 byte( aBytes[byteIndex] );

        // Mask the bits and move the lsb of the extracted bits to 0 bit.

        // Result will be shifted so that the lsb bit of the extracted bits

        // will be in bit 0.

        result =

            static_cast<TUint8>( ( byte & mask ) >> ( KBitsInByte - lastBit ) );

        }

    LOG( DETAILED, "SATENGINE: TSatBitOP::ExtractBits exiting" )

    return result;

    }

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

// Creates a 8-bit mask of ones.

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

//

TUint8 TSatBitOP::CreateMask8Bit( TUint8 aBitIndex, TUint8 aCount )

    {

    LOG( DETAILED, "SATENGINE: TSatBitOP::CreateMask8Bit calling" )

    // Change aBitIndex to use normal indexing of bits, because

    // 0 in aBitIndex means MSB.

    aBitIndex = static_cast<TUint8>( KHighBitInByte - aBitIndex );

    TUint8 result( 0 );

    TInt i ( 0 );

    for ( i = 0; i < aCount; i++ )

        {

        result |= static_cast<TUint8>( 1 << aBitIndex );

        aBitIndex--;

        }

    LOG2( DETAILED, "SATENGINE: TSatBitOP::CreateMask8Bit i: %i", i )

    LOG2( DETAILED, "SATENGINE: TSatBitOP::CreateMask8Bit exiting, \

          result: %i", result )

    return result;

    }

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

// Creates a 16-bit mask of ones.

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

//

TUint16 TSatBitOP::CreateMask16Bit( TUint8 aBitIndex, TUint8 aCount )

    {

    LOG( DETAILED, "SATENGINE: TSatBitOP::CreateMask16Bit calling" )

    // Change aBitIndex to use normal indexing of bits, because

    // 0 in aBitIndex means MSB.

    aBitIndex = static_cast<TUint8>( KHighBitInWord - aBitIndex );

    TUint16 result( 0 );

    TInt i ( 0 );

    for ( i = 0;  i < aCount; i++ )

        {

        result |= static_cast<TUint16>( 1 << aBitIndex );

        aBitIndex--;

        }

    LOG2( DETAILED, "SATENGINE: TSatBitOP::CreateMask16Bit i: %i", i )

    LOG2( DETAILED, "SATENGINE: TSatBitOP::CreateMask16Bit exiting, \

          result: %i", result )

    return result;

    }