BaseRasterSource.cpp

#include "BaseRasterSource.h"
#include "JsonSerialization.h"
#include "ImageDecoder.h"
#include "StashService.h"
 
#include "Context.h"
 
#include "Services/Services.h"
#include "Bridge/TerrainFunctions.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
namespace {
  using namespace Cogs::Core::TerrainProvider;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BaseRasterSource");
}
 
bool Cogs::Core::TerrainProvider::BaseConfig::compatible(const BaseConfig* other) const
{
  const float epsilon = 1e-7f;
  if (epsilon < std::abs(extent.min.x - other->extent.min.x) ||
      epsilon < std::abs(extent.min.y - other->extent.min.y) ||
      epsilon < std::abs(extent.max.x - other->extent.max.x) ||
      epsilon < std::abs(extent.max.y - other->extent.max.y))
  {
    LOG_ERROR(logger, "Mismatched extents");
    return false;
  }
 
  if (epsilon < std::abs(tiling.size.x - other->tiling.size.x) ||
      epsilon < std::abs(tiling.size.y - other->tiling.size.y) ||
      tiling.width != other->tiling.width ||
      tiling.height != other->tiling.height ||
      tiling.overlapStart != other->tiling.overlapStart ||
      tiling.overlapEnd != other->tiling.overlapEnd ||
      tiling.levels != other->tiling.levels)
  {
    LOG_ERROR(logger, "Mismatched tilings");
    return false;
  }
 
  if (coordsys.kind != other->coordsys.kind ||
      coordsys.id != other->coordsys.id)
  {
    LOG_ERROR(logger, "Mismatched coord sys");
    return false;
  }
 
  if (textureFormat != other->textureFormat)
  {
    LOG_ERROR(logger, "Mismatched texture formats");
    return false;
  }
 
  if (mimeType != other->mimeType) {
    LOG_ERROR(logger, "Mismatched mime-types");
    return false;
  }
 
  if (cacheKey != other->cacheKey) {
    LOG_ERROR(logger, "Mismatched cache keys");
    return false;
  }
 
  return true;
}
 
 
class Cogs::Core::TerrainProvider::HandleRequestTask
{
public:
  BaseRasterSource* provider = nullptr;
  Request* request = nullptr;
 
  void operator()()
  {
    auto* stash = provider->stashService->getStash();
    assert(stash);
    initializeSharedContext(provider->context, stash->context);
 
    MimeType kind = MimeType::None;
    if (request->failure) {
 
      Cogs::TileData tileData = {};
      tileData.format = provider->textureFormat;
      tileData.width = provider->tiling.width;
      tileData.height = provider->tiling.height;
      tileData.imageData = nullptr;
      tileData.stride = 0;
      tileData.flags = Cogs::TileDataFlags::IsHeight;
 
      request->loadCallback(request->loadData,
                            int(request->id.level),
                            int(request->id.i),
                            int(request->id.j),
                            &tileData);
      {
        Cogs::LockGuard lock(provider->requests.mutex);
        provider->requests.inFlight.erase(tileKey(request->id));
        provider->requests.hasHandleTask.remove(request);
        provider->requests.store.destroy(request);
      }
 
    }
    else if (provider->cache->getTile(stash->contents, kind, request->id)) {
 
      Cogs::TileData tileData = {};
      
      stash->decoder.decode(tileData,
                            stash->contents,
                            kind,
                            provider->tiling.width,
                            provider->tiling.height,
                            provider->noDataValue);
 
      request->loadCallback(request->loadData,
                            int(request->id.level),
                            int(request->id.i),
                            int(request->id.j),
                            &tileData);
 
      {
        Cogs::LockGuard lock(provider->requests.mutex);
        provider->requests.inFlight.erase(tileKey(request->id));
        provider->requests.hasHandleTask.remove(request);
        provider->requests.store.destroy(request);
      }
    }
 
    else {
      {
        Cogs::LockGuard guard(provider->requests.mutex);
        provider->requests.hasHandleTask.remove(request);
        provider->requests.waitingForProvider.pushBack(request);
        request->task = NoTask;
      }
      provider->requestTile(request);
    }
  }
 
};
 
 
uint64_t Cogs::Core::TerrainProvider::tileKey(const TileId& id)
{
  return (uint64_t(id.level) << 56) | (uint64_t(id.j) << 28) | uint64_t(id.i);
}
 
