summaryrefslogtreecommitdiffhomepage
path: root/src/boot/BootKit
diff options
context:
space:
mode:
Diffstat (limited to 'src/boot/BootKit')
-rw-r--r--src/boot/BootKit/BitManip.h20
-rw-r--r--src/boot/BootKit/BootKit.h335
-rw-r--r--src/boot/BootKit/BootThread.h41
-rw-r--r--src/boot/BootKit/Device.h35
-rw-r--r--src/boot/BootKit/EPM.h9
-rw-r--r--src/boot/BootKit/HW/ATA.h47
-rw-r--r--src/boot/BootKit/HW/SATA.h42
-rw-r--r--src/boot/BootKit/Platform.h32
-rw-r--r--src/boot/BootKit/Protocol.h10
-rw-r--r--src/boot/BootKit/Qr.h797
-rw-r--r--src/boot/BootKit/QrPrelude.h1
-rw-r--r--src/boot/BootKit/Shared/base.h24
-rw-r--r--src/boot/BootKit/Shared/bit.h228
-rw-r--r--src/boot/BootKit/Support.h145
14 files changed, 1766 insertions, 0 deletions
diff --git a/src/boot/BootKit/BitManip.h b/src/boot/BootKit/BitManip.h
new file mode 100644
index 00000000..32795328
--- /dev/null
+++ b/src/boot/BootKit/BitManip.h
@@ -0,0 +1,20 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#ifndef __BITMANIP_H__
+#define __BITMANIP_H__
+
+/// File: BitManip.h
+/// Purpose: Bit manipulation helpers, based on neboot-dev.
+
+#define bk_set_bit(X, O) X = (1 << O) | X
+#define bk_clear_bit(X, O) X = ~(1 << O) & X
+#define bk_toogle(X, O) X = (1 << O) ^ X
+#define bk_lsb(X) X = X & -X
+#define bk_msb(X) X = -(mp_lsb(X)) & X
+#define bk_look_for_bit(X, O) (1 << O) | X
+
+#endif // ifndef __BITMANIP_H__
diff --git a/src/boot/BootKit/BootKit.h b/src/boot/BootKit/BootKit.h
new file mode 100644
index 00000000..e1a2b628
--- /dev/null
+++ b/src/boot/BootKit/BootKit.h
@@ -0,0 +1,335 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+/***********************************************************************************/
+/// @file BootKit.h
+/// @brief Bootloader Application Programming Interface.
+/***********************************************************************************/
+
+#pragma once
+
+#include <BootKit/HW/ATA.h>
+#include <CompilerKit/Version.h>
+#include <modules/CoreGfx/CoreGfx.h>
+
+/// include NeFS header and Support header as well.
+
+#include <BootKit/Support.h>
+#include <FSKit/NeFS.h>
+
+/***********************************************************************************/
+/// Include other APIs.
+/***********************************************************************************/
+
+#include <NeKit/Defines.h>
+#include <modules/ATA/ATA.h>
+
+#include <FirmwareKit/EFI.h>
+#include <FirmwareKit/EPM.h>
+#include <FirmwareKit/GPT.h>
+#include <FirmwareKit/VEPM.h>
+
+#define kBKBootFileMime "boot-x/file"
+#define kBKBootDirMime "boot-x/dir"
+
+/***********************************************************************************/
+/// Framebuffer helpers.
+/***********************************************************************************/
+
+namespace Boot {
+void ThrowError(const WideChar* errorCode, const WideChar* reason) noexcept;
+
+class BootTextWriter;
+class BootFileReader;
+class BootThread;
+class BVersionString;
+
+typedef Char* PEFImagePtr;
+typedef Char* PEImagePtr;
+
+typedef WideChar CharacterTypeUTF16;
+typedef Char CharacterTypeASCII;
+typedef char8_t CharacterTypeUTF8;
+
+using namespace Kernel;
+
+/**
+ * @brief BootKit Text Writer class
+ * Writes to UEFI StdOut.
+ */
+class BootTextWriter final {
+ BootTextWriter& _Write(const UInt64& num);
+
+ public:
+ BootTextWriter& Write(const UInt64& num);
+ BootTextWriter& Write(const Char* str);
+ BootTextWriter& Write(const CharacterTypeUTF16* str);
+ BootTextWriter& WriteCharacter(CharacterTypeUTF16 c);
+ BootTextWriter& Write(const UChar* str);
+
+ template <typename T>
+ BootTextWriter& operator<<(T elem) {
+ this->Write(elem);
+ return *this;
+ }
+
+ public:
+ explicit BootTextWriter() = default;
+ ~BootTextWriter() = default;
+
+ public:
+ BootTextWriter& operator=(const BootTextWriter&) = default;
+ BootTextWriter(const BootTextWriter&) = default;
+};
+
+Kernel::SizeT BCopyMem(CharacterTypeUTF16* dest, CharacterTypeUTF16* src, const Kernel::SizeT len);
+
+Kernel::SizeT BSetMem(CharacterTypeASCII* src, const CharacterTypeASCII byte,
+ const Kernel::SizeT len);
+
+/// String length functions.
+
+/// @brief get string length.
+Kernel::SizeT BStrLen(const CharacterTypeUTF16* ptr);
+
+/// @brief set memory with custom value.
+Kernel::SizeT BSetMem(CharacterTypeUTF16* src, const CharacterTypeUTF16 byte,
+ const Kernel::SizeT len);
+
+/**
+ * @brief BootKit File Reader class
+ * Reads the Firmware Boot partition and filesystem.
+ */
+class BootFileReader final {
+ public:
+ explicit BootFileReader(const CharacterTypeUTF16* path, EfiHandlePtr ImageHandle);
+ ~BootFileReader();
+
+ public:
+ Void ReadAll(SizeT until, SizeT chunk = kib_cast(4), UIntPtr out_address = 0UL);
+
+ enum {
+ kOperationOkay,
+ kNotSupported,
+ kEmptyDirectory,
+ kNoSuchEntry,
+ kIsDirectory,
+ kTooSmall,
+ kCount,
+ };
+
+ /// @brief error code getter.
+ /// @return the error code.
+ Int32& Error();
+
+ /// @brief blob getter.
+ /// @return the blob.
+ VoidPtr Blob();
+
+ /// @breif Size getter.
+ /// @return the size of the file.
+ UInt64& Size();
+
+ public:
+ BootFileReader& operator=(const BootFileReader&) = default;
+ BootFileReader(const BootFileReader&) = default;
+
+ private:
+ Int32 mErrorCode{kOperationOkay};
+ VoidPtr mBlob{nullptr};
+ CharacterTypeUTF16 mPath[kPathLen];
+ BootTextWriter mWriter;
+ EfiFileProtocol* mFile{nullptr};
+ UInt64 mSizeFile{0};
+ EfiFileProtocol* mRootFs;
+};
+
+typedef UInt8* BlobType;
+
+/// @brief Bootloader Version String.
+class BVersionString final {
+ public:
+ static const CharacterTypeASCII* The() { return BOOTLOADER_VERSION; }
+};
+
+/***********************************************************************************/
+/// Provide some useful processor features.
+/***********************************************************************************/
+
+#ifdef __EFI_x86_64__
+
+/***
+ * Common processor instructions.
+ */
+
+EXTERN_C void rt_out8(UInt16 port, UInt8 value);
+EXTERN_C void rt_out16(UInt16 port, UInt16 value);
+EXTERN_C void rt_out32(UInt16 port, UInt32 value);
+EXTERN_C UInt8 rt_in8(UInt16 port);
+EXTERN_C UInt16 rt_in16(UInt16 port);
+EXTERN_C UInt32 rt_in32(UInt16 port);
+
+EXTERN_C void rt_halt();
+EXTERN_C void rt_cli();
+EXTERN_C void rt_sti();
+EXTERN_C void rt_cld();
+EXTERN_C void rt_std();
+
+#endif // __EFI_x86_64__
+
+/// @brief BootKit Drive Formatter.
+template <typename BootDev>
+class BDiskFormatFactory final {
+ public:
+ /// @brief File entry for **BDiskFormatFactory**.
+ struct BFileDescriptor final {
+ Char fFileName[kNeFSCatalogNameLen];
+ Int32 fKind;
+ };
+
+ public:
+ explicit BDiskFormatFactory() = default;
+ ~BDiskFormatFactory() = default;
+
+ NE_COPY_DELETE(BDiskFormatFactory)
+
+ /// @brief Format disk using partition name and blob.
+ /// @param Partition part_name the target partition name.
+ /// @param blob blobs array.
+ /// @param blob_sz blobs array count.
+ /// @retval True disk has been formatted.
+ /// @retval False failed to format.
+ Boolean Format(const Char* part_name);
+
+ /// @brief check if partition is good.
+ Bool IsPartitionValid() noexcept {
+#if defined(BOOTZ_EPM_SUPPORT)
+ fDiskDev.Leak().mBase = (kEPMBootBlockLba);
+ fDiskDev.Leak().mSize = sizeof(EPM_PART_BLOCK);
+
+ EPM_PART_BLOCK buf_epm = {};
+
+ fDiskDev.Read((Char*) &buf_epm, sizeof(EPM_PART_BLOCK));
+
+ if (StrCmp(buf_epm.Magic, kEPMMagic) > 0) {
+ return false;
+ }
+
+ if (buf_epm.Version != kEPMRevisionBcd) {
+ return false;
+ }
+
+ BootTextWriter writer;
+ writer.Write("BootZ: EPM Partition found.\r");
+
+ return true;
+#else
+ GPT_PARTITION_TABLE* gpt_part = (GPT_PARTITION_TABLE*) RTL_ALLOCA(sizeof(GPT_PARTITION_TABLE));
+
+ fDiskDev.Leak().mBase = (kGPTPartitionTableLBA);
+ fDiskDev.Leak().mSize = sizeof(GPT_PARTITION_TABLE);
+
+ fDiskDev.Read((Char*) gpt_part, sizeof(GPT_PARTITION_TABLE));
+
+ BootTextWriter writer;
+
+ if (StrCmp(gpt_part->Signature, kMagicGPT) == 0) {
+ writer.Write("BootZ: GPT Partition found.\r");
+ return true;
+ }
+
+ writer.Write("BootZ: No Partition found.\r");
+
+ return false;
+#endif
+ }
+
+ private:
+ BootDev fDiskDev;
+};
+
+/// @brief Format disk with a specific partition scheme.
+/// @param part_name partition Name
+/// @retval True disk has been formatted.
+/// @retval False failed to format.
+template <typename BootDev>
+inline Boolean BDiskFormatFactory<BootDev>::Format(const Char* part_name) {
+#if defined(BOOTZ_EPM_SUPPORT)
+ EPM_PART_BLOCK* epm_boot = (EPM_PART_BLOCK*) RTL_ALLOCA(sizeof(EPM_PART_BLOCK));
+
+ const auto kFsName = "NeKernel";
+ const auto kBlockName = " NeKernelOS";
+
+ epm_boot->FsVersion = 0;
+ epm_boot->LbaStart = sizeof(EPM_PART_BLOCK);
+ epm_boot->LbaEnd = fDiskDev.GetDiskSize() - 1;
+ epm_boot->SectorSz = BootDev::kSectorSize;
+ epm_boot->Kind = kEPMNeKernel;
+ epm_boot->NumBlocks = 1;
+
+ epm_boot->Guid = kEPMNilGuid;
+
+ CopyMem(epm_boot->Fs, reinterpret_cast<VoidPtr>(const_cast<Char*>(kFsName)), StrLen(kFsName));
+ CopyMem(epm_boot->Name, reinterpret_cast<VoidPtr>(const_cast<Char*>(kBlockName)),
+ StrLen(kBlockName));
+ CopyMem(epm_boot->Magic, reinterpret_cast<VoidPtr>(const_cast<Char*>(kEPMMagic)),
+ StrLen(kEPMMagic));
+
+ fDiskDev.Leak().mBase = kEPMBootBlockLba; // always always resies at zero block.
+ fDiskDev.Leak().mSize = sizeof(EPM_PART_BLOCK);
+
+ fDiskDev.Write((Char*) epm_boot, sizeof(EPM_PART_BLOCK));
+
+ BootTextWriter writer;
+ writer.Write(L"BootZ: Drive is EPM formatted.\r");
+#elif defined(BOOTZ_GPT_SUPPORT)
+ NE_UNUSED(part_name);
+
+ GPT_PARTITION_TABLE* gpt_part = (GPT_PARTITION_TABLE*) RTL_ALLOCA(sizeof(GPT_PARTITION_TABLE));
+
+ CopyMem(gpt_part->Signature, reinterpret_cast<VoidPtr>(const_cast<Char*>(kMagicGPT)),
+ StrLen(kMagicGPT));
+
+ gpt_part->Revision = 0x00010000;
+ gpt_part->HeaderSize = sizeof(GPT_PARTITION_TABLE);
+
+ gpt_part->CRC32 = 0x00000000;
+
+ gpt_part->Reserved1 = 0x00000000;
+ gpt_part->LBAHeader = 0x00000000;
+ gpt_part->LBAAltHeader = 0x00000000;
+ gpt_part->FirstGPTEntry = 0x00000000;
+ gpt_part->LastGPTEntry = 0x00000000;
+
+ gpt_part->Guid.Data1 = 0x00000000;
+ gpt_part->Guid.Data2 = 0x0000;
+ gpt_part->Guid.Data3 = 0x0000;
+
+ SetMem(gpt_part->Guid.Data4, 0, 8);
+
+ gpt_part->Revision = 0x00010000;
+
+ gpt_part->StartingLBA = 0x00000000;
+ gpt_part->NumPartitionEntries = 0x00000000;
+ gpt_part->SizeOfEntries = 0x00000000;
+ gpt_part->CRC32PartEntry = 0x00000000;
+
+ SetMem(gpt_part->Reserved2, 0, kSectorAlignGPT_PartTbl);
+
+ fDiskDev.Leak().mBase = kGPTPartitionTableLBA; // always always resies at zero block.
+ fDiskDev.Leak().mSize = sizeof(GPT_PARTITION_TABLE);
+
+ fDiskDev.Write((Char*) gpt_part, sizeof(GPT_PARTITION_TABLE));
+
+ BootTextWriter writer;
+ writer.Write(L"BootZ: Drive is GPT formatted.\r");
+#else
+ NE_UNUSED(part_name);
+#endif
+
+ return YES;
+}
+} // namespace Boot
diff --git a/src/boot/BootKit/BootThread.h b/src/boot/BootKit/BootThread.h
new file mode 100644
index 00000000..abe4d653
--- /dev/null
+++ b/src/boot/BootKit/BootThread.h
@@ -0,0 +1,41 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <FirmwareKit/Handover.h>
+#include <KernelKit/MSDOS.h>
+#include <KernelKit/PE.h>
+
+namespace Boot {
+using namespace Kernel;
+
+class BootThread;
+
+/// @brief Bootloader Thread class.
+class BootThread final {
+ public:
+ explicit BootThread() = delete;
+ ~BootThread() = default;
+
+ explicit BootThread(Kernel::VoidPtr blob);
+
+ BootThread& operator=(const BootThread&) = default;
+ BootThread(const BootThread&) = default;
+
+ Int32 Start(HEL::BootInfoHeader* handover, BOOL is_own_stack);
+ void SetName(const char* name);
+ const char* GetName();
+ bool IsValid();
+
+ private:
+ Char fBlobName[256U] = {"BootThread"};
+ VoidPtr fStartAddress{nullptr};
+ VoidPtr fBlob{nullptr};
+ UInt8* fStack{nullptr};
+ HEL::BootInfoHeader* fHandover{nullptr};
+};
+} // namespace Boot
diff --git a/src/boot/BootKit/Device.h b/src/boot/BootKit/Device.h
new file mode 100644
index 00000000..36e2b3d4
--- /dev/null
+++ b/src/boot/BootKit/Device.h
@@ -0,0 +1,35 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <modules/AHCI/AHCI.h>
+#include <modules/ATA/ATA.h>
+
+namespace Kernel {
+/// @brief Device type.
+class Device {
+ public:
+ explicit Device() = default;
+ virtual ~Device() = default;
+
+ NE_MOVE_DEFAULT(Device)
+
+ struct Trait {
+ SizeT mBase{0};
+ SizeT mSize{0};
+ };
+
+ virtual Trait& Leak() = 0;
+
+ virtual Device& Read(Char* Buf, SizeT SecCount) = 0;
+ virtual Device& Write(Char* Buf, SizeT SecCount) = 0;
+};
+
+typedef Device BootDevice;
+typedef Device NetworkDevice;
+typedef Device DiskDevice;
+} // namespace Kernel \ No newline at end of file
diff --git a/src/boot/BootKit/EPM.h b/src/boot/BootKit/EPM.h
new file mode 100644
index 00000000..cc82dd41
--- /dev/null
+++ b/src/boot/BootKit/EPM.h
@@ -0,0 +1,9 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <FirmwareKit/EPM.h>
diff --git a/src/boot/BootKit/HW/ATA.h b/src/boot/BootKit/HW/ATA.h
new file mode 100644
index 00000000..25629869
--- /dev/null
+++ b/src/boot/BootKit/HW/ATA.h
@@ -0,0 +1,47 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <BootKit/Device.h>
+#include <modules/ATA/ATA.h>
+
+using namespace Kernel;
+
+class BootDeviceATA final : public Device {
+ public:
+ enum {
+ kPrimary = ATA_PRIMARY_IO,
+ kSecondary = ATA_SECONDARY_IO,
+ };
+
+ explicit BootDeviceATA() noexcept;
+ ~BootDeviceATA() = default;
+
+ enum { kSectorSize = kATASectorSize };
+
+ struct ATATrait final : public Device::Trait {
+ UInt16 mBus{kPrimary};
+ UInt8 mMaster{0};
+ Boolean mErr{false};
+
+ operator bool() { return !mErr; }
+ };
+
+ public:
+ operator bool();
+
+ SizeT GetSectorsCount() noexcept;
+ SizeT GetDiskSize() noexcept;
+
+ BootDeviceATA& Read(Char* Buf, SizeT SecCount) override;
+ BootDeviceATA& Write(Char* Buf, SizeT SecCount) override;
+
+ ATATrait& Leak() override;
+
+ private:
+ ATATrait mTrait;
+};
diff --git a/src/boot/BootKit/HW/SATA.h b/src/boot/BootKit/HW/SATA.h
new file mode 100644
index 00000000..07ce7611
--- /dev/null
+++ b/src/boot/BootKit/HW/SATA.h
@@ -0,0 +1,42 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <BootKit/BootKit.h>
+#include <CompilerKit/CompilerKit.h>
+#include <modules/AHCI/AHCI.h>
+
+#define kAHCISectorSz (512)
+
+class BootDeviceSATA final {
+ public:
+ explicit BootDeviceSATA() noexcept;
+ ~BootDeviceSATA() = default;
+
+ NE_COPY_DEFAULT(BootDeviceSATA)
+
+ struct SATATrait final : public Device::Trait {
+ Kernel::Boolean mErr{false};
+ Kernel::Boolean mDetected{false};
+
+ operator bool() { return !this->mErr; }
+ };
+
+ operator bool() { return this->Leak().mDetected; }
+
+ SizeT GetDiskSize() { return drv_std_get_size(); }
+
+ constexpr static auto kSectorSize = kAHCISectorSize;
+
+ BootDeviceSATA& Read(Boot::CharacterTypeASCII* Buf, const Kernel::SizeT SecCount);
+ BootDeviceSATA& Write(Boot::CharacterTypeASCII* Buf, const Kernel::SizeT SecCount);
+
+ SATATrait& Leak();
+
+ private:
+ SATATrait mTrait;
+};
diff --git a/src/boot/BootKit/Platform.h b/src/boot/BootKit/Platform.h
new file mode 100644
index 00000000..bfc738fc
--- /dev/null
+++ b/src/boot/BootKit/Platform.h
@@ -0,0 +1,32 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+/**
+ @file Platform.h
+ @brief Platform specific code.
+*/
+
+#ifdef __x86_64__
+
+#ifdef __cplusplus
+#ifndef EXTERN_C
+#define EXTERN_C extern "C"
+#endif
+#else
+#ifndef EXTERN_C
+#define EXTERN_C extern
+#endif
+#endif // __cplusplus
+
+EXTERN_C void rt_halt();
+EXTERN_C void rt_cli();
+EXTERN_C void rt_sti();
+EXTERN_C void rt_cld();
+EXTERN_C void rt_std();
+
+#endif /* ifdef __x86_64__ */
diff --git a/src/boot/BootKit/Protocol.h b/src/boot/BootKit/Protocol.h
new file mode 100644
index 00000000..0a049b77
--- /dev/null
+++ b/src/boot/BootKit/Protocol.h
@@ -0,0 +1,10 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <FirmwareKit/EFI.h>
+#include <FirmwareKit/Handover.h>
diff --git a/src/boot/BootKit/Qr.h b/src/boot/BootKit/Qr.h
new file mode 100644
index 00000000..f537aa5e
--- /dev/null
+++ b/src/boot/BootKit/Qr.h
@@ -0,0 +1,797 @@
+#ifndef QR_H
+#define QR_H
+
+#include <BootKit/Shared/base.h>
+#include <BootKit/Shared/bit.h>
+
+#include <BootKit/QrPrelude.h>
+#include <BootKit/Support.h>
+#include <CompilerKit/Detail.h>
+#include <modules/CoreGfx/CoreGfx.h>
+
+/// @note the QR code is still code 128, it utilizes the same concept of having it's own character
+/// set.
+
+namespace qr {
+inline uint8_t min_poly = 0b11101, /* Minimal polynomial x^8 + x^4 + x^3 + x^2 + 1 */
+ generator = 0b10; /* Generator of Galois field */
+
+/// @brief galois finite field multiplication.
+inline uint8_t gf_mul(uint8_t a, uint8_t b) {
+ uint8_t res = 0;
+
+ for (; b; b >>= 1) {
+ if (b & 1) res ^= a;
+ if (a & 0x80)
+ a = (a << 1) ^ min_poly;
+ else
+ a <<= 1;
+ }
+
+ return res;
+}
+
+// Size of Ecc block with respect to level and version. 0 version is for
+// padding.
+constexpr int ECC_CODEWORDS_PER_BLOCK[4][41] = {
+ {0, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28,
+ 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},
+ {0, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26,
+ 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28},
+ {0, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30,
+ 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},
+ {0, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28,
+ 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},
+};
+
+// Number of Ecc blocks with respect to level and version. 0 version is for
+// padding.
+constexpr int N_ECC_BLOCKS[4][41] = {
+ {0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8,
+ 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25},
+ {0, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16,
+ 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49},
+ {0, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20,
+ 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68},
+ {0, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25,
+ 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81},
+};
+
+// Positions of central modules of alignment patterns according to version. 0
+// version is for padding.
+constexpr int ALIGN_POS[41][7] = {
+ {},
+ {0},
+ {6, 18},
+ {6, 22},
+ {6, 26},
+ {6, 30},
+ {6, 34},
+ {6, 22, 38},
+ {6, 24, 42},
+ {6, 26, 46},
+ {6, 28, 50},
+ {6, 30, 54},
+ {6, 32, 58},
+ {6, 34, 62},
+ {6, 26, 46, 66},
+ {6, 26, 48, 70},
+ {6, 26, 50, 74},
+ {6, 30, 54, 78},
+ {6, 30, 56, 82},
+ {6, 30, 58, 86},
+ {6, 34, 62, 90},
+ {6, 28, 50, 72, 94},
+ {6, 26, 50, 74, 98},
+ {6, 30, 54, 78, 102},
+ {6, 28, 54, 80, 106},
+ {6, 32, 58, 84, 110},
+ {6, 30, 58, 86, 114},
+ {6, 34, 62, 90, 118},
+ {6, 26, 50, 74, 98, 122},
+ {6, 30, 54, 78, 102, 126},
+ {6, 26, 52, 78, 104, 130},
+ {6, 30, 56, 82, 108, 134},
+ {6, 34, 60, 86, 112, 138},
+ {6, 30, 58, 86, 114, 142},
+ {6, 34, 62, 90, 118, 146},
+ {6, 30, 54, 78, 102, 126, 150},
+ {6, 24, 50, 76, 102, 128, 154},
+ {6, 28, 54, 80, 106, 132, 158},
+ {6, 32, 58, 84, 110, 136, 162},
+ {6, 26, 54, 82, 110, 138, 166},
+ {6, 30, 58, 86, 114, 142, 170},
+};
+
+// Return n-th bit of arr starting from MSB.
+constexpr uint8_t get_bit_r(uint8_t* arr, int n) {
+ return (arr[n >> 3] >> (7 - (n & 7))) & 1;
+}
+
+// Add up to 16 bits to arr. Data starts from MSB as well as each byte of an
+// array.
+constexpr void add_bits(uint16_t data, int n, uint8_t* arr, size_t& pos) {
+ while (n--) {
+ arr[pos >> 3] |= ((data >> n) & 1) << (7 - (pos & 7));
+ ++pos;
+ }
+}
+
+// Translate char to alphanumeric encoding value,
+constexpr int alphanumeric(char c) {
+ if (c >= '0' && c <= '9') return c - '0';
+
+ if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
+
+ switch (c) {
+ case ' ':
+ return 36;
+ case '$':
+ return 37;
+ case '%':
+ return 38;
+ case '*':
+ return 39;
+ case '+':
+ return 40;
+ case '-':
+ return 41;
+ case '.':
+ return 42;
+ case '/':
+ return 43;
+ case ':':
+ return 44;
+ }
+ return -1;
+}
+
+// Check if string can be encoded in alphanumeric mode.
+constexpr bool is_alphanumeric(const char* str, size_t len) {
+ for (size_t i = 0; i < len; ++i)
+ if (alphanumeric(str[i]) == -1) return false;
+ return true;
+}
+
+// Check if string can be encoded in numeric mode.
+constexpr bool is_numeric(const char* str, size_t len) {
+ for (size_t i = 0; i < len; ++i)
+ if (str[i] < '0' || str[i] > '9') return false;
+ return true;
+}
+
+// Check if string can be encoded in kanji mode.
+constexpr bool is_kanji(const char* str, size_t len) {
+ for (size_t i = 0; i < len; i += 2) {
+ uint16_t val = uint16_t(str[i]) | (uint16_t(str[i + 1]) << 8);
+ if (val < 0x8140 || val > 0xebbf || (val > 0x9ffc && val < 0xe040)) return false;
+ }
+ return true;
+}
+
+// Reed-Solomon Ecc generator polynomial for the given degree.
+constexpr void gf_gen_poly(int degree, uint8_t* poly) {
+ SetMem(poly, 0, degree);
+
+ uint8_t root = poly[degree - 1] = 1;
+
+ for (int i = 0; i < degree; ++i) {
+ for (int j = 0; j < degree - 1; ++j) poly[j] = gf_mul(poly[j], root) ^ poly[j + 1];
+ poly[degree - 1] = gf_mul(poly[degree - 1], root);
+ root = (root << 1) ^ ((root >> 7) * 0x11d);
+ }
+}
+
+// Polynomial division if Galois Field.
+constexpr void gf_poly_div(uint8_t* dividend, size_t len, uint8_t* divisor, int degree,
+ uint8_t* result) {
+ SetMem(result, 0, degree);
+
+ for (size_t i = 0; i < len; ++i) {
+ uint8_t factor = dividend[i] ^ result[0];
+ MoveMem(&result[0], &result[1], degree - 1);
+ result[degree - 1] = 0;
+ for (int j = 0; j < degree; ++j) result[j] ^= gf_mul(divisor[j], factor);
+ }
+}
+
+enum Ecc {
+ L,
+ M,
+ Q,
+ H,
+};
+
+enum Mode {
+ M_NUMERIC,
+ M_ALPHANUMERIC,
+ M_BYTE,
+ M_KANJI,
+};
+
+// Select appropriate encoding mode for string.
+constexpr Mode select_mode(const char* str, size_t len) {
+ if (is_numeric(str, len)) return M_NUMERIC;
+ if (is_alphanumeric(str, len)) return M_ALPHANUMERIC;
+ if (is_kanji(str, len)) return M_KANJI;
+ return M_BYTE;
+}
+
+// Return size of Character Control Indicator in bits for given version and
+// mode.
+constexpr int cci(int ver, Mode mode) {
+ constexpr int cnt[4][3] = {
+ {10, 12, 14},
+ {9, 11, 13},
+ {8, 16, 16},
+ {8, 10, 12},
+ };
+ if (ver < 10) return cnt[mode][0];
+ if (ver < 27) return cnt[mode][1];
+ return cnt[mode][2];
+}
+
+template <int V>
+struct Qr {
+ private:
+ friend class QrDelegate;
+ bool draw(int x, int y) noexcept;
+
+ public:
+ constexpr auto side_size() const { return SIDE; }
+
+ bool module(int x, int y);
+ bool encode(const char* str, size_t len, Ecc ecc, int mask = -1);
+
+ private:
+ bool encode_data(const char* data, size_t len, Ecc ecc, uint8_t* out);
+ void encode_ecc(uint8_t* data, Ecc ecc, uint8_t* out);
+
+ void add_data(uint8_t* data, uint8_t* patterns);
+ void add_patterns();
+ void add_version();
+ void add_format(Ecc ecc, int mask);
+ void reserve_patterns(uint8_t* out);
+
+ template <bool Black>
+ void draw_rect(int y, int x, int height, int width, uint8_t* out);
+ template <bool Black>
+ void draw_bound(int y, int x, int height, int width, uint8_t* out);
+
+ template <bool Horizontal>
+ int rule_1_3_score();
+ int penalty_score();
+ int select_mask(Ecc ecc, uint8_t* patterns);
+ void apply_mask(int mask, uint8_t* patterns);
+
+ private:
+ static_assert(V >= 1 && V <= 40, "invalid version");
+ static constexpr int SIDE = 17 + V * 4;
+ static constexpr int N_BITS = SIDE * SIDE;
+ static constexpr int N_ALIGN = V == 1 ? 0 : V / 7 + 2;
+ static constexpr int N_ALIGN_BITS = V > 1 ? (N_ALIGN* N_ALIGN - 3) * 25 : 0;
+ static constexpr int N_TIMING_BITS = (SIDE - 16) * 2 - (10 * (V > 1 ? N_ALIGN - 2 : 0));
+ static constexpr int N_VER_BITS = V > 6 ? 36 : 0;
+ static constexpr int N_DAT_BITS = N_BITS - (192 + N_ALIGN_BITS + N_TIMING_BITS + 31 + N_VER_BITS);
+ static constexpr int N_BYTES = utl::bytes_in_bits(N_BITS); // Actual number of bytes_in_bits
+ // required to store whole Qr code
+ static constexpr int N_DAT_BYTES =
+ utl::bytes_in_bits(N_DAT_BITS); // Actual number of bytes_in_bits required to store
+ // [data + ecc]
+ static constexpr int N_DAT_CAPACITY =
+ N_DAT_BITS >> 3; // Capacity of [data + ecc] without remainder bits
+ private:
+ /// @brief internal function to retrieve bit from a bitset.
+ uint8_t get_arr_bit(uint8_t* arr, unsigned bit) const { return utl::get_arr_bit(arr, bit); }
+
+ /// @brief internal function to set bit from a bitset.
+ void set_arr_bit(uint8_t* arr, unsigned bit) { utl::set_arr_bit(arr, bit); }
+
+ /// @brief internal function to clear bit from a bitset.
+ void clr_arr_bit(uint8_t* arr, unsigned bit) { utl::clr_arr_bit(arr, bit); }
+
+ uint8_t code[N_BYTES] = {};
+
+ bool status = false;
+};
+
+// Get color of a module from left-to-right and top-to-bottom. Black is true.
+template <int V>
+bool Qr<V>::module(int x, int y) {
+ return get_arr_bit(code, y * SIDE + x);
+}
+
+/// @brief draw a new QR code.
+template <int V>
+bool Qr<V>::draw(int whereX, int whereY) noexcept {
+ if (!this->status) return false; // it may be invalid.
+
+ cg_init();
+
+ for (int y = 0; y < (this->side_size()); ++y) {
+ for (int x = 0; x < (this->side_size()); ++x) {
+ FBDrawInRegion((this->module(x, y) ? RGB(00, 00, 00) : RGB(0xFF, 0xFF, 0xFF)), 1, 1,
+ x + whereX, y + whereY);
+ }
+ }
+
+ cg_clear();
+
+ return false;
+}
+
+// Create Qr code with given error correction level. If mask == -1,
+// then best mask selected automatically. NOTE: Automatic mask is the
+// most expensive operation. Takes about 95 % of all computation time.
+template <int V>
+bool Qr<V>::encode(const char* str, size_t len, Ecc ecc, int mask) {
+ uint8_t data[N_DAT_BYTES] = {};
+ uint8_t data_with_ecc[N_DAT_BYTES] = {};
+ uint8_t patterns[N_BYTES] = {};
+
+ if (!encode_data(str, len, ecc, data)) {
+ return status = false;
+ }
+
+ encode_ecc(data, ecc, data_with_ecc);
+
+ reserve_patterns(patterns);
+ CopyMem(code, patterns, N_BYTES);
+
+ add_data(data_with_ecc, patterns);
+ add_patterns();
+ add_version();
+
+ mask = mask != -1 ? mask & 7 : select_mask(ecc, patterns);
+
+ add_format(ecc, mask);
+ apply_mask(mask, patterns);
+
+ return status = true;
+}
+
+template <int V>
+bool Qr<V>::encode_data(const char* data, size_t len, Ecc ecc, uint8_t* out) {
+ Mode mode = select_mode(data, len);
+
+ size_t n_bits = (N_DAT_CAPACITY - ECC_CODEWORDS_PER_BLOCK[ecc][V] * N_ECC_BLOCKS[ecc][V]) << 3;
+ size_t pos = 0;
+
+ add_bits(1 << mode, 4, out, pos);
+ add_bits(len, cci(V, mode), out, pos);
+
+ if (mode == M_NUMERIC) {
+ const size_t triplets = len / 3;
+ const size_t triplets_size = triplets * 3;
+ const size_t rem = len % 3;
+ const size_t rem_bits = rem == 2 ? 7 : rem == 1 ? 4 : 0;
+ const size_t total_size = 10 * triplets + rem_bits;
+
+ if (pos + total_size > n_bits) return false;
+
+ char buf[4] = {};
+
+ for (size_t i = 0; i < triplets_size; i += 3) {
+ buf[0] = data[i];
+ buf[1] = data[i + 1];
+ buf[2] = data[i + 2];
+
+ uint16_t num = StringToLong(buf, NULL, 10);
+ add_bits(num, 10, out, pos);
+ }
+
+ if (rem) {
+ buf[0] = data[triplets_size];
+ buf[1] = data[triplets_size + 1];
+ buf[rem] = 0;
+
+ uint16_t num = StringToLong(buf, NULL, 10);
+ add_bits(num, rem_bits, out, pos);
+ }
+ } else if (mode == M_ALPHANUMERIC) {
+ if (pos + 11 * (int(len & ~1ul) / 2) > n_bits) return false;
+
+ for (int i = 0; i < int(len & ~1ul); i += 2) {
+ uint16_t num = alphanumeric(data[i]) * 45 + alphanumeric(data[i + 1]);
+ add_bits(num, 11, out, pos);
+ }
+ if (len & 1) {
+ if (pos + 6 > n_bits) return false;
+
+ add_bits(alphanumeric(data[len - 1]), 6, out, pos);
+ }
+ } else if (mode == M_BYTE) {
+ if (pos + len * 8 > n_bits) return false;
+
+ for (size_t i = 0; i < len; ++i) add_bits(data[i], 8, out, pos);
+ } else {
+ if (pos + 13 * (len / 2) > n_bits) return false;
+
+ for (size_t i = 0; i < len; i += 2) {
+ uint16_t val = ((uint8_t) data[i]) | (((uint8_t) data[i + 1]) << 8);
+ uint16_t res = 0;
+ val -= val < 0x9FFC ? 0x8140 : 0xC140;
+ res += val & 0xff;
+ res += (val >> 8) * 0xc0;
+ add_bits(res, 13, out, pos);
+ }
+ }
+
+ size_t padding = n_bits - pos;
+ size_t i = 0;
+
+ add_bits(0, padding > 4 ? 4 : padding, out, pos);
+
+ if (pos & 7) add_bits(0, (8 - pos) & 7, out, pos);
+
+ while (pos < n_bits) add_bits(++i & 1 ? 0xec : 0x11, 8, out, pos);
+
+ return true;
+}
+
+template <int V>
+void Qr<V>::encode_ecc(uint8_t* data, Ecc ecc, uint8_t* out) {
+ int n_blocks = N_ECC_BLOCKS[ecc][V];
+ int ecc_len = ECC_CODEWORDS_PER_BLOCK[ecc][V];
+
+ int n_data_bytes = N_DAT_CAPACITY - ecc_len * n_blocks;
+
+ int n_short_blocks = n_blocks - N_DAT_CAPACITY % n_blocks;
+ int short_len = N_DAT_CAPACITY / n_blocks - ecc_len;
+
+ uint8_t gen_poly[30];
+ uint8_t ecc_buf[30];
+
+ gf_gen_poly(ecc_len, gen_poly);
+
+ uint8_t* data_ptr = data;
+
+ for (int i = 0; i < n_blocks; ++i) {
+ int data_len = short_len;
+
+ if (i >= n_short_blocks) ++data_len;
+
+ gf_poly_div(data_ptr, data_len, gen_poly, ecc_len, ecc_buf);
+
+ for (int j = 0, k = i; j < data_len; ++j, k += n_blocks) {
+ if (j == short_len) k -= n_short_blocks;
+ out[k] = data_ptr[j];
+ }
+ for (int j = 0, k = n_data_bytes + i; j < ecc_len; ++j, k += n_blocks) out[k] = ecc_buf[j];
+
+ data_ptr += data_len;
+ }
+}
+
+template <int V>
+void Qr<V>::add_data(uint8_t* data, uint8_t* patterns) {
+ int data_pos = 0;
+
+ for (int x = SIDE - 1; x >= 1; x -= 2) {
+ if (x == 6) x = 5;
+
+ for (int i = 0; i < SIDE; ++i) {
+ int y = !((x + 1) & 2) ? SIDE - 1 - i : i;
+ int coord = y * SIDE + x;
+
+ if (!get_arr_bit(patterns, coord)) {
+ if (get_bit_r(data, data_pos)) set_arr_bit(code, coord);
+
+ ++data_pos;
+ }
+
+ if (!get_arr_bit(patterns, coord - 1)) {
+ if (get_bit_r(data, data_pos)) set_arr_bit(code, coord - 1);
+
+ ++data_pos;
+ }
+ }
+ }
+}
+
+template <int V>
+void Qr<V>::add_patterns() {
+ // White bounds inside finders
+ draw_bound<false>(1, 1, 5, 5, code);
+ draw_bound<false>(1, SIDE - 6, 5, 5, code);
+ draw_bound<false>(SIDE - 6, 1, 5, 5, code);
+
+ // Finish alignment patterns
+ for (int i = 0; i < N_ALIGN; ++i) {
+ for (int j = 0; j < N_ALIGN; ++j) {
+ if ((!i && !j) || (!i && j == N_ALIGN - 1) || (!j && i == N_ALIGN - 1)) continue;
+ draw_bound<false>(ALIGN_POS[V][i] - 1, ALIGN_POS[V][j] - 1, 3, 3, code);
+ }
+ }
+
+ // Draw white separators
+ draw_rect<false>(7, 0, 1, 8, code);
+ draw_rect<false>(0, 7, 8, 1, code);
+ draw_rect<false>(SIDE - 8, 0, 1, 8, code);
+ draw_rect<false>(SIDE - 8, 7, 8, 1, code);
+ draw_rect<false>(7, SIDE - 8, 1, 8, code);
+ draw_rect<false>(0, SIDE - 8, 8, 1, code);
+
+ // Perforate timing patterns
+ for (int i = 7; i < SIDE - 7; i += 2) {
+ clr_arr_bit(code, 6 * SIDE + i);
+ clr_arr_bit(code, i * SIDE + 6);
+ }
+}
+
+template <int V>
+void Qr<V>::add_version() {
+ if (V < 7) return;
+
+ uint32_t rem = V;
+
+ for (uint8_t i = 0; i < 12; ++i) rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
+
+ uint32_t data = V << 12 | rem;
+
+ for (int x = 0; x < 6; ++x) {
+ for (int j = 0; j < 3; ++j) {
+ int y = SIDE - 11 + j;
+
+ bool black = (data >> (x * 3 + j)) & 1;
+
+ if (!black) {
+ clr_arr_bit(code, y * SIDE + x);
+ clr_arr_bit(code, y + SIDE * x);
+ }
+ }
+ }
+}
+
+template <int V>
+void Qr<V>::add_format(Ecc ecc, int mask) {
+ int data = (ecc ^ 1) << 3 | mask;
+ int rem = data;
+
+ for (int i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >> 9) * 0b10100110111);
+
+ int res = (data << 10 | rem) ^ 0b101010000010010;
+
+ for (int i = 0; i < 6; ++i) {
+ if ((res >> i) & 1) {
+ set_arr_bit(code, SIDE * 8 + SIDE - 1 - i);
+ set_arr_bit(code, SIDE * i + 8);
+ } else {
+ clr_arr_bit(code, SIDE * 8 + SIDE - 1 - i);
+ clr_arr_bit(code, SIDE * i + 8);
+ }
+ }
+
+ for (int i = 6; i < 8; ++i) {
+ if ((res >> i) & 1) {
+ set_arr_bit(code, SIDE * 8 + SIDE - 1 - i);
+ set_arr_bit(code, SIDE * (i + 1) + 8);
+ } else {
+ clr_arr_bit(code, SIDE * 8 + SIDE - 1 - i);
+ clr_arr_bit(code, SIDE * (i + 1) + 8);
+ }
+ }
+
+ if ((res >> 8) & 1) {
+ set_arr_bit(code, SIDE * 8 + 7);
+ set_arr_bit(code, SIDE * (SIDE - 7) + 8);
+ } else {
+ clr_arr_bit(code, SIDE * 8 + 7);
+ clr_arr_bit(code, SIDE * (SIDE - 7) + 8);
+ }
+
+ for (int i = 9, j = 5; i < 15; ++i, --j) {
+ if ((res >> i) & 1) {
+ set_arr_bit(code, SIDE * 8 + j);
+ set_arr_bit(code, SIDE * (SIDE - 1 - j) + 8);
+ } else {
+ clr_arr_bit(code, SIDE * 8 + j);
+ clr_arr_bit(code, SIDE * (SIDE - 1 - j) + 8);
+ }
+ }
+}
+
+template <int V>
+template <bool B>
+void Qr<V>::draw_rect(int y, int x, int height, int width, uint8_t* out) {
+ if (B) {
+ for (int dy = y * SIDE; dy < (y + height) * SIDE; dy += SIDE)
+ for (int dx = x; dx < x + width; ++dx) set_arr_bit(out, dy + dx);
+ } else {
+ for (int dy = y * SIDE; dy < (y + height) * SIDE; dy += SIDE)
+ for (int dx = x; dx < x + width; ++dx) clr_arr_bit(out, dy + dx);
+ }
+}
+
+template <int V>
+template <bool B>
+void Qr<V>::draw_bound(int y, int x, int height, int width, uint8_t* out) {
+ if (B) {
+ for (int i = y * SIDE + x; i < y * SIDE + x + width; ++i) set_arr_bit(out, i);
+ for (int i = (y + height - 1) * SIDE + x; i < (y + height - 1) * SIDE + x + width; ++i)
+ set_arr_bit(out, i);
+ for (int i = (y + 1) * SIDE + x; i < (y + height - 1) * SIDE + x; i += SIDE)
+ set_arr_bit(out, i);
+ for (int i = (y + 1) * SIDE + x + width - 1; i < (y + height - 1) * SIDE + x + width - 1;
+ i += SIDE)
+ set_arr_bit(out, i);
+ } else {
+ for (int i = y * SIDE + x; i < y * SIDE + x + width; ++i) clr_arr_bit(out, i);
+ for (int i = (y + height - 1) * SIDE + x; i < (y + height - 1) * SIDE + x + width; ++i)
+ clr_arr_bit(out, i);
+ for (int i = (y + 1) * SIDE + x; i < (y + height - 1) * SIDE + x; i += SIDE)
+ clr_arr_bit(out, i);
+ for (int i = (y + 1) * SIDE + x + width - 1; i < (y + height - 1) * SIDE + x + width - 1;
+ i += SIDE)
+ clr_arr_bit(out, i);
+ }
+}
+
+template <int V>
+void Qr<V>::reserve_patterns(uint8_t* out) {
+ draw_rect<true>(0, 6, SIDE, 1, out);
+ draw_rect<true>(6, 0, 1, SIDE, out);
+
+ draw_rect<true>(0, 0, 9, 9, out);
+ draw_rect<true>(SIDE - 8, 0, 8, 9, out);
+ draw_rect<true>(0, SIDE - 8, 9, 8, out);
+
+ for (int i = 0; i < N_ALIGN; ++i) {
+ for (int j = 0; j < N_ALIGN; ++j) {
+ if ((!i && !j) || (!i && j == N_ALIGN - 1) || (!j && i == N_ALIGN - 1)) continue;
+ draw_rect<true>(ALIGN_POS[V][i] - 2, ALIGN_POS[V][j] - 2, 5, 5, out);
+ }
+ }
+
+ if (V >= 7) {
+ draw_rect<true>(SIDE - 11, 0, 3, 6, out);
+ draw_rect<true>(0, SIDE - 11, 6, 3, out);
+ }
+}
+
+template <int V>
+template <bool H>
+int Qr<V>::rule_1_3_score() {
+ constexpr int y_max = H ? N_BITS : SIDE;
+ constexpr int x_max = H ? SIDE : N_BITS;
+ constexpr int y_step = H ? SIDE : 1;
+ constexpr int x_step = H ? 1 : SIDE;
+
+ int res = 0;
+
+ for (int y = 0; y < y_max; y += y_step) {
+ bool color = get_arr_bit(code, y);
+ int finder = color;
+ int cnt = 1;
+ for (int x = 1; x < x_max; x += x_step) {
+ if (get_arr_bit(code, y + x) == color) {
+ ++cnt;
+ if (cnt == 5) res += 3;
+ if (cnt > 5) ++res;
+ } else {
+ color = !color;
+ cnt = 1;
+ }
+ // Finder-like
+ finder = ((finder << 1) & 0x7ff) | color;
+ if (x >= x_step * 10) {
+ if (finder == 0x05d || finder == 0x5d0) res += 40;
+ }
+ }
+ }
+ return res;
+}
+
+template <int V>
+int Qr<V>::penalty_score() {
+ int res = 0;
+
+ res += rule_1_3_score<true>();
+ res += rule_1_3_score<false>();
+
+ for (int y = 0; y < N_BITS - SIDE; y += SIDE) {
+ for (int x = 0; x < SIDE - 1; ++x) {
+ bool c = get_arr_bit(code, y + x);
+
+ if (c == get_arr_bit(code, y + x + 1) && c == get_arr_bit(code, y + x + SIDE) &&
+ c == get_arr_bit(code, y + x + SIDE + 1))
+ res += 3;
+ }
+ }
+
+ int black = 0;
+ for (int y = 0; y < N_BITS; y += SIDE) {
+ for (int x = 0; x < SIDE; ++x) black += get_arr_bit(code, y + x);
+ }
+ res += abs((black * 100) / N_BITS - 50) / 5 * 10;
+
+ return res;
+}
+
+template <int V>
+int Qr<V>::select_mask(Ecc ecc, uint8_t* patterns) {
+ unsigned min_score = -1;
+ unsigned score = 0;
+ uint8_t mask = 0;
+
+ for (int i = 0; i < 8; ++i) {
+ add_format(ecc, i);
+ apply_mask(i, patterns);
+ score = penalty_score();
+ if (score < min_score) {
+ mask = i;
+ min_score = score;
+ }
+ apply_mask(i, patterns);
+ }
+ return mask;
+}
+
+template <int V>
+void Qr<V>::apply_mask(int mask, uint8_t* patterns) {
+ for (int y = 0, dy = 0; y < SIDE; ++y, dy += SIDE) {
+ for (int x = 0; x < SIDE; ++x) {
+ int coord = dy + x;
+
+ if (get_arr_bit(patterns, coord)) continue;
+
+ bool keep = true;
+
+ switch (mask) {
+ case 0:
+ keep = (x + y) & 1;
+ break;
+ case 1:
+ keep = y & 1;
+ break;
+ case 2:
+ keep = x % 3;
+ break;
+ case 3:
+ keep = (x + y) % 3;
+ break;
+ case 4:
+ keep = (y / 2 + x / 3) & 1;
+ break;
+ case 5:
+ keep = x * y % 2 + x * y % 3;
+ break;
+ case 6:
+ keep = (x * y % 2 + x * y % 3) & 1;
+ break;
+ case 7:
+ keep = ((x + y) % 2 + x * y % 3) & 1;
+ break;
+ }
+
+ if (!keep) {
+ if (get_arr_bit(code, coord))
+ clr_arr_bit(code, coord);
+ else
+ set_arr_bit(code, coord);
+ }
+ }
+ }
+}
+
+/// @brief QR code encoder class.
+class QrDelegate final {
+ public:
+ explicit QrDelegate() = default;
+ ~QrDelegate() = default;
+
+ NE_COPY_DEFAULT(QrDelegate)
+
+ /// @brief Draw method delegate.
+ template <Int32 V>
+ bool draw(Qr<V>& subject, Int32 x, Int32 y) noexcept {
+ return subject.draw(x, y);
+ }
+};
+} // namespace qr
+
+namespace Kernel::Qr {
+using namespace qr;
+} // namespace Kernel::Qr
+
+#endif // QR_H \ No newline at end of file
diff --git a/src/boot/BootKit/QrPrelude.h b/src/boot/BootKit/QrPrelude.h
new file mode 100644
index 00000000..e89fad7a
--- /dev/null
+++ b/src/boot/BootKit/QrPrelude.h
@@ -0,0 +1 @@
+#include <BootKit/BitManip.h> \ No newline at end of file
diff --git a/src/boot/BootKit/Shared/base.h b/src/boot/BootKit/Shared/base.h
new file mode 100644
index 00000000..c95db0cc
--- /dev/null
+++ b/src/boot/BootKit/Shared/base.h
@@ -0,0 +1,24 @@
+#ifndef UTL_BASE_H
+#define UTL_BASE_H
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+namespace utl {
+
+/**
+ * @brief Helper to get number of elements in array.
+ *
+ * @tparam T Auto-deduced element type
+ * @tparam N Auto-deduced number of elements
+ * @return Array size
+ */
+template <class T, size_t N>
+constexpr size_t countof(T (&)[N]) {
+ return N;
+}
+
+} // namespace utl
+
+#endif \ No newline at end of file
diff --git a/src/boot/BootKit/Shared/bit.h b/src/boot/BootKit/Shared/bit.h
new file mode 100644
index 00000000..1ac29c89
--- /dev/null
+++ b/src/boot/BootKit/Shared/bit.h
@@ -0,0 +1,228 @@
+#ifndef UTL_BIT_H
+#define UTL_BIT_H
+
+#include <bit>
+
+namespace utl {
+
+/**
+ * @brief Size of object in terms of bits.
+ *
+ * @tparam T Object type
+ * @return Number of bits
+ */
+template <class T>
+constexpr auto bit_size() {
+ return sizeof(T) * 8;
+}
+
+/**
+ * @brief Integer with all bits set to 1.
+ *
+ * @tparam T Integer type
+ * @return All set integer
+ */
+template <class T>
+constexpr T bit_full() {
+ return T(-1);
+}
+
+/**
+ * @brief Wrap around mask for power of two number of bits
+ * within given integer type. For example:
+ * [ bit_wrap<uint8_t> = 8 - 1 = 0b111 ]
+ * [ bit_wrap<uint16_t> = 16 - 1 = 0b1111 ]
+ * [ bit_wrap<uint32_t> = 32 - 1 = 0b11111 ]
+ *
+ * @tparam T Integer type
+ * @return Wrap around mask for number of bits
+ */
+template <class T>
+constexpr T bit_wrap() {
+ return bit_size<T>() - 1;
+}
+
+/**
+ * @brief Number of bits to fit bit_wrap<T> result, in other words
+ * bit width of (sizeof(T) * 8 - 1). For example:
+ * [ bit_shft<uint8_t> = bit_width(0b111) = 3 ]
+ * [ bit_shft<uint16_t> = bit_width(0b1111) = 4 ]
+ * [ bit_shft<uint32_t> = bit_width(0b11111) = 5 ]
+ *
+ * @tparam T Integer type
+ * @return Number of bits to shift to divide by sizeof(T) * 8
+ */
+template <class T>
+constexpr auto bit_shft() {
+ return std::bit_width(bit_wrap<T>());
+}
+
+/**
+ * @brief Round up division by number of bits within given integer type,
+ * which sizeof(T) * 8 is power of two.
+ *
+ * @tparam T Inetegr type
+ * @param x Dividend
+ * @return Quotient
+ */
+template <class T>
+constexpr auto bit_ceil(auto x) {
+ return (x + bit_wrap<T>()) >> bit_shft<T>();
+}
+
+/**
+ * @brief Count leading zeros.
+ *
+ * @param x Unsigned integer argument
+ * @return Number of leading zeros
+ */
+constexpr unsigned cntlz(auto x) {
+ if constexpr (std::is_same_v<decltype(x), int>)
+ return std::countl_zero(unsigned(x));
+ else
+ return std::countl_zero(x);
+}
+
+/**
+ * @brief Count trailing zeros.
+ *
+ * @param x Unsigned integer argument
+ * @return Number of trailing zeros
+ */
+constexpr unsigned cnttz(auto x) {
+ if constexpr (std::is_same_v<decltype(x), int>)
+ return std::countr_zero(unsigned(x));
+ else
+ return std::countr_zero(x);
+}
+
+/**
+ * @brief Get number of words (integers) required to store N bits.
+ *
+ * @tparam T Word integer type
+ * @param n Number of bits to store
+ * @return Number of words
+ */
+template <class T>
+constexpr size_t words_in_bits(size_t n) {
+ return (n >> bit_shft<T>()) + !!(n & bit_wrap<T>());
+}
+
+/**
+ * @brief Get number of bytes required to store N bits.
+ *
+ * @param n Number of bits to store
+ * @return Number of bytes
+ */
+constexpr size_t bytes_in_bits(size_t n) {
+ return words_in_bits<uint8_t>(n);
+}
+
+/**
+ * @brief Make integer with bit at given position.
+ *
+ * @tparam T Inetegr type
+ * @param n Bit position
+ * @return Integer with set bit
+ */
+template <class T = unsigned>
+constexpr T bit(int n) {
+ return T(1) << n;
+}
+
+/**
+ * @brief Get n-th bit of an integer.
+ *
+ * @tparam T Integer type
+ * @param x Integer
+ * @param n Bit position from LSB
+ * @return true if set
+ */
+template <class T>
+constexpr bool get_bit(T x, int n) {
+ return (x >> n) & 1;
+}
+
+/**
+ * @brief Set n-th bit of an integer.
+ *
+ * @tparam T Integer type
+ * @param x Integer
+ * @param n Bit position from LSB
+ */
+template <class T>
+constexpr void set_bit(T& x, int n) {
+ x |= 1 << n;
+}
+
+/**
+ * @brief Clear n-th bit of an integer.
+ *
+ * @tparam T Integer type
+ * @param x Integer
+ * @param n Bit position from LSB
+ */
+template <class T>
+constexpr void clr_bit(T& x, int n) {
+ x &= ~(1 << n);
+}
+
+/**
+ * @brief Get n-th bit in array of words (starting from LSB).
+ *
+ * @tparam T Word type
+ * @param p Array of words
+ * @param n Index of bit to get
+ * @return true if set
+ */
+template <class T>
+constexpr bool get_arr_bit(const T* p, unsigned n) {
+ return get_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
+}
+
+/**
+ * @brief Set n-th bit in array of words (starting from LSB).
+ *
+ * @tparam T Word type
+ * @param p Array of words
+ * @param n Index of bit to set
+ */
+template <class T>
+constexpr void set_arr_bit(T* p, unsigned n) {
+ set_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
+}
+
+/**
+ * @brief Clear n-th bit in array of words (starting from LSB).
+ *
+ * @tparam T Word type
+ * @param p Array of words
+ * @param n Index of bit to clear
+ */
+template <class T>
+constexpr void clr_arr_bit(T* p, unsigned n) {
+ clr_bit(p[n >> bit_shft<T>()], n & bit_wrap<T>());
+}
+
+/**
+ * @brief Shift bits left in array of integer elements from least significant bit
+ * and considering 0-th byte as the right most.
+ * uint16_t example: 0b10000000'11100001 ==> 0b00000001'11000010.
+ *
+ * @tparam T Integer type
+ * @tparam L Length of array
+ * @param x Array of integers, nullptr not acceptable!
+ * @param len Number of elements
+ */
+template <class T, size_t L>
+constexpr void shift_left(T (&x)[L]) {
+ for (int i = L - 1; i > 0; --i) {
+ x[i] <<= 1;
+ x[i] |= x[i - 1] >> bit_wrap<T>();
+ }
+ x[0] <<= 1;
+}
+
+} // namespace utl
+
+#endif \ No newline at end of file
diff --git a/src/boot/BootKit/Support.h b/src/boot/BootKit/Support.h
new file mode 100644
index 00000000..110b220c
--- /dev/null
+++ b/src/boot/BootKit/Support.h
@@ -0,0 +1,145 @@
+/* ========================================
+
+ Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+/// @file Support.h
+/// @brief Purpose of this file is to help port libs into the bootloader.
+
+#ifndef __NE_ARM64__
+#include <string.h>
+#endif
+
+#define kLongMax ((long) (~0UL >> 1))
+#define kLongMin (~kLongMax)
+
+#ifdef __BOOTZ__
+
+/// @brief memset definition in C++.
+/// @param dst destination pointer.
+/// @param byte value to fill in.
+/// @param len length of of src.
+EXTERN_C void* memset(void* dst, int byte, long long unsigned int len);
+
+/// @brief memcpy definition in C++.
+/// @param dst destination pointer.
+/// @param src source pointer.
+/// @param len length of of src.
+EXTERN_C void* memcpy(void* dst, const void* src, long long unsigned int len);
+
+/// @brief strlen definition in C++.
+EXTERN_C size_t strlen(const char* whatToCheck);
+
+/// @brief strcmp definition in C++.
+EXTERN_C int strcmp(const char* whatToCheck, const char* whatToCheckRight);
+
+#else
+
+#ifndef __NE_ARM64__
+#include <string.h>
+#endif
+
+#endif // __BOOTZ__
+
+#define SetMem(dst, c, sz) memset(dst, c, sz)
+#define MoveMem(dst, src, sz) memcpy(dst, src, sz)
+#define CopyMem(dst, src, sz) memcpy(dst, src, sz)
+#define StrLen(src) strlen(src)
+#define StrCmp(dst, src) strcmp(dst, src)
+
+inline int IsSpace(int c) {
+ return c == ' ';
+}
+
+inline int StringNCompare(const char* destination, const char* source, long length) {
+ long err = 0;
+
+ for (long i = 0UL; i < length; ++i) {
+ if (source[i] != destination[i]) ++err;
+ }
+
+ return err;
+}
+
+inline long StringToLong(const char* nptr, char** endptr, int base) {
+ const char *p = nptr, *endp;
+ bool is_neg = 0, overflow = 0;
+
+ /* Need unsigned so (-kLongMin) can fit in these: */
+ unsigned long n = 0UL, cutoff;
+ int cutlim;
+
+ if (base < 0 || base == 1 || base > 36) {
+ return 0L;
+ }
+
+ endp = nptr;
+
+ while (IsSpace(*p)) p++;
+
+ if (*p == '+') {
+ p++;
+ } else if (*p == '-') {
+ is_neg = 1, p++;
+ }
+ if (*p == '0') {
+ p++;
+ /* For strtol(" 0xZ", &endptr, 16), endptr should point to 'x';
+ * pointing to ' ' or '0' is non-compliant.
+ * (Many implementations do this wrong.) */
+ endp = p;
+ if (base == 16 && (*p == 'X' || *p == 'x')) {
+ p++;
+ } else if (base == 2 && (*p == 'B' || *p == 'b')) {
+ /* C23 standard supports "0B" and "0b" prefixes. */
+ p++;
+ } else if (base == 0) {
+ if (*p == 'X' || *p == 'x') {
+ base = 16, p++;
+ } else if (*p == 'B' || *p == 'b') {
+ base = 2, p++;
+ } else {
+ base = 8;
+ }
+ }
+ } else if (base == 0) {
+ base = 10;
+ }
+
+ cutoff = (is_neg) ? -(kLongMin / base) : kLongMax / base;
+ cutlim = (is_neg) ? -(kLongMin % base) : kLongMax % base;
+
+ while (1) {
+ int c;
+ if (*p >= 'A')
+ c = ((*p - 'A') & (~('a' ^ 'A'))) + 10;
+ else if (*p <= '9')
+ c = *p - '0';
+ else
+ break;
+ if (c < 0 || c >= base) break;
+ endp = ++p;
+ if (overflow) {
+ /* endptr should go forward and point to the non-digit character
+ * (of the given base); required by ANSI standard. */
+ if (endptr) continue;
+ break;
+ }
+ if (n > cutoff || (n == cutoff && c > cutlim)) {
+ overflow = 1;
+ continue;
+ }
+ n = n * base + c;
+ }
+
+ if (endptr) *endptr = (char*) endp;
+
+ if (overflow) {
+ return ((is_neg) ? kLongMin : kLongMax);
+ }
+
+ return (long) ((is_neg) ? -n : n);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-13 21:13:56 +0000