add directory index format

Author: fuzziqersoftware

CMakeLists.txt

@@ -55,6 +55,7 @@ add_library(resource_file
   src/IndexFormats/AppleSingle-AppleDouble.cc
   src/IndexFormats/CBag.cc
   src/IndexFormats/DCData.cc
+  src/IndexFormats/Directory.cc
   src/IndexFormats/HIRF.cc
   src/IndexFormats/MacBinary.cc
   src/IndexFormats/Mohawk.cc

src/Audio/MODSynthesizer.cc

@@ -1174,7 +1174,7 @@ void MODSynthesizer::run_one() {
 void MODSynthesizer::run_all() {
   bool changed_partition = false;
   this->max_output_samples = this->opts->sample_rate * this->opts->max_output_seconds * 2;
-  while (this->pos.partition_index < this->mod->partition_count && !this->exceeded_time_limit()) {
+  while (!this->done()) {
     this->execute_current_division_commands();
     // Note: We print the partition after executing its commands so that the
     // timing information will be consistent if any Fxx commands were run.
@@ -1195,6 +1195,10 @@ void MODSynthesizer::run_all() {
   }
 }
 
+bool MODSynthesizer::done() const {
+  return (this->pos.partition_index >= this->mod->partition_count || this->exceeded_time_limit());
+}
+
 MODRenderer::MODRenderer(shared_ptr<const Module> mod, shared_ptr<const Options> opts)
     : MODSynthesizer(mod, opts) {}
 

src/Audio/MODSynthesizer.hh

@@ -110,7 +110,7 @@ public:
     // If not empty, audio is muted for all tracks except those specified in
     // this set
     std::unordered_set<size_t> solo_tracks;
-    // Factor by which to spees up or slow down the entire song
+    // Factor by which to speed up or slow down the entire song
     float tempo_bias = 1.0;
     // Number of full arpeggio cycles per division. If set to zero, arpeggios
     // use tick boundaries instead of being evenly spaced across the division
@@ -133,6 +133,15 @@ public:
   void run_one();
   void run_all();
 
+  bool done() const;
+
+  inline std::shared_ptr<const Module> get_module() const {
+    return this->mod;
+  }
+  inline std::shared_ptr<const Options> get_options() const {
+    return this->opts;
+  }
+
 protected:
   struct Timing {
     size_t sample_rate;

src/IndexFormats/Directory.cc

@@ -0,0 +1,88 @@
+#include "Formats.hh"
+
+#include <stdint.h>
+
+#include <filesystem>
+#include <phosg/Encoding.hh>
+#include <phosg/Strings.hh>
+#include <string>
+
+#include "../ResourceFile.hh"
+#include "../TextCodecs.hh"
+
+using namespace std;
+using namespace phosg;
+
+namespace ResourceDASM {
+
+ResourceFile load_resource_file_from_directory(const string& dir_path) {
+  ResourceFile ret;
+  for (const auto& type_item : std::filesystem::directory_iterator(dir_path)) {
+    if (!type_item.is_directory()) {
+      continue;
+    }
+
+    string type_item_name = type_item.path().filename();
+    uint32_t type = resource_type_for_raw_string(unescape_hex_bytes_for_filename(type_item_name));
+
+    for (const auto& res_item : std::filesystem::directory_iterator(std::filesystem::path(dir_path) / type_item_name)) {
+      if (!res_item.is_regular_file()) {
+        continue;
+      }
+
+      string res_item_name = res_item.path().filename();
+      if (!res_item_name.ends_with(".bin")) {
+        continue;
+      }
+
+      // Filename is eiher like 20.bin (ID only) or 20_Resource_name.bin (ID +
+      // name; name has _XX => escaped byte). Trim off the .bin first
+      res_item_name.resize(res_item_name.size() - 4);
+
+      size_t offset = 0;
+      int32_t res_id = stol(res_item_name, &offset, 10);
+      if (res_id < -0x8000 || res_id > 0x7FFF) {
+        throw std::runtime_error(std::format("Invalid resource ID: {}/{}.bin", type_item_name, res_item_name));
+      }
+      if (offset > res_item_name.size()) {
+        throw std::runtime_error(std::format("Invalid resource filename (parse error): {}/{}.bin", type_item_name, res_item_name));
+      }
+
+      string res_name;
+      if (offset < res_item_name.size()) {
+        // Has resource name
+        if (res_item_name[offset] != '_') {
+          throw std::runtime_error(std::format("Invalid resource filename (missing separator): {}/{}.bin", type_item_name, res_item_name));
+        }
+        res_name = unescape_hex_bytes_for_filename(res_item_name.substr(offset + 1));
+      }
+
+      auto res = make_shared<ResourceFile::Resource>();
+      res->type = type;
+      res->id = res_id;
+      res->flags = 0;
+      res->name = res_name;
+      res->data = phosg::load_file(res_item.path().string());
+      ret.add(res);
+    }
+  }
+
+  return ret;
+}
+
+void save_resource_file_to_directory(const ResourceFile& rf, const std::string& dir_path) {
+  std::filesystem::path base_path = dir_path;
+  // TODO: This is kinda dumb. It'd be nice if we could use a generator to just
+  // iterate the shared_ptr<const Resource> objects directly
+  for (auto [res_type, res_id] : rf.all_resources()) {
+    auto res = rf.get_resource(res_type, res_id);
+    string type_item_name = escape_hex_bytes_for_filename(raw_string_for_resource_type(res_type));
+    std::filesystem::create_directories(base_path / type_item_name);
+    string res_item_name = res->name.empty()
+        ? std::format("{}.bin", res->id)
+        : std::format("{}_{}.bin", res->id, escape_hex_bytes_for_filename(res->name));
+    phosg::save_file((base_path / type_item_name / res_item_name).string(), res->data);
+  }
+}
+
+} // namespace ResourceDASM

src/IndexFormats/Formats.hh

@@ -40,6 +40,10 @@ ResourceFile parse_cbag(const std::string& data);
 // DCData.cc
 ResourceFile parse_dc_data(const std::string& data);
 
+// Directory.cc
+ResourceFile load_resource_file_from_directory(const std::string& dir_path);
+void save_resource_file_to_directory(const ResourceFile& rf, const std::string& dir_path);
+
 // HIRF.cc
 ResourceFile parse_hirf(const std::string& data);
 

src/ResourceFile.hh

@@ -24,6 +24,7 @@ using namespace phosg;
 enum class IndexFormat {
   NONE = 0, // For ResourceFiles constructed in memory
   RESOURCE_FORK,
+  DIRECTORY,
   APPLESINGLE_APPLEDOUBLE,
   MACBINARY,
   MOHAWK,

src/TextCodecs.cc

@@ -123,4 +123,57 @@ string raw_string_for_resource_type(uint32_t type) {
   return result;
 }
 
+uint32_t resource_type_for_raw_string(const std::string& s) {
+  switch (s.size()) {
+    case 0:
+      return 0x20202020;
+    case 1:
+      return ((static_cast<uint32_t>(s[0]) & 0xFF) << 24) | 0x00202020;
+    case 2:
+      return ((static_cast<uint32_t>(s[0]) & 0xFF) << 24) |
+          ((static_cast<uint32_t>(s[1]) & 0xFF) << 16) |
+          0x00002020;
+    case 3:
+      return ((static_cast<uint32_t>(s[0]) & 0xFF) << 24) |
+          ((static_cast<uint32_t>(s[1]) & 0xFF) << 16) |
+          ((static_cast<uint32_t>(s[2]) & 0xFF) << 8) |
+          0x00000020;
+    case 4:
+      return ((static_cast<uint32_t>(s[0]) & 0xFF) << 24) |
+          ((static_cast<uint32_t>(s[1]) & 0xFF) << 16) |
+          ((static_cast<uint32_t>(s[2]) & 0xFF) << 8) |
+          (static_cast<uint32_t>(s[3]) & 0xFF);
+    default:
+      throw std::runtime_error(std::format("Invalid resource type name: {}", s));
+  }
+}
+
+string escape_hex_bytes_for_filename(const string& s) {
+  string ret;
+  for (size_t z = 0; z < s.size(); z++) {
+    if (s[z] == '_' || s[z] == '/' || s[z] == ':' || s[z] < 0x20 || s[z] > 0x7E) {
+      ret += std::format("_{:02X}", static_cast<uint8_t>(s[z]));
+    } else {
+      ret.push_back(s[z]);
+    }
+  }
+  return ret;
+}
+
+string unescape_hex_bytes_for_filename(const string& s) {
+  string ret;
+  for (size_t z = 0; z < s.size(); z++) {
+    if (s[z] == '_') {
+      if (z > s.size() - 3) {
+        throw std::runtime_error(std::format("Invalid escape sequence: {}", s));
+      }
+      ret.push_back((phosg::value_for_hex_char(s[z + 1]) << 4) | phosg::value_for_hex_char(s[z + 2]));
+      z += 2;
+    } else {
+      ret.push_back(s[z]);
+    }
+  }
+  return ret;
+}
+
 } // namespace ResourceDASM

src/TextCodecs.hh

@@ -13,9 +13,13 @@ std::string decode_mac_roman(char data, bool for_filename = false);
 
 std::string string_for_resource_type(uint32_t type, bool for_filename = false);
 std::string raw_string_for_resource_type(uint32_t type);
+uint32_t resource_type_for_raw_string(const std::string& s);
 
 constexpr bool should_escape_mac_roman_filename_char(char ch) {
   return (static_cast<uint8_t>(ch) < 0x20) || (ch == '/') || (ch == ':');
 }
 
+std::string escape_hex_bytes_for_filename(const std::string& s);
+std::string unescape_hex_bytes_for_filename(const std::string& s);
+
 } // namespace ResourceDASM