Skip to content

Byte-swap integers to support big endian architectures #61

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
onitake wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Byte-swap integers to support big endian architectures #61

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
1d85888
Byte-swap integer I/O to support big endian architectures
onitake Dec 19, 2025
a9d300d
Remove duplicated I/O code
onitake Dec 20, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 10 additions & 24 deletions src/LibBGCode/binarize/binarize.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,22 +18,6 @@ using namespace core;

namespace binarize {

template<class T>
static bool write_to_file(FILE& file, const T* data, size_t data_size)
{
const size_t wsize = fwrite(static_cast<const void*>(data), 1, data_size, &file);
return !ferror(&file) && wsize == data_size;
}

template<class T>
static bool read_from_file(FILE& file, T *data, size_t data_size)
{
static_assert(!std::is_const_v<T>, "Type of output buffer cannot be const!");

const size_t rsize = fread(static_cast<void *>(data), 1, data_size, &file);
return !ferror(&file) && rsize == data_size;
}

void update_checksum(Checksum& checksum, const ThumbnailBlock &th)
{
checksum.append(th.params.format);
Expand Down Expand Up @@ -420,7 +404,7 @@ core::EResult write(const BaseMetadataBlock &block, FILE& file, core::EBlockType
return res;

// write block payload
if (!write_to_file(file, &block.encoding_type, sizeof(block.encoding_type)))
if (!write_to_file_le(file, block.encoding_type))
return EResult::WriteError;
if (!out_data.empty()) {
if (!write_to_file(file, out_data.data(), out_data.size()))
Expand All @@ -443,7 +427,7 @@ EResult BaseMetadataBlock::read_data(FILE& file, const BlockHeader& block_header
{
const ECompressionType compression_type = (ECompressionType)block_header.compression;

if (!read_from_file(file, (void*)&encoding_type, sizeof(encoding_type)))
if (!read_from_file_le(file, encoding_type))
return EResult::ReadError;
if (encoding_type > metadata_encoding_types_count())
return EResult::InvalidMetadataEncodingType;
Expand All @@ -452,7 +436,7 @@ EResult BaseMetadataBlock::read_data(FILE& file, const BlockHeader& block_header
const size_t data_size = (compression_type == ECompressionType::None) ? block_header.uncompressed_size : block_header.compressed_size;
if (data_size > 0) {
data.resize(data_size);
if (!read_from_file(file, (void*)data.data(), data_size))
if (!read_from_file(file, data.data(), data_size))
return EResult::ReadError;
}

Expand Down Expand Up @@ -638,7 +622,7 @@ EResult ThumbnailBlock::read_data(FILE& file, const FileHeader& file_header, con
return EResult::InvalidThumbnailDataSize;

data.resize(block_header.uncompressed_size);
if (!read_from_file(file, (void*)data.data(), block_header.uncompressed_size))
if (!read_from_file(file, data.data(), block_header.uncompressed_size))
return EResult::ReadError;

const EChecksumType checksum_type = (EChecksumType)file_header.checksum_type;
Expand Down Expand Up @@ -683,7 +667,7 @@ EResult GCodeBlock::write(FILE& file, ECompressionType compression_type, EChecks
return res;

// write block payload
if (!write_to_file(file, &encoding_type, sizeof(encoding_type)))
if (!write_to_file_le(file, encoding_type))
return EResult::WriteError;
if (!out_data.empty()) {
if (!write_to_file(file, out_data.data(), out_data.size()))
Expand All @@ -696,8 +680,10 @@ EResult GCodeBlock::write(FILE& file, ECompressionType compression_type, EChecks
// update checksum with block header
update_checksum(cs, block_header);
// update checksum with block payload
std::array<std::byte, sizeof(encoding_type)> swapped_encoding;
store_integer_le(encoding_type, swapped_encoding.data());
std::vector<uint8_t> data_to_encode =
encode(reinterpret_cast<const std::byte*>(&encoding_type), sizeof(encoding_type));
encode(swapped_encoding.data(), swapped_encoding.size());
cs.append(data_to_encode.data(), data_to_encode.size());
if (!out_data.empty())
cs.append(static_cast<unsigned char *>(out_data.data()), out_data.size());
Expand All @@ -713,7 +699,7 @@ EResult GCodeBlock::read_data(FILE& file, const FileHeader& file_header, const B
{
const ECompressionType compression_type = (ECompressionType)block_header.compression;

if (!read_from_file(file, (void*)&encoding_type, sizeof(encoding_type)))
if (!read_from_file_le(file, encoding_type))
return EResult::ReadError;
if (encoding_type > gcode_encoding_types_count())
return EResult::InvalidGCodeEncodingType;
Expand All @@ -722,7 +708,7 @@ EResult GCodeBlock::read_data(FILE& file, const FileHeader& file_header, const B
const size_t data_size = (compression_type == ECompressionType::None) ? block_header.uncompressed_size : block_header.compressed_size;
if (data_size > 0) {
data.resize(data_size);
if (!read_from_file(file, (void*)data.data(), data_size))
if (!read_from_file(file, data.data(), data_size))
return EResult::ReadError;
}

Expand Down
56 changes: 20 additions & 36 deletions src/LibBGCode/core/core.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,22 +3,6 @@

namespace bgcode { namespace core {

template<class T>
static bool write_to_file(FILE& file, const T* data, size_t data_size)
{
const size_t wsize = fwrite(static_cast<const void*>(data), 1, data_size, &file);
return !ferror(&file) && wsize == data_size;
}

template<class T>
static bool read_from_file(FILE& file, T *data, size_t data_size)
{
static_assert(!std::is_const_v<T>, "Type of output buffer cannot be const!");

const size_t rsize = fread(static_cast<void *>(data), 1, data_size, &file);
return !ferror(&file) && rsize == data_size;
}

EResult verify_block_checksum(FILE& file, const FileHeader& file_header,
const BlockHeader& block_header, std::byte* buffer, size_t buffer_size)
{
Expand Down Expand Up @@ -112,29 +96,29 @@ EResult FileHeader::write(FILE& file) const
if (checksum_type >= checksum_types_count())
return EResult::InvalidChecksumType;

if (!write_to_file(file, &magic, sizeof(magic)))
if (!write_to_file_le(file, magic))
return EResult::WriteError;
if (!write_to_file(file, &version, sizeof(version)))
if (!write_to_file_le(file, version))
return EResult::WriteError;
if (!write_to_file(file, &checksum_type, sizeof(checksum_type)))
if (!write_to_file_le(file, checksum_type))
return EResult::WriteError;

return EResult::Success;
}

EResult FileHeader::read(FILE& file, const uint32_t* const max_version)
{
if (!read_from_file(file, &magic, sizeof(magic)))
if (!read_from_file_le(file, magic))
return EResult::ReadError;
if (magic != MAGICi32)
return EResult::InvalidMagicNumber;

if (!read_from_file(file, &version, sizeof(version)))
if (!read_from_file_le(file, version))
return EResult::ReadError;
if (max_version != nullptr && version > *max_version)
return EResult::InvalidVersionNumber;

if (!read_from_file(file, &checksum_type, sizeof(checksum_type)))
if (!read_from_file_le(file, checksum_type))
return EResult::ReadError;
if (checksum_type >= checksum_types_count())
return EResult::InvalidChecksumType;
Expand All @@ -157,14 +141,14 @@ long BlockHeader::get_position() const
EResult BlockHeader::write(FILE& file)
{
m_position = ftell(&file);
if (!write_to_file(file, &type, sizeof(type)))
if (!write_to_file_le(file, type))
return EResult::WriteError;
if (!write_to_file(file, &compression, sizeof(compression)))
if (!write_to_file_le(file, compression))
return EResult::WriteError;
if (!write_to_file(file, &uncompressed_size, sizeof(uncompressed_size)))
if (!write_to_file_le(file, uncompressed_size))
return EResult::WriteError;
if (compression != (uint16_t)ECompressionType::None) {
if (!write_to_file(file, &compressed_size, sizeof(compressed_size)))
if (!write_to_file_le(file, compressed_size))
return EResult::WriteError;
}
return EResult::Success;
Expand All @@ -173,20 +157,20 @@ EResult BlockHeader::write(FILE& file)
EResult BlockHeader::read(FILE& file)
{
m_position = ftell(&file);
if (!read_from_file(file, &type, sizeof(type)))
if (!read_from_file_le(file, type))
return EResult::ReadError;
if (type >= block_types_count())
return EResult::InvalidBlockType;

if (!read_from_file(file, &compression, sizeof(compression)))
if (!read_from_file_le(file, compression))
return EResult::ReadError;
if (compression >= compression_types_count())
return EResult::InvalidCompressionType;

if (!read_from_file(file, &uncompressed_size, sizeof(uncompressed_size)))
if (!read_from_file_le(file, uncompressed_size))
return EResult::ReadError;
if (compression != (uint16_t)ECompressionType::None) {
if (!read_from_file(file, &compressed_size, sizeof(compressed_size)))
if (!read_from_file_le(file, compressed_size))
return EResult::ReadError;
}

Expand All @@ -199,21 +183,21 @@ size_t BlockHeader::get_size() const {
}

EResult ThumbnailParams::write(FILE& file) const {
if (!write_to_file(file, &format, sizeof(format)))
if (!write_to_file_le(file, format))
return EResult::WriteError;
if (!write_to_file(file, &width, sizeof(width)))
if (!write_to_file_le(file, width))
return EResult::WriteError;
if (!write_to_file(file, &height, sizeof(height)))
if (!write_to_file_le(file, height))
return EResult::WriteError;
return EResult::Success;
}

EResult ThumbnailParams::read(FILE& file){
if (!read_from_file(file, &format, sizeof(format)))
if (!read_from_file_le(file, format))
return EResult::ReadError;
if (!read_from_file(file, &width, sizeof(width)))
if (!read_from_file_le(file, width))
return EResult::ReadError;
if (!read_from_file(file, &height, sizeof(height)))
if (!read_from_file_le(file, height))
return EResult::ReadError;
return EResult::Success;
}
Expand Down
43 changes: 42 additions & 1 deletion src/LibBGCode/core/core_impl.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -120,7 +120,7 @@ class BGCODE_CORE_EXPORT Checksum

// Append any aritmetic data to the checksum (shorthand for aritmetic types)
template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
void append(T& data) { append(reinterpret_cast<const std::byte*>(&data), sizeof(data)); }
void append(T& data);

// Returns true if the given checksum is equal to this one
bool matches(Checksum& other);
Expand Down Expand Up @@ -168,12 +168,53 @@ void Checksum::append(const BufT *data, size_t size)
}
}

template<typename T, typename>
void Checksum::append(T& data)
{
std::array<std::byte, sizeof(T)> temp;
store_integer_le(data, temp.begin(), temp.size());
append(temp.data(), temp.size());
}

static constexpr auto MAGICi32 = load_integer<uint32_t>(std::begin(MAGIC), std::end(MAGIC));

constexpr auto checksum_types_count() noexcept { auto v = to_underlying(EChecksumType::CRC32); ++v; return v;}
constexpr auto block_types_count() noexcept { auto v = to_underlying(EBlockType::Thumbnail); ++v; return v; }
constexpr auto compression_types_count() noexcept { auto v = to_underlying(ECompressionType::Heatshrink_12_4); ++v; return v; }

template<class BufT>
static bool write_to_file(FILE& file, const BufT* data, size_t data_size)
{
const size_t wsize = fwrite(static_cast<const void*>(data), 1, data_size, &file);
return !ferror(&file) && wsize == data_size;
}

template<class T>
static bool write_to_file_le(FILE& file, const T &data)
{
std::array<std::byte, sizeof(T)> temp;
store_integer_le(data, temp.begin(), temp.size());
return write_to_file(file, temp.data(), temp.size());
}

template<class BufT>
static bool read_from_file(FILE& file, BufT *data, size_t data_size)
{
const size_t rsize = fread(static_cast<BufT *>(data), 1, data_size, &file);
return !ferror(&file) && rsize == data_size;
}

template<class T>
static bool read_from_file_le(FILE& file, T &data)
{
std::array<std::byte, sizeof(T)> temp;
if (!read_from_file(file, temp.data(), temp.size())) {
return false;
}
data = load_integer<T>(temp.begin(), temp.end());
return true;
}

} // namespace core
} // namespace bgcode

Expand Down