Blur.cpp

#include "Platform/Instrumentation.h"
#include "Blur.h"
 
#include "Context.h"
 
#include "Services/Features.h"
#include "Services/TaskManager.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Platform/Threads.h"
#include "Foundation/Platform/Timer.h"
 
#include <vector>
#include <algorithm>
#include <iostream>
 
using namespace Cogs::Core;
 
namespace {
  double elapsed = 0.0;
  uint32_t invocations = 0;
}
 
float  Blur::boxFilterWidthFromStdDev(const float stddev,
                                      const uint32_t quality)
{
#if 1
  const double C3 = -0.00216225;
  const double C2 = 0.049443778;
  const double C1 = -0.405850586;
  const double C0 = 1.806223754;
 
  const double slope = ((C3*quality + C2)*quality + C1)*quality + C0;
 
  return static_cast<float>(slope * stddev);
#else
  auto A = (stddev*stddev) / (0.45f*quality);
  auto B = std::pow(A, 1.f / 1.96f);
  return B;
#endif
}
 
void Blur::boxFilterIterations3D(Context* context,
                                 float* output,
                                 const float* input,
                                 const glm::uvec3 size,
                                 const float radius,
                                 const uint32_t iterations)
{
  
  auto minSize = std::min(std::min(size.x, size.y), size.z);
  if (minSize == 0) return;
 
  auto rolex = Timer::startNew();
 
  float r = std::max(0.f, std::min(radius, minSize / 2.f));
 
#ifndef EMSCRIPTEN
  bool useSSE = context->features->supported(CPUFeature::SSE)
    && ((size.x & 3) == 0)
    && ((size.y & 3) == 0)
    && ((size.z & 3) == 0);
    //&& (invocations & 1);
#else
  bool useSSE = false;
#endif
 
  DynamicCpuInstrumentationScope(SCOPE_VOLUMETRIC, "blur", useSSE ? "sse" : "plain");
 
  const auto concurrency = std::max(1u, (uint32_t)Cogs::Threads::hardwareConcurrency());
  std::vector<Memory::TypedBuffer<float>> lineA = std::vector<Memory::TypedBuffer<float>>(concurrency);
  std::vector<Memory::TypedBuffer<float>> lineB = std::vector<Memory::TypedBuffer<float>>(concurrency);;
  for (uint32_t t = 0; t < concurrency; t++) {
    lineA[t].resize(16 * (std::max(size.x, std::max(size.y, size.z)) + 4));
    lineB[t].resize(16 * (std::max(size.x, std::max(size.y, size.z)) + 4));
  }
 
#if 1
  const auto ySplit = std::max(4u, (size.y + concurrency - 1) / concurrency);
  const auto zSplit = std::max(4u, (size.z + concurrency - 1) / concurrency);
 
  auto xGroup = context->taskManager->createGroup();
  for (uint32_t t = 0; t < concurrency; t++) {
    uint32_t a = zSplit*t;
    uint32_t b = std::min(a + zSplit, size.z);
    if (a < b) {
      if (useSSE) context->taskManager->enqueueChild(xGroup, BoxFilterPassXTaskSSE{ input, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
      else context->taskManager->enqueueChild(xGroup, BoxFilterPassXTask{ input, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
    }
  }
  context->taskManager->wait(xGroup);
  context->taskManager->destroy(xGroup);
 
  auto yGroup = context->taskManager->createGroup();
  for (uint32_t t = 0; t < concurrency; t++) {
    uint32_t a = zSplit*t;
    uint32_t b = std::min(a + zSplit, size.z);
    if (a < b) {
      if (useSSE) context->taskManager->enqueueChild(yGroup, BoxFilterPassYTaskSSE{ output, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
      else context->taskManager->enqueueChild(yGroup, BoxFilterPassYTask{ output, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
    }
  }
  context->taskManager->wait(yGroup);
  context->taskManager->destroy(yGroup);
 
  auto zGroup = context->taskManager->createGroup();
  for (uint32_t t = 0; t < concurrency; t++) {
    uint32_t a = ySplit*t;
    uint32_t b = std::min(a + ySplit, size.y);
    if (a < b) {
      if (useSSE) context->taskManager->enqueueChild(zGroup, BoxFilterPassZTaskSSE{ output, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
      else context->taskManager->enqueueChild(zGroup, BoxFilterPassZTask{ output, output, lineA[t].data(), lineB[t].data(), size, r, iterations, a, b });
    }
  }
  context->taskManager->wait(zGroup);
  context->taskManager->destroy(zGroup);
#elif 1
  BoxFilterPassXTaskSSE{ input, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.z }();
  BoxFilterPassYTaskSSE{ output, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.z }();
  BoxFilterPassZTaskSSE{ output, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.y }();
#else 
  BoxFilterPassXTask{ input, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.z }();
  BoxFilterPassYTask{ output, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.z }();
  BoxFilterPassZTask{ output, output, lineA[0].data(), lineB[0].data(), size, r, iterations, 0, size.y }();
#endif
 
  elapsed += rolex.elapsedSeconds();
  invocations++;
}