Fetcher.cpp

#include "Foundation/Logging/Logger.h"
 
#include "zstd.h"
 
#include "Context.h"
#include "ExtensionRegistry.h"
#include "Resources/DataFetcherManager.h"
#include "Resources/TextureManager.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  bool lookupAndCheckForStaleness(Context* context, Image360System*& system, Image360Component*& comp, Image360Data*& data, const uint32_t instanceId)
  {
    system = ExtensionRegistry::getExtensionSystem<Image360System>(context);
    for (Image360Component& comp_ : system->pool) {
      Image360Data& data_ = system->getData(&comp_);
      if (data_.config.instanceId == instanceId) {
        comp = &comp_;
        data = &data_;
        return true;
      }
    }
    LOG_DEBUG(logger, "[instance=%u] Failed to lookup instance.", instanceId);
    return false;
  }
 
}
 
 
 
void Cogs::Core::Image360::Fetcher::issueChannelFetch(Context* context,
                                                      const Image360Component& im360Comp,
                                                      const Config& config,
                                                      const MapIx mapIx,
                                                      const SlotIx slotIx,
                                                      const uint8_t channelIx,
                                                      const uint8_t revision,
                                                      const size_t cacheLevel,
                                                      const size_t cacheLevelIndex)
{
  assert(channelIx < config.channels.size());
  const Config::Channel& valueChannel = config.channels[channelIx];
 
  std::vector<char> prefix(config.treeDepth + 1, 0);
  size_t t = cacheLevelIndex;
  for (size_t i = cacheLevel; i; --i) {
    prefix[i] = '0' + (t % 4);
    t = t / 4;
  }
  prefix[0] = '0' + char(t);
 
  std::string path = valueChannel.prefix;
  path.append(prefix.data());
 
  bool loadAsData = false;
  switch (valueChannel.dataType) {
  case Config::Channel::DataType::SRGB8_JPEG:
    path.append(".jpg");
    break;
 
  case Config::Channel::DataType::SRGB8_PNG: [[fallthrough]];
  case Config::Channel::DataType::SRGBA8_PNG:
    path.append(".png");
    break;
  case Config::Channel::DataType::U16:
    path.append(".u16");
    loadAsData = true;
    break;
  case Config::Channel::DataType::U16_ZST:
    path.append(".u16.zst");
    loadAsData = true;
    break;
  default:
    assert(false && "Invalid enum");
    break;
  }
 
  LOG_TRACE(logger, "Map=%zu slot=%d rev=%u channel=%u: Issue fetching %s", mapIx, slotIx, revision, channelIx, path.c_str());
  for (const Fetcher::LoadItem& loadItem : itemsLoading) {
    assert(!(loadItem.mapIx == mapIx && loadItem.slotIx == slotIx && loadItem.channelIx == channelIx && loadItem.revision == revision));
  }
 
  if (itemsLoading.empty()) {
    // Loading queue transitions from empty to non-empty, notify
    context->engine->invokeComponentNotifyCallback(im360Comp, (int)Image360Notification::FetchingBegin, nullptr, 0);
  }
 
  Fetcher::LoadItem& loadItem = itemsLoading.emplace_back();
  loadItem.mapIx = mapIx;
  loadItem.slotIx = slotIx;
  loadItem.channelIx = channelIx;
  loadItem.revision = revision;
 
  if (loadAsData) {
    auto handler = [context, instanceId = config.instanceId, w = config.baseSize, channelIx, mapIx, slotIx, revision, dataType = valueChannel.dataType](std::unique_ptr<Cogs::FileContents> contents1)
    {
      LOG_TRACE(logger, "Map=%zu slot=%d rev=%u channel=%u Got data", mapIx, slotIx, revision, channelIx);
 
      bool decompress = false;
      size_t elementSize = 0;
      Cogs::TextureFormat format = Cogs::TextureFormat::Unknown;
      switch (dataType) {
      case Config::Channel::DataType::SRGB8_PNG:
        format = Cogs::DataFormat::R8G8B8_UNORM_SRGB;
        elementSize = 3 * sizeof(uint8_t);
        break;
      case Config::Channel::DataType::SRGBA8_PNG:
        format = Cogs::DataFormat::R8G8B8A8_UNORM_SRGB;
        elementSize = 4 * sizeof(uint8_t);
        break;
      case Config::Channel::DataType::U16:
        format = Cogs::TextureFormat::R16_UINT;
        elementSize = sizeof(uint16_t);
        break;
      case Config::Channel::DataType::U16_ZST:
        format = Cogs::TextureFormat::R16_UINT;
        elementSize = sizeof(uint16_t);
        decompress = true;
        break;
      default:
        assert(false && "Invalid enum");
        break;
      }
 
      // Decompress data or try to move the file contents into a memory buffer
      size_t expectedSize = elementSize * w * w;
      std::unique_ptr<Cogs::Memory::MemoryBuffer> contents2 = std::make_unique<Cogs::Memory::MemoryBuffer>();
      if (contents1) {
        if (decompress) {
          contents2->resize(expectedSize);
          size_t outSize = ZSTD_decompress(contents2->data(), contents2->size(), contents1->ptr, contents1->size);
          if (outSize != expectedSize) {
            LOG_ERROR(logger, "Error decompressing zstd data: %zxu", outSize);
            contents2->clear();
          }
        }
        else {
          Cogs::Memory::MemoryBuffer data_ = contents1->take();
          contents2->swap(data_);
        }
      }
 
      // Try to upload the texture
      TextureHandle texture = TextureHandle::NoHandle;
      if (contents2->size() == expectedSize) {
        TextureLoadInfo* loadInfo = context->textureManager->createLoadInfo();
        loadInfo->target = Cogs::ResourceDimensions::Texture2D;
        loadInfo->width = w;
        loadInfo->height = w;
        loadInfo->format = format;
        loadInfo->loadFlags = ResourceLoadFlags::DoNotCache;
        loadInfo->mipMaps = false;
        loadInfo->resourceData.assign((const char*)contents2->data(), (const char*)contents2->data() + contents2->size());
        texture = context->textureManager->loadTexture(loadInfo);
      }
      else if(!contents2->empty()) {
        LOG_ERROR_ONCE(logger, "Unexpected size of data (got=%zu, expected=%zu)", contents2->size(), expectedSize);
      }
 
      // Update system in main thread
      auto task = [context, instanceId, channelIx, mapIx, slotIx, revision, texture, contents3 = contents2.release()]
      {
        std::unique_ptr<Memory::MemoryBuffer> contents4(contents3);
 
        Image360System* system = nullptr;
        Image360Component* comp = nullptr;
        Image360Data* data = nullptr;
        if (!lookupAndCheckForStaleness(context, system, comp, data, instanceId)) {
          LOG_WARNING(logger, "Map=%zu slot=%d rev=%u channel=%u: Ignoring stale tile data file", mapIx, slotIx, revision, channelIx);
          return;
        }
 
        for (Fetcher::LoadItem& loadItem : data->fetcher.itemsLoading) {
          if ((loadItem.mapIx == mapIx) &&
              (loadItem.slotIx == slotIx) &&
              (loadItem.channelIx == channelIx) &&
              (loadItem.revision == revision))
          {
            if (texture) {
              loadItem.texture = texture;
              loadItem.buffer = std::move(contents4);
            }
            else {
              loadItem.failed = true;
            }
            context->engine->setDirty();
            return;
          }
        }
 
        LOG_WARNING(logger, "Map=%zu slot=%d rev=%u channel=%u: Failed to find matching loadItem", mapIx, slotIx, revision, channelIx);
      };
 
      context->engine->runTaskInMainThread(std::move(task));
    };
    loadItem.fetchId = DataFetcherManager::fetchAsync(context, path, handler, 0, 0, true, Cogs::FileContentsHints::None);
  }
  else {
    loadItem.texture = context->textureManager->loadTexture(path, NoResourceId, TextureLoadFlags::None);
  }
 
}
 
 
bool Cogs::Core::Image360::Fetcher::canLoadAnyItems(const Config& config) const
{
  return itemsLoading.size() < config.maxConcurrent;
}
 
 
void Cogs::Core::Image360::Fetcher::processLoadItems(Context* context,
                                                     const Image360Component& im360Comp,
                                                     Cache& cache,
                                                     const Config& config,
                                                     const uint32_t currentFrame)
{
  itemsLoadingNext.clear();
  for (LoadItem& loadItem : itemsLoading) {
 
    SlotIx slotIx = cache.map[loadItem.mapIx];
    if (0 <= slotIx && loadItem.slotIx == slotIx && cache.items[slotIx].revision == loadItem.revision) {
 
      Cache::Item& cacheItem = cache.items[slotIx];
 
      bool isValue = loadItem.channelIx == config.valueChannel;
      bool isDepth = config.hasDepth && loadItem.channelIx == config.depthChannel;
      const uint32_t age = currentFrame - cacheItem.lastTouched;
 
      if (!isValue && !isDepth) {
        LOG_ERROR(logger, "Map=%zu Slot=%d channel=%u rev=%u channel is neither value nor depth", loadItem.mapIx, slotIx, loadItem.channelIx, loadItem.revision);
        continue;
      }
 
      if (isValue) { assert(cacheItem.value.state == Cache::Item::State::Loading); }
      if (isDepth) { assert(cacheItem.depth.state == Cache::Item::State::Loading); }
 
      if (loadItem.failed || (loadItem.texture && loadItem.texture->hasFailedLoad())) {
        if (isValue) { cacheItem.value.state = Cache::Item::State::Failed; }
        if (isDepth) { cacheItem.depth.state = Cache::Item::State::Failed; }
        LOG_TRACE(logger, "Map=%zu Slot=%d rev=%u failed load item", loadItem.mapIx, slotIx, loadItem.revision);
        continue;
      }
 
      if (loadItem.texture && loadItem.texture->isResident()) {
 
        if (loadItem.texture->description.width != loadItem.texture->description.height) {
          if (isValue) { cacheItem.value.state = Cache::Item::State::Failed; }
          if (isDepth) { cacheItem.depth.state = Cache::Item::State::Failed; }
          LOG_ERROR(logger, "Map=%zu Slot=%d rev=%u texture is not square w=%u h=%u",
                    loadItem.mapIx, slotIx, loadItem.revision, loadItem.texture->description.width, loadItem.texture->description.height);
        }
        else if (loadItem.texture->description.width != config.baseSize) {
          if (isValue) { cacheItem.value.state = Cache::Item::State::Failed; }
          if (isDepth) { cacheItem.depth.state = Cache::Item::State::Failed; }
          LOG_ERROR(logger, "Map=%zu Slot=%d rev=%u texture size (=%u) does not match base size (=%u)",
                    loadItem.mapIx, slotIx, loadItem.revision, loadItem.texture->description.width, config.baseSize);
        }
        else {
          if (isValue) { cacheItem.value.state = Cache::Item::State::Loaded; }
          if (isDepth) { cacheItem.depth.state = Cache::Item::State::Loaded; }
          LOG_TRACE(logger, "Map=%zu Slot=%d rev=%u loaded load item", loadItem.mapIx, slotIx, loadItem.revision);
          itemsUploading.push_back(std::move(loadItem));
        }
 
        context->engine->triggerUpdate();
      }
      else if (3 < age) {
        LOG_DEBUG(logger, "Map=%zu Slot=%d rev=%u: Cancelling loadItem isValue=%u isDepth=%u tex=%u fetch=%u",
                  loadItem.mapIx, slotIx, loadItem.revision,
                  isValue ? 1 : 0, isDepth ? 1 : 0,
                  loadItem.texture ? 1 : 0,
                  loadItem.fetchId != DataFetcherManager::NoFetchId ? 1 : 0);
 
        // Hasn't been requested for two frames, just cancel it.
        if (isValue) { cacheItem.value.state = Cache::Item::State::None; }
        if (isDepth) { cacheItem.depth.state = Cache::Item::State::None; }
        if (loadItem.texture) {
          context->textureManager->cancelTextureLoad(loadItem.texture);
          loadItem.texture = TextureHandle::NoHandle;
        }
        if (loadItem.fetchId != DataFetcherManager::NoFetchId) {
          DataFetcherManager::cancelAsyncFetch(context, loadItem.fetchId);
          loadItem.fetchId = DataFetcherManager::NoFetchId;
        }
 
      }
      else {
        itemsLoadingNext.push_back(std::move(loadItem));
      }
    }
    else {
      LOG_TRACE(logger, "Map=%zu Slot=%d rev=%u: Stale load item", loadItem.mapIx, slotIx, loadItem.revision);
    }
  }
  if (!itemsLoading.empty() && itemsLoadingNext.empty()) {
    // Loading queue transitions from non-empty to empty, notify
    context->engine->invokeComponentNotifyCallback(im360Comp, (int)Image360Notification::FetchingEnd, nullptr, 0);
  }
 
  itemsLoading.swap(itemsLoadingNext);
}