BridgeRasterSource.cpp

#include "BridgeRasterSource.h"
#include "RasterConversion.h"
#include "RasterSourceSubscription.h"
 
#include "../ClipmapTerrainTypes.h"
 
#include "Rendering/ITextures.h"
#include "Rendering/IContext.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <memory>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BridgeRasterSource");
}
 
namespace Cogs
{
  struct RequestClosure
  {
    RequestClosure(size_t generation, size_t tileGeneration) : generation(generation), tileGeneration(tileGeneration) {}
 
    uint64_t providerId = 0;
    BridgeRasterSource * source = nullptr;
    size_t generation = 0;
    size_t id = 0;
    size_t rasterLevel = 0;
    size_t tileGeneration = 0;
  };
 
  void loadTileData(BridgeRasterSource * source,
    RasterTile * tile,
    const size_t requestGeneration,
    const size_t rasterLevel,
    const size_t /*id*/,
    const uint8_t * data,
    int width,
    int height,
    TextureFormat format,
    bool isHeight = false,
    float minZ = 0,
    float maxZ = 0)
  {
#ifdef _WIN32
    source->device->initializeThread();
#endif
 
    const size_t cacheLimit = source->cacheSize;
 
    while (source->textureBufferSize > cacheLimit) {
      WriteLock sourceLock(*source);
 
      source->evictLruTile();
    }
 
    size_t textureSize;
    TextureHandle textureHandle;
 
    const bool supportQuery = (source->getFlags() & RasterSourceFlags::Queryable) != 0;
    bool compressCache = (source->getFlags() & RasterSourceFlags::CompressCache) != 0;
    const bool isCompressible = Cogs::isCompressible(format);
 
    if (compressCache && !isCompressible) {
      if (!source->suppressCompressionError) {
        source->suppressCompressionError = true;
        LOG_ERROR(logger, "Compression only supported for R8G8B8A8_UNORM or R8G8B8A8_UNORM_SRGB format.");
      }
 
      compressCache = false;
    } else if (compressCache && (width % 4 != 0 || height % 4 != 0)) {
      if (!source->suppressDimensionError) {
        LOG_ERROR(logger, "Tile dimensions must be a multiple of 4 to support block compression.");
        source->suppressDimensionError = true;
      }
 
      compressCache = false;
    }
 
    if (compressCache) {
      textureSize = Cogs::getTextureSize(width, height, format) / 4;
 
      std::vector<uint8_t> compressed(textureSize);
      auto compressedFormat = compressTileData(compressed, data, format, width, height);
      
      textureHandle = source->loadTexture(compressed.data(), width, height, compressedFormat, textureSize);
    } else {  
      textureSize = Cogs::getTextureSize(width, height, format);
      textureHandle = source->loadTexture(data, width, height, format, textureSize);
    }
 
    source->device->waitForCommandSync();
 
    TileLoadResponse response{};
    response.rasterLevel = static_cast<int>(rasterLevel);
    response.tile = tile;
 
    std::vector<uint8_t> buffer;
 
    if (supportQuery) {
      source->allocateTileStorage(textureSize, buffer);
      buffer.assign(data, data + textureSize);
    }
 
    {
      WriteLock lock(*source);
 
      source->loadTileData(tile, requestGeneration, buffer, textureHandle, format, textureSize);
 
      if (isHeight) {
        source->isHeight = true;
 
        tile->data->minZ = minZ;
        tile->data->maxZ = maxZ;
 
        source->minZ = std::min(source->minZ, minZ);
        source->maxZ = std::max(source->maxZ, maxZ);
      }
    }
 
    std::lock_guard<std::mutex> lock(source->subscriberMutex);
 
    for (auto handler : source->subscribers) {
      handler->postResponse(response);
    }
  }
 
