BmnFileReaderXzLzma.cxx

Go to the documentation of this file.

// headers from this target
#include "BmnFileReaderXzLzma.h"
 
#include "BmnDefinitions.h"
// std:: headers
#include <cassert>
#include <filesystem>
// the main XZ LZMA2 header
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
// This header holds various smaller headers and a few definitions - it's best to only add that header
#include <lzma.h>
#else
// If we build without the library, it would be find to use #pragma on the entire object, without push
// and pop, but it's nothing too important for us here - just for simplicity I'm going with this def
DISABLE_UNUSED_PARAM_WARNING
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
 
/*
 * A wrapper around lzma_stream as it may not be forward declared due to the way devs wrote
 * its definition. While we could use `void*` in `BmnFileReaderXzLzma.hpp`, this is more readable
 */
struct LzmaContext
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    LzmaContext()
        : fLzmaStream(LZMA_STREAM_INIT)
    {}
    ~LzmaContext() { lzma_end(&fLzmaStream); }
 
  public:
    lzma_stream fLzmaStream;
#else
    LzmaContext() = default;
    ~LzmaContext() = default;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
};
 
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
// ================== static function declaration ==================
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
 
/*
 * A method that can be used for obtaining a string based on an error ID return by some LZMA function
 * @param errorID An error ID return by a LZMA function
 */
[[nodiscard]] static std::string GetLzmaReturnTypeDescription(const int32_t errorID) noexcept;
/*
 * A method that can be used for obtaining a string based on a lzma_ret value
 * @param lzmaReturnEnum An enum-type returned by a LZMA function
 */
[[nodiscard]] static std::string GetLzmaReturnTypeDescription(const lzma_ret lzmaReturnEnum) noexcept;
 
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
 
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
// ================== BmnFileReaderXzLzma public methods ==================
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 
size_t BmnFileReaderXzLzma::sMaximalAllowedMemory = 256ull * 1024ull * 1024ull;
 
BmnFileReaderXzLzma::BmnFileReaderXzLzma(const std::string& fileName)
    : BmnIFileReader(BmnFileType::XZ_LZMA, fileName)
    , fLzmaStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderXzLzma::BmnFileReaderXzLzma(std::string&& fileName)
    : BmnIFileReader(BmnFileType::XZ_LZMA, std::move(fileName))
    , fLzmaStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderXzLzma::BmnFileReaderXzLzma(const std::filesystem::path& filePath)
    : BmnIFileReader(BmnFileType::XZ_LZMA, filePath)
    , fLzmaStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderXzLzma::BmnFileReaderXzLzma(std::filesystem::path&& filePath)
    : BmnIFileReader(BmnFileType::XZ_LZMA, std::move(filePath))
    , fLzmaStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderXzLzma::~BmnFileReaderXzLzma()
{
    BmnFileReaderXzLzma::Close();
}
 
void BmnFileReaderXzLzma::Open(const BmnBinaryFileProcessingOptions processingFlags)
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    /*
    While we actually don't need so many comments and checks here, we are still performing them just to ensure
    one doesn't make an accidental mistake - it might be easier to catch it
    */
    if (fLzmaStream) {
        LOG(error) << "LZMA stream is already valid!";
        return;
    }
    if (!PerformStandardChecksBeforeOpening(processingFlags))
        return;
    fArchiveReadManager.Open(fFilePath, std::ios::in | std::ios::binary);
    fLzmaStream = new LzmaContext{};
    // we are looking for .xz files, not raw lzma so `lzma_stream_decoder` is find, no need to use `lzma_auto_decoder`
    lzma_ret aReturnStatus = lzma_stream_decoder(&fLzmaStream->fLzmaStream, sMaximalAllowedMemory, LZMA_CONCATENATED);
    if (aReturnStatus != lzma_ret::LZMA_OK) {
        fArchiveReadManager.Close();
        delete fLzmaStream;
        fLzmaStream = nullptr;
        LOG(error) << "Failed to initialize lzma stream! Reason: " << GetLzmaReturnTypeDescription(aReturnStatus)
                   << '\n';
    }
