roundtrip_blp.cpp

Go to the documentation of this file.

 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <format>
#include <optional>
#include <string>
 
#include <wowlib/audit/detail.hpp>
#include <wowlib/formats/blp/blp.hpp>
 
namespace {
  using namespace wowlib;
  using namespace wowlib::audit;
  using namespace wowlib::formats;

  std::optional<std::string> firstDivergenceBlp(const FileBuffer& original,
                                                  const FileBuffer& rewritten,
                                                  const blp::BLP& entity) {
    if (original == rewritten) return std::nullopt;
 
    const std::size_t common = std::min(original.size(), rewritten.size());
    std::size_t at = 0;
    while (at < common && original[at] == rewritten[at]) ++at;
 
    std::string inside = "gap/tail";
    if (at < 0x94) inside = "header";
    else if (at < blp::BlpHeaderBytes) inside = "palette";
    else
      for (std::size_t level = 0; level < blp::BlpMaxMips; ++level) {
        const std::uint32_t offset = entity.storedLayout.offsets[level];
        const std::uint32_t size = entity.storedLayout.sizes[level];
        if (offset != 0 && size != 0 && at >= offset && at < std::uint64_t{offset} + size) {
          inside = std::format("mip {}", level);
          break;
        }
      }
    return std::format("first divergence at {:#x} inside {} (sizes {} vs {})", at, inside, original.size(),
                       rewritten.size());
  }

  RoundtripReport roundtripBlp(fs::FileSystem& fs, const std::string& path) {
    RoundtripReport report;
    const auto raw = fs.readFile(FileKey{path});
    if (auto outcome = audit::detail::classifyRead(report, "read", raw)) return *outcome;
 
    blp::BLP entity;
    if (auto r = entity.read(*raw); !r) return audit::detail::failWith(report, "parse", r.error().message);
 
    const auto rewritten = entity.write();
    if (!rewritten)
      return audit::detail::failWith(report, "write", rewritten.error().message);
    if (auto divergence = firstDivergenceBlp(*raw, *rewritten, entity)) return audit::detail::failWith(
      report, "compare", *divergence);
    return report;
  }
}
 
namespace wowlib::audit::detail {
  RoundtripReport FormatDrivers::blp(fs::FileSystem& fs, const std::string& path) {
    return guarded([&] { return roundtripBlp(fs, path); });
  }
}