  void loadCallbackInternal(void * userData, int /*level*/, int /*x*/, int /*y*/, TileData * dataPtr)
  {
    assert(userData && "User data must point to valid closure.");
    assert(dataPtr && "Tile data must point to valid structure.");
 
    std::unique_ptr<RequestClosure> closure(static_cast<RequestClosure *>(userData));
    BridgeRasterSource * source = closure->source;
    
    // Enter processing state for this request. Ensures the tile data etc. is not deleted while the lock
    // is in scope.
    std::lock_guard<RasterSource::Processing> processingLock(source->processing);
    --source->closures;
 
    if (closure->generation < source->generation) {
      // Drop responses to requests made before source was invalidated.
      return;
    }
 
    RasterTile * tile = nullptr;
    {
      ReadLock lock(*source);
 
      tile = source->getTile(closure->id);
    }
 
    if (!tile || (tile->data && (closure->tileGeneration < tile->data->generation))) {
      // Drop responses to requests that have been preempted by later requests.
      return;
    }
 
    auto tileData = reinterpret_cast<const TileData *>(dataPtr);
    auto data = reinterpret_cast<const uint8_t *>(tileData->imageData);
    auto format = tileData->format;
 
    if (data) {
      if (tileData->shouldConvert() || tileData->shouldFlip()) {
        std::vector<uint8_t> convertedData;
        auto targetFormat = convertBitmapData(data, tileData, convertedData);
 
        if (targetFormat == TextureFormat::Unknown) {
          LOG_ERROR(logger, "Texture format %hu not convertible.", tileData->format);
          return;
        }
 
        loadTileData(closure->source, tile, closure->tileGeneration, closure->rasterLevel, closure->id, convertedData.data(), tileData->width, tileData->height, targetFormat, tileData->isHeight(), tileData->minZ, tileData->maxZ);
      } else {
        loadTileData(closure->source, tile, closure->tileGeneration, closure->rasterLevel, closure->id, data, tileData->width, tileData->height, format, tileData->isHeight(), tileData->minZ, tileData->maxZ);
      }
    } else {
      WriteLock lock(*source);
 
      source->loadEmptyTileData(tile);
    }
  }
 
#define CHECKED(c, p) p
 
  void loadCallback(void * userData, int level, int x, int y, TileData * dataPtr)
  {
    RequestClosure * closure = reinterpret_cast<RequestClosure *>(userData);
    BridgeRasterSource * source = closure->source;
 
    assert(closure && "Invalid closure in tile load callback.");
    assert(source && "Invalid raster source in tile load closure.");
 
    // loadCallbackInternal will take ownership of the closure and destroy it.
    CHECKED(source->context, loadCallbackInternal(userData, level, x, y, dataPtr));
  }
}
 
Cogs::BridgeRasterSource::BridgeRasterSource(CogsContext * context, RasterSourceParameters * parameters) :
  context(context),
  cacheSize(parameters->cacheSize),
  providerId(parameters->id),
  flags(parameters->flags),
  requestCallback(parameters->tileRequestCallback),
  allocationCallback(parameters->allocationCallback),
  deallocationCallback(parameters->deallocationCallback)
{
  const bool supportQuery = (flags & RasterSourceFlags::Queryable) != 0;
  const bool compressCache = (flags & RasterSourceFlags::CompressCache) != 0;
 
  if (supportQuery && compressCache) {
    LOG_ERROR(logger, "Raster source cannot support queries on compressed data.");
  }
 
  format = static_cast<TextureFormat>(parameters->format);
  name = std::string(parameters->name);
 
  GeodeticExtent geodeticExtent(parameters->minX, parameters->minY, parameters->maxX, parameters->maxY);
 
  tileLongitudePosts = parameters->tileWidth;
  tileLatitudePosts = parameters->tileHeight;
 
  const size_t numLevels = parameters->numLevels;
 
  double deltaLongitude = parameters->deltaX;
  double deltaLatitude = parameters->deltaY;
 
  const double extentX = geodeticExtent.getEast() - geodeticExtent.getWest();
  const double extentY = geodeticExtent.getNorth() - geodeticExtent.getSouth();
 
  double tilePostDeltaLongitude = deltaLongitude / (double)tileLongitudePosts;
  double tilePostDeltaLatitude = deltaLatitude / (double)tileLatitudePosts;
 
  for (size_t i = 0; i < numLevels; ++i) {
    const int longitudePosts = static_cast<int>(std::ceil(extentX / deltaLongitude)) * tileLongitudePosts;
    const int latitudePosts = static_cast<int>(std::ceil(extentY / deltaLatitude)) * tileLatitudePosts;
 
    assert(longitudePosts > 0 && "Number of longitude posts must be a positive integer.");
    assert(latitudePosts > 0 && "Number of latitude posts must be a positive integer.");
 
    levels.emplace_back(this,
      static_cast<int>(i),
      geodeticExtent,
      parameters->noData,
      longitudePosts,
      latitudePosts,
      tileLongitudePosts,
      tileLatitudePosts,
      tilePostDeltaLongitude,
      tilePostDeltaLatitude);
 
    deltaLongitude /= 2.0;
    deltaLatitude /= 2.0;
 
    tilePostDeltaLongitude /= 2.0;
    tilePostDeltaLatitude /= 2.0;
  }
}
 