#else
    throw std::runtime_error{"Trying to use LZMA while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
void BmnFileReaderXzLzma::Close() noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    if (!fLzmaStream)
        return;
    // while lzma.h tells us we can reuse the stream, we could save some time that we will spend for allocating new
    // buffers, but it's a safer and less error-prone approach - thus, I'm deleting buffers while closing
    delete fLzmaStream;
    fLzmaStream = nullptr;
    fArchiveReadManager.Close();
    fNumberOfReadBytes = 0ull;
    fLastReturnStatus = 0;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
int64_t BmnFileReaderXzLzma::Read(void* dataToFill, const int64_t sizeToFill)
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    if (!IsStreamInGoodState())
        return 0ll;
    return fArchiveReadManager.Read(dataToFill, sizeToFill);
#else
    throw std::runtime_error{"Trying to use LZMA while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
int64_t BmnFileReaderXzLzma::Tell() const noexcept
{
    return fNumberOfReadBytes + fArchiveReadManager.GetCurrentOutputBufferPosition()
           - fArchiveReadManager.GetTotalOutputBufferFilledSize();
}
 
void BmnFileReaderXzLzma::Seek(int64_t value)
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    if (value < 0ll || (size_t)value == fNumberOfReadBytes)
        return;
    if (!IsStreamInGoodState()) {
        LOG(error) << "Before calling `BmnFileReaderXzLzma::Seek` ensure to clear bad flags!\n";
        return;
    }
    if (!fLzmaStream) {
        LOG(error) << "Before calling `BmnFileReaderXzLzma::Seek` ensure to open the stream!\n";
        return;
    }
    if (!fArchiveReadManager.IsOpen()) {
        LOG(error) << "Reading file missing while calling `BmnFileReaderXzLzma::Seek`\n";
        return;
    }
    if ((size_t)value < (fNumberOfReadBytes - fArchiveReadManager.GetTotalOutputBufferFilledSize())) {
        Close();
        Open(BmnBinaryFileProcessingOptions::ReadBinary);
    }
    // in theory I could check IsOpen again for unexpected errors, but....
    fArchiveReadManager.MoveToDecompressingLocation(value);
#else
    throw std::runtime_error{"Trying to use LZMA while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
bool BmnFileReaderXzLzma::IsGood() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    return fLzmaStream && IsStreamInGoodState() && fArchiveReadManager.IsGood();
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
bool BmnFileReaderXzLzma::IsEOF() const noexcept
{
    return fArchiveReadManager.IsEOF();
}
 
void BmnFileReaderXzLzma::ClearStateFlags()
{
    // I don't like this method much
    fLastReturnStatus = 0ull;
    fArchiveReadManager.Clear();
}
 
bool BmnFileReaderXzLzma::IsOpen() const noexcept
{
    return fArchiveReadManager.IsOpen() && fLzmaStream;
}
 
// ========== BmnIArchiveLib Interface ==========
 
BmnFileStreamResults BmnFileReaderXzLzma::Uncompress(const void* source,
                                                     const size_t sourceTotalSize,
                                                     size_t& numberOfReadBytes,
                                                     void* output,
                                                     const size_t outputTotalSize,
                                                     size_t& numberOfSetOutputBytes)
{
    if (!fLzmaStream)
        return BmnFileStreamResults::FileNotOpen;
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::TryingToReadBadStream;
    fLzmaStream->fLzmaStream.next_out = (uint8_t*)output;
    fLzmaStream->fLzmaStream.avail_out = outputTotalSize;
    fLzmaStream->fLzmaStream.total_out = 0ull;
    fLzmaStream->fLzmaStream.next_in = (uint8_t*)source;
    fLzmaStream->fLzmaStream.avail_in = sourceTotalSize;
    fLzmaStream->fLzmaStream.total_in = 0ull;
    if (sourceTotalSize == 0ull)
        fLastReturnStatus = (int32_t)lzma_code(&fLzmaStream->fLzmaStream, lzma_action::LZMA_FINISH);
    else
        fLastReturnStatus = (int32_t)lzma_code(&fLzmaStream->fLzmaStream, lzma_action::LZMA_RUN);
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::UnexpectedFail;
    numberOfReadBytes = (size_t)fLzmaStream->fLzmaStream.total_in;
    numberOfSetOutputBytes = (size_t)fLzmaStream->fLzmaStream.total_out;
    fNumberOfReadBytes += numberOfSetOutputBytes;
    if (fLastReturnStatus == 1)
        return BmnFileStreamResults::ReachedEOF;
    return BmnFileStreamResults::Success;
#else
    throw std::runtime_error{"Trying to use LZMA while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
std::string BmnFileReaderXzLzma::GetLastUncompressErrorDescription() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    return GetLzmaReturnTypeDescription(fLastReturnStatus);
#else
    return std::string{"BMN NOT BUILT WITH XZ LZMA"};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
bool BmnFileReaderXzLzma::JumpsAllowed() const noexcept
{
    return false;
}
 
void BmnFileReaderXzLzma::JumpTo(size_t)
{
    /*
    In general with XZ LZMA we could allow jumping while carefully building LZMA blocks. Still,
    that would be allowed only in files written by our own encoder, while XZ would not produce
    the same results. Thus, we don't allow jumps no matter what and if jumps are needed, we can
    think about it and adapt later
    */
    LOG(warning) << "Calling `BmnFileReaderXzLzma::JumpTo` while the type doesn't allow jumping!\n";
}
 
size_t BmnFileReaderXzLzma::GetNumberOfDecompressedBytes() const noexcept
{
    return fNumberOfReadBytes;
}
 
bool BmnFileReaderXzLzma::HasReachedTheEndOfStream() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    return fLastReturnStatus == 1;
#else
    return true;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
bool BmnFileReaderXzLzma::IsStreamInGoodState() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    assert(fLastReturnStatus >= 0);
    return fLastReturnStatus < 4;
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
// ========== BmnFileReaderXzLzma methods ==========
 
size_t BmnFileReaderXzLzma::GetUsedMemoryByLZMA() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    if (!fLzmaStream)
        return 0ull;
    return lzma_memusage(&fLzmaStream->fLzmaStream);
#else
    return 0ull;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
}
 
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
// ================== static function definition ==================
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
 
static std::string GetLzmaReturnTypeDescription(const int32_t errorID) noexcept
{
    assert(errorID < 12);
    return GetLzmaReturnTypeDescription(static_cast<lzma_ret>(errorID));
}
 
static std::string GetLzmaReturnTypeDescription(const lzma_ret lzmaReturnEnum) noexcept
{
    switch (lzmaReturnEnum) {
        case lzma_ret::LZMA_OK:
            return std::string{"OK"};
        case LZMA_STREAM_END:
            return std::string{"STREAM END"};
        case LZMA_NO_CHECK:
            return std::string{"NO INFO"};
        case LZMA_UNSUPPORTED_CHECK:
            return std::string{"NO CHECK"};
        case LZMA_GET_CHECK:
            return std::string{"GET CHECK"};   // don't understand this one
        case LZMA_MEM_ERROR:
            return std::string{"MEMORY ALLOCATION FAILED"};
        case LZMA_MEMLIMIT_ERROR:
            return std::string{"MEMORY LIMIT REACHED"};
        case LZMA_FORMAT_ERROR:
            return std::string{"FILE IS NOT XZ LZMA"};
        case LZMA_OPTIONS_ERROR:
            return std::string{"BAD DECODING OPTIONS"};
        case LZMA_DATA_ERROR:
            return std::string{"LZMA DATA CORRUPTED"};
        case LZMA_BUF_ERROR:
            return std::string{"BAD BUFFERS"};
        case LZMA_PROG_ERROR:
            return std::string{"INVALID ARGUMENTS"};
        default:
            // HOW??
            assert(false);
            return std::string{};
    }
}
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
 
#ifndef BMNCOMPRESSION_WITH_XZ_LZMA
RESTORE_UNUSED_PARAM_WARNING
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA