/******************************************************************************
 *
 * Name:     hfadataset.cpp
 * Project:  Erdas Imagine Driver
 * Purpose:  Imagine Compression code.
 * Author:   Sam Gillingham <sam.gillingham at nrm.qld.gov>
 *
 ******************************************************************************
 * Copyright (c) 2005, Sam Gillingham
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "cpl_port.h"
#include "hfa_p.h"

#include <cstddef>

#include "cpl_conv.h"
#include "cpl_error.h"
#include "cpl_vsi.h"
#include "hfa.h"

HFACompress::HFACompress(void *pData, GUInt32 nBlockSize, EPTType eDataType)
    : m_pData(pData), m_nBlockSize(nBlockSize),
      m_nBlockCount((nBlockSize * 8) / HFAGetDataTypeBits(eDataType)),
      m_eDataType(eDataType), m_nDataTypeNumBits(HFAGetDataTypeBits(eDataType)),
      m_pCounts(nullptr), m_pCurrCount(nullptr), m_nSizeCounts(0),
      m_pValues(nullptr), m_pCurrValues(nullptr), m_nSizeValues(0), m_nMin(0),
      m_nNumRuns(0), m_nNumBits(0)
{
    // Allocate some memory for the count and values - probably too big.
    // About right for worst case scenario.
    m_pCounts = static_cast<GByte *>(
        VSI_MALLOC_VERBOSE(m_nBlockCount * sizeof(GUInt32) + sizeof(GUInt32)));

    m_pValues = static_cast<GByte *>(
        VSI_MALLOC_VERBOSE(m_nBlockCount * sizeof(GUInt32) + sizeof(GUInt32)));
}

HFACompress::~HFACompress()
{
    // Free the compressed data.
    CPLFree(m_pCounts);
    CPLFree(m_pValues);
}

// Returns the number of bits needed to encode a count.
static GByte _FindNumBits(GUInt32 range)
{
    if (range < 0xff)
    {
        return 8;
    }

    if (range < 0xffff)
    {
        return 16;
    }

    return 32;
}

// Gets the value from the uncompressed block as a GUInt32 no matter
// the data type.
GUInt32 HFACompress::valueAsUInt32(GUInt32 iPixel)
{
    GUInt32 val = 0;

    if (m_nDataTypeNumBits == 8)
    {
        val = ((GByte *)m_pData)[iPixel];
    }
    else if (m_nDataTypeNumBits == 16)
    {
        val = ((GUInt16 *)m_pData)[iPixel];
    }
    else if (m_nDataTypeNumBits == 32)
    {
        val = ((GUInt32 *)m_pData)[iPixel];
    }
    else if (m_nDataTypeNumBits == 4)
    {
        if (iPixel % 2 == 0)
            val = ((GByte *)m_pData)[iPixel / 2] & 0x0f;
        else
            val = (((GByte *)m_pData)[iPixel / 2] & 0xf0) >> 4;
    }
    else if (m_nDataTypeNumBits == 2)
    {
        if (iPixel % 4 == 0)
            val = ((GByte *)m_pData)[iPixel / 4] & 0x03;
        else if (iPixel % 4 == 1)
            val = (((GByte *)m_pData)[iPixel / 4] & 0x0c) >> 2;
        else if (iPixel % 4 == 2)
            val = (((GByte *)m_pData)[iPixel / 4] & 0x30) >> 4;
        else
            val = (((GByte *)m_pData)[iPixel / 4] & 0xc0) >> 6;
    }
    else if (m_nDataTypeNumBits == 1)
    {
        if (((GByte *)m_pData)[iPixel >> 3] & (0x1 << (iPixel & 0x07)))
            val = 1;
        else
            val = 0;
    }
    else
    {
        // Should not get to here.  Check in compressBlock() should return false
        // if we can't compress this block because we don't know about the type.
        CPLError(CE_Failure, CPLE_FileIO,
                 "Imagine Datatype 0x%x (0x%x bits) not supported", m_eDataType,
                 m_nDataTypeNumBits);
        CPLAssert(false);
    }

    return val;
}

// Finds the minimum value in a type specific fashion. This value is
// subtracted from each value in the compressed dataset. The maximum
// value is also found and the number of bits that the range can be stored
// is also returned.
//
// TODO: Minimum value returned as pNumBits is now 8 - Imagine
// can handle 1, 2, and 4 bits as well.
GUInt32 HFACompress::findMin(GByte *pNumBits)
{
    GUInt32 u32Min = valueAsUInt32(0);
    GUInt32 u32Max = u32Min;

    for (GUInt32 count = 1; count < m_nBlockCount; count++)
    {
        GUInt32 u32Val = valueAsUInt32(count);
        if (u32Val < u32Min)
            u32Min = u32Val;
        else if (u32Val > u32Max)
            u32Max = u32Val;
    }

    *pNumBits = _FindNumBits(u32Max - u32Min);

    return u32Min;
}

// Codes the count in the way expected by Imagine - i.e. the lower 2 bits
// specify how many bytes the count takes up.
void HFACompress::makeCount(GUInt32 count, GByte *pCounter,
                            GUInt32 *pnSizeCount)
{
    // Because Imagine stores the number of bits used in the lower 2 bits of the
    // data it restricts what we can use.
    if (count < 0x40)
    {
        pCounter[0] = static_cast<GByte>(count);
        *pnSizeCount = 1;
    }
    else if (count < 0x4000)
    {
        pCounter[1] = count & 0xff;
        count /= 256;
        pCounter[0] = static_cast<GByte>(count | 0x40);
        *pnSizeCount = 2;
    }
    else if (count < 0x400000)
    {
        pCounter[2] = count & 0xff;
        count /= 256;
        pCounter[1] = count & 0xff;
        count /= 256;
        pCounter[0] = static_cast<GByte>(count | 0x80);
        *pnSizeCount = 3;
    }
    else
    {
        pCounter[3] = count & 0xff;
        count /= 256;
        pCounter[2] = count & 0xff;
        count /= 256;
        pCounter[1] = count & 0xff;
        count /= 256;
        pCounter[0] = static_cast<GByte>(count | 0xc0);
        *pnSizeCount = 4;
    }
}

// Encodes the value depending on the number of bits we are using.
void HFACompress::encodeValue(GUInt32 val, GUInt32 repeat)
{
    GUInt32 nSizeCount = 0;

    makeCount(repeat, m_pCurrCount, &nSizeCount);
    m_pCurrCount += nSizeCount;
    if (m_nNumBits == 8)
    {
        // Only storing 8 bits per value as the range is small.
        *m_pCurrValues = GByte(val - m_nMin);
        m_pCurrValues += sizeof(GByte);
    }
    else if (m_nNumBits == 16)
    {
        // Only storing 16 bits per value as the range is small.
        *reinterpret_cast<GUInt16 *>(m_pCurrValues) = GUInt16(val - m_nMin);
#ifndef CPL_MSB
        CPL_SWAP16PTR(m_pCurrValues);
#endif  // ndef CPL_MSB
        m_pCurrValues += sizeof(GUInt16);
    }
    else
    {
        *reinterpret_cast<GUInt32 *>(m_pCurrValues) = GUInt32(val - m_nMin);
#ifndef CPL_MSB
        CPL_SWAP32PTR(m_pCurrValues);
#endif  // ndef CPL_MSB
        m_pCurrValues += sizeof(GUInt32);
    }
}

// This is the guts of the file - call this to compress the block returns false
// if the compression fails - i.e. compressed block bigger than input.
bool HFACompress::compressBlock()
{
    GUInt32 nLastUnique = 0;

    // Check we know about the datatype to be compressed.
    // If we can't compress it we should return false so that
    // the block cannot be compressed (we can handle just about
    // any type uncompressed).
    if (!QueryDataTypeSupported(m_eDataType))
    {
        CPLDebug("HFA",
                 "Cannot compress HFA datatype 0x%x (0x%x bits). "
                 "Writing uncompressed instead.",
                 m_eDataType, m_nDataTypeNumBits);
        return false;
    }

    // Reset our pointers.
    m_pCurrCount = m_pCounts;
    m_pCurrValues = m_pValues;

    // Get the minimum value.  this can be subtracted from each value in
    // the image.
    m_nMin = findMin(&m_nNumBits);

    // Go through the block.
    GUInt32 u32Last = valueAsUInt32(0);
    for (GUInt32 count = 1; count < m_nBlockCount; count++)
    {
        const GUInt32 u32Val = valueAsUInt32(count);
        if (u32Val != u32Last)
        {
            // The values have changed - i.e. a run has come to and end.
            encodeValue(u32Last, count - nLastUnique);

            if ((m_pCurrValues - m_pValues) > static_cast<int>(m_nBlockSize))
            {
                return false;
            }

            m_nNumRuns++;
            u32Last = u32Val;
            nLastUnique = count;
        }
    }

    // We have done the block but have not got the last run because we
    // were only looking for a change in values.
    encodeValue(u32Last, m_nBlockCount - nLastUnique);
    m_nNumRuns++;

    // Set the size variables.
    m_nSizeCounts = static_cast<GUInt32>(m_pCurrCount - m_pCounts);
    m_nSizeValues = static_cast<GUInt32>(m_pCurrValues - m_pValues);

    // The 13 is for the header size - maybe this should live with some
    // constants somewhere?
    return (m_nSizeCounts + m_nSizeValues + 13) < m_nBlockSize;
}

bool HFACompress::QueryDataTypeSupported(EPTType eHFADataType)
{
    const int nBits = HFAGetDataTypeBits(eHFADataType);

    return nBits == 1 || nBits == 2 || nBits == 4 || nBits == 8 ||
           nBits == 16 || nBits == 32;
}