Cogs::BridgeRasterSource::~BridgeRasterSource()
{
  assert(!processing.getCount() && "Request processing should be completed before destruction.");
}
 
void Cogs::BridgeRasterSource::requestTile(const TileLoadRequest & request)
{
  const RasterTileIdentifier & identifier = request.tile->identifier;
 
  if (request.tile->isResident()) {
    return;
  }
 
  if (request.tile->isOOB()) {
    loadInvalidTile(request.tile);
 
    return;
  }
 
  auto closure = std::make_unique<RequestClosure>(generation, request.tile->generation);
  closure->providerId = this->providerId;
  closure->source = this;
  closure->rasterLevel = request.tile->identifier.level;
  closure->id = identifier.getHashCode();
 
  ++closures;
 
  if (!requestCallback(closure.get(), loadCallback, identifier.level, identifier.x, identifier.y)) {
    // The request will not be processed, in most cases due to an identical request already being processed.
    --closures;
  } else {
    closure.release();
  }
}
 
void Cogs::BridgeRasterSource::allocateTileStorage(const size_t textureSize, std::vector<uint8_t> & buffer)
{
  if (allocationCallback) {
    allocationCallback(nullptr, static_cast<unsigned int>(textureSize));
  }
 
  buffer.resize(textureSize);
}
 
void Cogs::BridgeRasterSource::deallocateTileStorage(std::vector<uint8_t> & buffer)
{
  if (buffer.size()) {
    if (deallocationCallback) {
      deallocationCallback(nullptr, static_cast<unsigned int>(buffer.size()));
    }
 
    buffer.clear();
    buffer.shrink_to_fit();
  }
}
 
namespace
{
  static std::vector<uint8_t> emptyBuffer;
}
 
void Cogs::BridgeRasterSource::loadInvalidTile(RasterTile * tile)
{
  if (invalidTileHandle == TextureHandle::InvalidHandle) {
    uint8_t bytes[] = {
      110, 110, 110, 0,
      127, 127, 127, 0,
      127, 127, 127, 0,
      110, 110, 110, 0,
    };
 
    invalidTileHandle = device->getTextures()->loadTexture(bytes, 2, 2, TextureFormat::R8G8B8A8_UNORM);
  }
 
  loadTileData(tile, tile->generation, emptyBuffer, invalidTileHandle, TextureFormat::R8G8B8A8_UNORM, 0);
}
 
void Cogs::BridgeRasterSource::loadEmptyTileData(RasterTile * tile)
{
  loadTileData(tile, tile->generation, emptyBuffer, TextureHandle::NoHandle, TextureFormat::R8G8B8A8_UNORM, 0);
}