// Copyright (c) 2003-2009 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:
// Name        : UdvmMemory.cpp
// Part of     : SigComp / UDVM
// UDVM memory/memory manipulation
// Version     : 1.0
//



#include "Sigcomp.h"
#include "Udvm.h"
#include "UdvmMemory.h"

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

void CUdvmMemory::ConstructL(TUint aMemSize)
    {
    iMemSize = aMemSize;
    iMem = new (ELeave)CArrayFixFlat<TUint8>(8);
    iMem->ResizeL(iMemSize);
    }

CUdvmMemory::CUdvmMemory()
    {
    }

CUdvmMemory* CUdvmMemory::NewLC(TUint aMemSize)
    {
    CUdvmMemory* self= new (ELeave)CUdvmMemory();
    CleanupStack::PushL(self);
    self->ConstructL(aMemSize);
    return self;
    }

CUdvmMemory* CUdvmMemory::NewL(TUint aMemSize)
    {
    CUdvmMemory* self= NewLC(aMemSize);
    CleanupStack::Pop();
    return self;
    }

// Destructor
CUdvmMemory::~CUdvmMemory()
    {
    delete iMem;
    }

void CUdvmMemory::CheckMemAccessL(TUint aAddr, TUint aSize) const
    {
    if ((iFreeMemSize < KMaxUdvmMemorySize) &&
        ((aAddr + aSize) > iFreeMemSize))
        {
        User::Leave(CSigComp::EDecompressionFailure);
        }
    }

// ----------------------------------------------------------------------------
// CUdvmMemory::WriteMem8L
// write byte to UDVM memory
// ----------------------------------------------------------------------------
//

void CUdvmMemory::WriteMem8L(TUint aDest, TUint aVal)
    {

    CheckMemAccessL(aDest, 1);

    (*iMem)[aDest] = static_cast<TUint8>(aVal & 0xff);
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::WriteMem16L
// write 16-bit word to UDVM memory
// ----------------------------------------------------------------------------
//

void CUdvmMemory::WriteMem16L(TUint aDest, TUint aVal)
    {

    CheckMemAccessL(aDest, 2);

    // write 16-bit value in big-endian convention
    (*iMem)[aDest] = static_cast<TUint8>((aVal >> 8) & 0xff);
    (*iMem)[(aDest + 1) & KMaxUdvmMemoryMask] = static_cast<TUint8>
                                                           (aVal & 0xff);
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::ReadMem8L
// read byte from UDVM memory
// ----------------------------------------------------------------------------
//

TUint8 CUdvmMemory::ReadMem8L(TUint aSrc) const
    {

    CheckMemAccessL(aSrc, 1);

    return static_cast<TUint8>((*iMem)[aSrc]);
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::ReadMem16L
// read 16-bit word from UDVM memory
// ----------------------------------------------------------------------------
//

TUint16 CUdvmMemory::ReadMem16L(TUint aSrc) const
    {

    CheckMemAccessL(aSrc, 2);

    // read 16-bit value in big-endian convention
    return static_cast<TUint16>(((static_cast<TUint16>((*iMem)[aSrc]) << 8) +
           static_cast<TUint16>((*iMem)[(aSrc + 1) & KMaxUdvmMemoryMask])));
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::SetMemL
// set block of UDVM memory to value
// ----------------------------------------------------------------------------
//

void CUdvmMemory::SetMemL(TUint aDest, TUint8 aVal, TUint aSize)
    {

    CheckMemAccessL(aDest, aSize);

    for (TUint i = 0; i < aSize; i++)
        {
        (*iMem)[aDest] = aVal;
        aDest = (aDest + 1) & KMaxUdvmMemoryMask;
        }
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::CopyToMemL
// copy block of data to UDVM memory
// ----------------------------------------------------------------------------
//

void CUdvmMemory::CopyToMemL(TUint aDest, const TUint8* aSrc, TUint aSize)
    {

    CheckMemAccessL(aDest, aSize);

    for (TUint i = 0; i < aSize; i++)
        {
        (*iMem)[aDest] = *aSrc++;
        aDest = (aDest + 1) & KMaxUdvmMemoryMask;
        }
    }


// ----------------------------------------------------------------------------
// CUdvmMemory::CopyFromMemL
// copy block of data from UDVM memory
// ----------------------------------------------------------------------------
//

void CUdvmMemory::CopyFromMemL(TUint8* aDest, TUint aSrc, TUint aSize) const
    {

    CheckMemAccessL(aSrc, aSize);

    for (TUint i = 0; i < aSize; i++)
        {
        *aDest++ = (*iMem)[aSrc];
        aSrc = (aSrc + 1) & KMaxUdvmMemoryMask;
        }
    }

void CUdvmMemory::InitMemoryL(TUint aMsgSize, TUint aCyclesPerBit)
    {
    if (iMemSize <= aMsgSize)
        {
        User::Leave(CSigComp::EDecompressionFailure);
        }

    iFreeMemSize = iMemSize-aMsgSize;
    if (iFreeMemSize > KMaxUdvmMemorySize)
        {
        iFreeMemSize = KMaxUdvmMemorySize;
        }

    WriteMem16L(CUdvm::EMem_UDVM_memory_size, static_cast<TUint16>
                (iFreeMemSize & KMaxUdvmMemoryMask));
    WriteMem16L(CUdvm::EMem_cycles_per_bit, static_cast<TUint16>
                (aCyclesPerBit));
    WriteMem16L(CUdvm::EMem_SigComp_version, KSigCompVersion);
    SetMemL(CUdvm::EMem_reserved, 0,
            CUdvm::EMem_scratch_pad-CUdvm::EMem_reserved);
    SetMemL(CUdvm::EMem_scratch_pad, 0,
            CUdvm::EMem_registers - CUdvm::EMem_scratch_pad);
    WriteMem16L(CUdvm::EReg_byte_copy_left, 0x0000);
    WriteMem16L(CUdvm::EReg_byte_copy_right, 0x0000);
    WriteMem16L(CUdvm::EReg_input_bit_order, 0x0000);
    WriteMem16L(CUdvm::EReg_stack_location, 0x0000);
    SetMemL(CUdvm::EMem_user_area, 0, iFreeMemSize - CUdvm::EMem_user_area);
    }

TUint8* CUdvmMemory::MemoryPtr()
    {
    return &iMem->At(0);
    }

TUint CUdvmMemory::MemorySize() const
    {
    return iMemSize;
    }

TUint CUdvmMemory::FreeMemorySize() const
    {
    return iFreeMemSize;
    }