Config.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Serialization/JsonParser.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  bool parseJsonChannel(Config& config, const Value& channelJson)
  {
    if (!channelJson.IsObject()) {
      LOG_ERROR(logger, "json: channel item not an object");
      return false;
    }
 
    Config::Channel channel;
 
    for (const auto& channelMemberJson : channelJson.GetObject()) {
      Cogs::StringView channelMemberName = toView(channelMemberJson.name);
      switch (channelMemberName.hash()) {
 
 
      case Cogs::hash("dataType"):
        if (channelMemberJson.value.IsString()) {
          Cogs::StringView dataTypeJson = toView(channelMemberJson.value);
          switch (dataTypeJson.hash()) {
          case Cogs::hash("SRGB8_JPEG"):
            channel.dataType = Config::Channel::DataType::SRGB8_JPEG;
            break;
          case Cogs::hash("SRGB8_PNG"):
            channel.dataType = Config::Channel::DataType::SRGB8_PNG;
            break;
          case Cogs::hash("SRGBA8_PNG"):
            channel.dataType = Config::Channel::DataType::SRGBA8_PNG;
            break;
          case Cogs::hash("U16"):
            channel.dataType = Config::Channel::DataType::U16;
            break;
          case Cogs::hash("U16_ZST"):
            channel.dataType = Config::Channel::DataType::U16_ZST;
            break;
          default:
            LOG_ERROR(logger, "json: unrecognized channel item member 'dataType' value '%.*s'", StringViewFormat(dataTypeJson));
            return false;
          }
        }
        else {
          LOG_ERROR(logger, "json: channel item member 'dataType' is not a string");
          return false;
        }
        break;
 
      case Cogs::hash("prefix"):
        if (channelMemberJson.value.IsString() && channelMemberJson.value.GetStringLength() != 0) {
          channel.prefix = channelMemberJson.value.GetString();
          if (Cogs::IO::isRelative(channel.prefix)) {
            channel.prefix = Cogs::IO::combine(config.rootPath, channel.prefix);
          }
        }
        else {
          LOG_ERROR(logger, "json: channel item member 'prefix' is not a nonempty string");
          return false;
        }
        break;
 
      case Cogs::hash("scale"):
        if (channelMemberJson.value.IsFloat()) {
          channel.scale = channelMemberJson.value.GetFloat();
        }
        else {
          LOG_ERROR(logger, "json: channel item member 'scale' is not a float");
          return false;
        }
        break;
 
      case Cogs::hash("bias"):
        if (channelMemberJson.value.IsFloat()) {
          channel.bias = channelMemberJson.value.GetFloat();
        }
        else {
          LOG_ERROR(logger, "json: channel item member 'bias' is not a float");
          return false;
        }
        break;
 
      default:
        LOG_ERROR(logger, "json: unexpected channel member %.*s", StringViewFormat(channelMemberName));
        return false;
      }
    }
 
    if (channel.dataType == Config::Channel::DataType::None) {
      LOG_ERROR(logger, "json: channel missing compulsory member 'dataType");
      return false;
    }
    if (channel.prefix.empty()) {
      LOG_ERROR(logger, "json: channel missing compulsory member 'prefix");
      return false;
    }
 
    config.channels.emplace_back(std::move(channel));
    return true;
  }
 
}
 
bool Cogs::Core::Image360::Config::parseConfigJson(Cogs::FileContents* contents)
{
 
  Document doc = parseJson(Cogs::StringView((const char*)contents->ptr, contents->size), JsonParseFlags::None);
  if (doc.HasParseError()) {
    LOG_ERROR(logger, "json: malformed document");
    return false;
  }
 
  if (!doc.IsObject()) {
    LOG_ERROR(logger, "json: document root is not an object");
    return false;
  }
 
  rootPath = IO::parentPath(contents->origin());
 
  for (const auto& rootMemberJson : doc.GetObject()) {
    const Cogs::StringView rootMemberName = toView(rootMemberJson.name);
    switch (rootMemberName.hash()) {
    case Cogs::hash("baseSize"):
      if (rootMemberJson.value.IsUint() && rootMemberJson.value.GetUint() != 0) {
        baseSize = rootMemberJson.value.GetUint();
      }
      else {
        LOG_ERROR(logger, "json: root member 'baseSize' not a nonzero uint");
        return false;
      }
      break;
    case Cogs::hash("treeDepth"):
      if (rootMemberJson.value.IsUint() && rootMemberJson.value.GetUint() != 0) {
        treeDepth = rootMemberJson.value.GetUint();
      }
      else {
        LOG_ERROR(logger, "json: root member 'treeDepth' not a nonzero uint");
        return false;
      }
      break;
    case Cogs::hash("extent"):
      if (rootMemberJson.value.IsFloat() && 0.f < rootMemberJson.value.GetFloat()) {
        extent = rootMemberJson.value.GetFloat();
      }
      else {
        LOG_ERROR(logger, "json: root member 'extent' not a positive float");
        return false;
      }
      break;
    case Cogs::hash("depthChannel"):
      if (rootMemberJson.value.IsUint() && rootMemberJson.value.GetUint() < 256) {
        depthChannel = uint8_t(rootMemberJson.value.GetUint());
      }
      else {
        LOG_ERROR(logger, "json: root member 'depthChannel' not a byte-valued uint");
        return false;
      }
      break;
    case Cogs::hash("noDataDepth"):
      if (rootMemberJson.value.IsUint()) {
        noDataDepth = rootMemberJson.value.GetUint();
      }
      else {
        LOG_ERROR(logger, "json: root member 'noDataDepth' not an uint");
        return false;
      }
      break;
    case Cogs::hash("discardNoDepth"):
      if (rootMemberJson.value.IsBool()) {
        discardNoDepth = rootMemberJson.value.GetBool();
      }
      else {
        LOG_ERROR(logger, "json: root member 'discardNoDepth' not a bool");
        return false;
      }
      break;
    case Cogs::hash("channels"):
      if (rootMemberJson.value.IsArray()) {
        for (const auto& channelJson : rootMemberJson.value.GetArray()) {
          if (!parseJsonChannel(*this, channelJson)) return false;
        }
      }
      else {
        LOG_ERROR(logger, "json: root member 'channels' not an array");
        return false;
      }
      break;
    default:
      LOG_ERROR(logger, "json: unexpected root member %.*s", StringViewFormat(rootMemberName));
      return false;
    }
  }
 
  if (baseSize == 0) {
    LOG_ERROR(logger, "json: root missing compulsory member 'baseSize");
    return false;
  }
  if (treeDepth == 0) {
    LOG_ERROR(logger, "json: root missing compulsory member 'treeDepth");
    return false;
  }
  if (channels.empty()) {
    LOG_ERROR(logger, "json: root missing compulsory member 'channels");
    return false;
  }
 
  return true;
}