Cogs::Core::TerrainProvider::BaseRasterSource::BaseRasterSource(Context* context) :
  context(context)
{
  stashService = context->services->getService<StashService>();
  assert(stashService);
}
 
 
Cogs::Core::TerrainProvider::BaseRasterSource::~BaseRasterSource()
{
  LOG_DEBUG(logger, "Shutting down %zx", size_t(this));
  setErrorCode(ErrorCode::Done);
 
  std::vector<Request*> running;
  {
    Cogs::LockGuard g(requests.mutex);
    for (auto * item : requests.hasHandleTask) {
      running.push_back(static_cast<Request*>(item));
    }
  }
  for (auto& req : running) {
    context->taskManager->wait(req->task);
  }
}
 
Cogs::Core::TerrainProvider::IRasterSource::ErrorCode Cogs::Core::TerrainProvider::BaseRasterSource::getErrorCode() const
{
  Cogs::LockGuard guard(state.mutex);
  return state.errorCode;
}
 
void Cogs::Core::TerrainProvider::BaseRasterSource::setErrorCode(ErrorCode newErrorCode)
{
  Cogs::LockGuard guard(state.mutex);
  if (state.errorCode == ErrorCode::NoError) {
    state.errorCode = newErrorCode;
  }
}
 
bool Cogs::Core::TerrainProvider::BaseRasterSource::init(const BaseConfig& conf, std::unique_ptr<ICache>&& icache)
{
  cache = std::move(icache);
  assert(cache.get());
 
  extent = conf.extent;
  tiling = conf.tiling;
  coordsys = conf.coordsys;
  textureFormat = conf.textureFormat;
  if (textureFormat == TextureFormat::Unknown) {
    LOG_ERROR(logger, "Unknown texture format");
    return false;
  }
  name = conf.name;
  noDataValue = conf.noData;
  if (!std::isfinite(conf.extent.min.x) ||
      !std::isfinite(conf.extent.min.y) ||
      !std::isfinite(conf.extent.max.x) ||
      !std::isfinite(conf.extent.max.y) ||
      (conf.extent.max.x <= conf.extent.min.x) ||
      (conf.extent.max.y <= conf.extent.min.y))
  {
    LOG_ERROR(logger, "Illegal extent [%f,%f]x[%f,%f]",
              conf.extent.min.x, conf.extent.min.y,
              conf.extent.max.x, conf.extent.max.y);
    return false;
  }
 
  if (!std::isfinite(conf.tiling.size.x) ||
      !std::isfinite(conf.tiling.size.y) ||
      (conf.tiling.size.x <= 0.0) ||
      (conf.tiling.size.y <= 0.0) ||
      (conf.tiling.width == 0) ||
      (conf.tiling.height == 0) ||
      (conf.tiling.levels == 0))
  {
    LOG_ERROR(logger, "Illegal tiling");
    return false;
  }
 
  return true;
}
 
void Cogs::Core::TerrainProvider::BaseRasterSource::getConfig(BaseConfig& conf) const
{
  conf.extent = extent;
  conf.tiling = tiling;
  conf.coordsys = coordsys;
  conf.textureFormat = textureFormat;
  conf.name = name;
}
 
Cogs::RasterSourceParameters Cogs::Core::TerrainProvider::BaseRasterSource::getParameters() const
{
  Cogs::RasterSourceParameters params{};
 
  assert(tiling.overlapStart == 0 && "nonezero overlapStart not handled");
  assert(tiling.overlapEnd == 0 && "nonzero overlapEnd not handled");
 
  params.name = "Foo";// Cogs::Core::Strings::getC(conf.cacheKey);
  params.id = id();
  params.format = textureFormat;
  params.noData = std::numeric_limits<float>::quiet_NaN();  // Appears to be ignored by the terrain engine
  params.minX = extent.min.x;
  params.minY = extent.min.y;
  params.maxX = extent.max.x;
  params.maxY = extent.max.y;
  params.numLevels = tiling.levels;
  params.tileWidth = tiling.width;   // FIXME: handle overlapStart and overlapEnd
  params.tileHeight = tiling.height;
  params.deltaX = tiling.size.x;
  params.deltaY = tiling.size.y;
  params.cacheSize = 128 * 1024 * 1024;
  params.flags = 0;
  params.tileRequestCallback = tileRequestCallbackFunc;
 
  return params;
}
 
