add util::Buffer, rle::encode16, rle::decode16

src/coders/rle.cpp

@@ -35,6 +35,45 @@ size_t rle::encode(const ubyte* src, size_t srclen, ubyte* dst) {
     return offset;
 }
 
+size_t rle::decode16(const ubyte* src, size_t srclen, ubyte* dst) {
+    auto src16 = reinterpret_cast<const uint16_t*>(src);
+    auto dst16 = reinterpret_cast<uint16_t*>(dst);
+    size_t offset = 0;
+    for (size_t i = 0; i < srclen / 2;) {
+        uint16_t len = src16[i++];
+        uint16_t c = src16[i++];
+        for (size_t j = 0; j <= len; j++) {
+            dst16[offset++] = c;
+        }
+    }
+    return offset * 2;
+}
+
+size_t rle::encode16(const ubyte* src, size_t srclen, ubyte* dst) {
+    if (srclen == 0) {
+        return 0;
+    }
+    auto src16 = reinterpret_cast<const uint16_t*>(src);
+    auto dst16 = reinterpret_cast<uint16_t*>(dst);
+    size_t offset = 0;
+    uint16_t counter = 0;
+    uint16_t c = src16[0];
+    for (size_t i = 1; i < srclen / 2; i++) {
+        uint16_t cnext = src16[i];
+        if (cnext != c || counter == 0xFFFF) {
+            dst16[offset++] = counter;
+            dst16[offset++] = c;
+            c = cnext;
+            counter = 0;
+        } else {
+            counter++;
+        }
+    }
+    dst16[offset++] = counter;
+    dst16[offset++] = c;
+    return offset * 2;
+}
+
 size_t extrle::decode(const ubyte* src, size_t srclen, ubyte* dst) {
     size_t offset = 0;
     for (size_t i = 0; i < srclen;) {

src/coders/rle.hpp

@@ -5,6 +5,9 @@
 namespace rle {
     size_t encode(const ubyte* src, size_t length, ubyte* dst);
     size_t decode(const ubyte* src, size_t length, ubyte* dst);
+
+    size_t encode16(const ubyte* src, size_t length, ubyte* dst);
+    size_t decode16(const ubyte* src, size_t length, ubyte* dst);
 }
 
 namespace extrle {

src/files/WorldConverter.cpp

@@ -61,7 +61,7 @@ void WorldConverter::createUpgradeTasks() {
         if (issue.regionLayer == REGION_LAYER_VOXELS) {
             addRegionsTasks(issue.regionLayer, ConvertTaskType::UPGRADE_VOXELS);
         } else {
-            addRegionsTasks(issue.regionLayer, ConvertTaskType::UPGRADE_SIMPLE);
+            addRegionsTasks(issue.regionLayer, ConvertTaskType::UPGRADE_REGION);
         }
     }
 }
@@ -159,7 +159,7 @@ std::shared_ptr<Task> WorldConverter::startTask(
     return pool;
 }
 
-void WorldConverter::upgradeSimple(const fs::path& file, int x, int z) const {
+void WorldConverter::upgradeRegion(const fs::path& file, int x, int z) const {
     throw std::runtime_error("unsupported region format");
 }
 
@@ -194,10 +194,11 @@ void WorldConverter::convert(const ConvertTask& task) const {
     if (!fs::is_regular_file(task.file)) return;
 
     switch (task.type) {
-        case ConvertTaskType::UPGRADE_SIMPLE:
-            upgradeSimple(task.file, task.x, task.z);
+        case ConvertTaskType::UPGRADE_REGION:
+            upgradeRegion(task.file, task.x, task.z);
             break;
         case ConvertTaskType::UPGRADE_VOXELS:
+            upgradeRegion(task.file, task.x, task.z);
             upgradeVoxels(task.file, task.x, task.z);
             break;
         case ConvertTaskType::VOXELS:

src/files/WorldConverter.hpp

@@ -23,7 +23,7 @@ enum class ConvertTaskType {
     /// @brief rewrite player
     PLAYER,
     /// @brief refresh region file version
-    UPGRADE_SIMPLE,
+    UPGRADE_REGION,
     /// @brief rewrite voxels region file to new format
     UPGRADE_VOXELS,
 };
@@ -45,7 +45,7 @@ class WorldConverter : public Task {
     uint tasksDone = 0;
     bool upgradeMode;
 
-    void upgradeSimple(const fs::path& file, int x, int z) const;
+    void upgradeRegion(const fs::path& file, int x, int z) const;
     void upgradeVoxels(const fs::path& file, int x, int z) const;
     void convertPlayer(const fs::path& file) const;
     void convertVoxels(const fs::path& file, int x, int z) const;

src/util/Buffer.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <memory>
+#include <cstring>
+
+namespace util {
+    template<typename T>
+    class Buffer {
+        std::unique_ptr<T[]> ptr;
+        size_t length;
+    public:
+        Buffer(size_t length)
+         : ptr(std::make_unique<T[]>(length)), length(length) {
+        }
+
+        Buffer(std::unique_ptr<T[]> ptr, size_t length)
+         : ptr(std::move(ptr)), length(length) {}
+
+        Buffer(const T* src, size_t length)
+         : ptr(std::make_unique<T[]>(length)), length(length) {
+            std::memcpy(ptr, src, length);
+        }
+
+        T& operator[](long long index) {
+            return ptr[index];
+        }
+
+        const T& operator[](long long index) const {
+            return ptr[index];
+        }
+
+        T* data() {
+            return ptr.get();
+        }
+
+        const T* data() const {
+            return ptr.get();
+        }
+
+        size_t size() const {
+            return length;
+        }
+
+        std::unique_ptr<T[]> release() {
+            return std::move(ptr);
+        }
+
+        Buffer clone() const {
+            return Buffer(ptr.get(), length);
+        }
+    };
+}