void Cogs::Core::TerrainProvider::BaseRasterSource::addTile(const Cogs::Memory::MemoryBuffer& contents, MimeType kind, Request* req, StringView debugLog)
{
  auto& tm = context->taskManager;
  cache->storeTile(contents, kind, req->id, debugLog);
  LOG_DEBUG(logger, "%s: Updated tile %u:%u,%u", Strings::getC(name), req->id.level, req->id.i, req->id.j);
  {
    Cogs::LockGuard guard(requests.mutex);
    requests.waitingForProvider.remove((Request*)req);
    requests.hasHandleTask.pushBack((Request*)req);
    req->task = tm->create(tm->ResourceQueue, HandleRequestTask{ this, req });
  }
  tm->enqueue(req->task);
 
  //  requests.cv.notify_one();
}
 
void Cogs::Core::TerrainProvider::BaseRasterSource::addTileFailure(Request* req, StringView debugLog)
{
  auto& tm = context->taskManager;
  Memory::MemoryBuffer empty;
  cache->storeTile(empty, MimeType::None, req->id, debugLog);
  req->failure = true;
  LOG_DEBUG(logger, "%s: Flagged tile %u:%u,%u as failed", Strings::getC(name), req->id.level, req->id.i, req->id.j);
  {
    Cogs::LockGuard guard(requests.mutex);
    requests.waitingForProvider.remove((Request*)req);
    requests.hasHandleTask.pushBack((Request*)req);
    req->task = tm->create(tm->ResourceQueue, HandleRequestTask{ this, req });
  }
  tm->enqueue(req->task);
 
  //requests.cv.notify_one();
}
 
bool Cogs::Core::TerrainProvider::BaseRasterSource::tileRequestCallbackFunc(void* tileLoadData, TileLoadCallback tileLoadCallback, int level, int x, int y)
{
  // UGLY HACK: The terrain engine does not provide any means to directly
  // identify which provider a request belongs. Thus, we peek into internal
  // structures of the terrain engine. The tileLoadData is a pointer to a
  // structure that holds the closure of this request. The first element
  // of the closure is the id for the provider that we set, and which we
  // defined as the address of the provider.
  struct TerrainEngineRequestClosure
  {
    uint64_t providerId = 0;
  };
  auto* closure = reinterpret_cast<TerrainEngineRequestClosure*>(tileLoadData);
  assert(closure);
  auto* provider = reinterpret_cast<BaseRasterSource*>(closure->providerId);
  assert(provider);
 
  auto& tm = provider->context->taskManager;
 
  if (provider->getErrorCode() == IRasterSource::ErrorCode::NoError) {
 
    // Sanity check
    if (0 <= level && 0 <= x && 0 <= y) {
 
      TileId id{ unsigned(level), unsigned(x), unsigned(y) };
      auto h = tileKey(id);
      {
        Cogs::UniqueLock guard(provider->requests.mutex);
 
        // Check if we already have a request for this specific tile in flight.
        if (provider->requests.inFlight.count(h) == 0) {
 
          // Nope, issue request
          provider->requests.inFlight.insert(h);
          auto* request = provider->requests.store.create();
          request->loadCallback = tileLoadCallback;
          request->loadData = tileLoadData;
          request->id = id;
          request->task = tm->create(tm->ResourceQueue, HandleRequestTask{ provider, request });
          provider->requests.hasHandleTask.pushBack(request);
          guard.unlock();
 
          tm->enqueue(request->task);
 
          //provider->requests.cv.notify_one();
 
          return true;  // Tell terrain engine to keep this closure around
        }
      }
    }
  }
  return false; // Tell terrain engien to release closure
}