utils : rework texture download and writing

+ introduce TransferBufferPool to persist transfer buffers
+ Ur5WithSystems.cpp : update recorder use

Author: ManifoldFR

examples/Ur5WithSystems.cpp

@@ -184,13 +184,6 @@ void eventLoop(const Renderer &renderer) {
   }
 }
 
-Renderer createRenderer(Uint32 width, Uint32 height,
-                        SDL_GPUTextureFormat depth_stencil_format) {
-  return Renderer{Device{auto_detect_shader_format_subset(), true},
-                  Window(__FILE__, int(width), int(height), 0),
-                  depth_stencil_format};
-}
-
 int main(int argc, char **argv) {
   CLI::App app{"Ur5 example"};
   bool performRecording{false};
@@ -206,8 +199,11 @@ int main(int argc, char **argv) {
     return 1;
 
   // D16_UNORM works on macOS, D24_UNORM and D32_FLOAT break the depth prepass
-  Renderer renderer =
-      createRenderer(wWidth, wHeight, SDL_GPU_TEXTUREFORMAT_D16_UNORM);
+  Renderer renderer{
+      Device{auto_detect_shader_format_subset(), true},
+      Window(__FILE__, wWidth, wHeight, 0),
+      SDL_GPU_TEXTUREFORMAT_D16_UNORM,
+  };
 
   entt::registry registry{};
 
@@ -414,44 +410,43 @@ int main(int argc, char **argv) {
 
   Uint32 frameNo = 0;
 
-  srand(42);
+  std::srand(42);
   Eigen::VectorXd q0 = pin::neutral(model);
   Eigen::VectorXd q1 = pin::randomConfiguration(model);
 
 #ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
   media::VideoRecorder recorder{NoInit};
+  media::TransferBufferPool transfer_buffer_pool{renderer.device};
   if (performRecording)
-    recorder = media::VideoRecorder{wWidth, wHeight, "ur5.mp4"};
+    recorder = media::VideoRecorder{wWidth,
+                                    wHeight,
+                                    "ur5.mp4",
+                                    {
+                                        .fps = 50,
+                                    }};
 #endif
 
-  auto record_callback = [&] {
-#ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
-    auto swapchain_format = renderer.getSwapchainTextureFormat();
-    media::videoWriteTextureToFrame(renderer.device, recorder,
-                                    renderer.swapchain, swapchain_format,
-                                    wWidth, wHeight);
-#endif
-  };
-
   AABB &worldSpaceBounds = robot_scene.worldSpaceBounds;
   worldSpaceBounds.update({-1.f, -1.f, 0.f}, {+1.f, +1.f, 1.f});
 
   frustumBoundsDebug.addBounds(worldSpaceBounds);
   frustumBoundsDebug.addFrustum(shadowPassInfo.cam);
 
   Eigen::VectorXd q = q0;
+  Eigen::VectorXd qn = q;
+  Eigen::VectorXd v{model.nv};
   const double dt = 1e-2;
 
   while (!quitRequested) {
     // logic
     eventLoop(renderer);
     double alpha = 0.5 * (1. + std::sin(frameNo * dt));
-    Eigen::VectorXd qn = q;
-    q = pin::interpolate(model, q0, q1, alpha);
-    Eigen::VectorXd v = pin::difference(model, q, qn) / dt;
-    pin::forwardKinematics(model, pin_data, q, v);
+    pin::interpolate(model, q0, q1, alpha, qn);
+    v = pin::difference(model, q, qn) / dt;
+    pin::forwardKinematics(model, pin_data, qn, v);
     pin::updateFramePlacements(model, pin_data);
     pin::updateGeometryPlacements(model, pin_data, geom_model, geom_data);
+    q = qn;
     debug_scene.update();
 
     // acquire command buffer and swapchain
@@ -494,19 +489,29 @@ int main(int argc, char **argv) {
     command_buffer.submit();
 
     if (performRecording) {
-      record_callback();
+#ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
+      CommandBuffer command_buffer = renderer.acquireCommandBuffer();
+      auto swapchain_format = renderer.getSwapchainTextureFormat();
+      media::videoWriteTextureToFrame(
+          command_buffer, renderer.device, transfer_buffer_pool, recorder,
+          renderer.swapchain, swapchain_format, wWidth, wHeight);
+#endif
     }
     frameNo++;
   }
 
-  SDL_WaitForGPUIdle(renderer.device);
+  SDL_WaitForGPUIdle();
   frustumBoundsDebug.release();
   depthPass.release();
   shadowDebugPass.release(renderer.device);
   depthDebugPass.release(renderer.device);
   robot_scene.release();
   debug_scene.release();
   gui_system.release();
+#ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
+  recorder.close();
+  transfer_buffer_pool.release();
+#endif
   renderer.destroy();
   SDL_Quit();
   return 0;

src/candlewick/utils/VideoRecorder.cpp

@@ -235,11 +235,7 @@ namespace media {
 
   VideoRecorder::VideoRecorder(Uint32 width, Uint32 height,
                                const std::string &filename)
-      : VideoRecorder(width, height, filename,
-                      Settings{
-                          .outputWidth = int(width),
-                          .outputHeight = int(height),
-                      }) {}
+      : VideoRecorder(width, height, filename, Settings{}) {}
 
   Uint32 VideoRecorder::frameCounter() const { return impl_->m_frameCounter; }
 

src/candlewick/utils/WriteTextureToImage.cpp

@@ -1,15 +1,61 @@
 #include "WriteTextureToImage.h"
 #include "../core/Device.h"
+#include "../core/CommandBuffer.h"
 #include "../third-party/stb_image_write.h"
 #include "../utils/PixelFormatConversion.h"
 
 namespace candlewick::media {
 
-void dumpTextureImgToFile(const Device &device, SDL_GPUTexture *texture,
-                          SDL_GPUTextureFormat format, const Uint32 width,
-                          const Uint32 height, const char *filename) {
+static SDL_GPUTransferBuffer *acquireBufferImpl(SDL_GPUDevice *device,
+                                                Uint32 requiredSize) {
+  SDL_GPUTransferBufferCreateInfo createInfo{
+      .usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD,
+      .size = requiredSize,
+      .props = 0,
+  };
+  return SDL_CreateGPUTransferBuffer(device, &createInfo);
+}
+
+TransferBufferPool::TransferBufferPool(const Device &device) : _device(device) {
+  // pre-allocate 4MB
+  Uint32 size = 1024 * 1024 * 4;
+  _buffer = acquireBufferImpl(_device, size);
+  _currentBufSize = size;
+}
+
+void TransferBufferPool::release() noexcept {
+  if (_device) {
+    if (_buffer)
+      SDL_ReleaseGPUTransferBuffer(_device, _buffer);
+    _buffer = nullptr;
+  }
+  _device = nullptr;
+}
+
+SDL_GPUTransferBuffer *TransferBufferPool::acquireBuffer(Uint32 requiredSize) {
+  if (_currentBufSize < requiredSize) {
+    // 20% boost
+    requiredSize = Uint32(1.2 * requiredSize);
+    SDL_Log("TransferBufferPool: re-allocating %u bytes (increase from %u)",
+            requiredSize, _currentBufSize);
+    _buffer = acquireBufferImpl(_device, requiredSize);
+    _currentBufSize = requiredSize;
+  }
+  return _buffer;
+}
+
+DownloadResult downloadTexture(CommandBuffer &command_buffer,
+                               const Device &device, TransferBufferPool &pool,
+                               SDL_GPUTexture *texture,
+                               SDL_GPUTextureFormat format, const Uint16 width,
+                               const Uint16 height) {
+
+  // pixel size, in bytes
+  const Uint32 pixelSize = SDL_GPUTextureFormatTexelBlockSize(format);
+  const Uint32 requiredSize = width * height * pixelSize;
+  assert(requiredSize ==
+         SDL_CalculateGPUTextureFormatSize(format, width, height, 1));
 
-  SDL_GPUCommandBuffer *command_buffer = SDL_AcquireGPUCommandBuffer(device);
   SDL_GPUCopyPass *copy_pass = SDL_BeginGPUCopyPass(command_buffer);
 
   SDL_GPUTextureRegion source{
@@ -19,17 +65,8 @@ void dumpTextureImgToFile(const Device &device, SDL_GPUTexture *texture,
       .h = height,
   };
 
-  // pixel size, in bytes
-  const Uint32 pixel_size = SDL_GPUTextureFormatTexelBlockSize(format);
-
-  SDL_GPUTransferBuffer *download_transfer_buffer;
-  {
-    SDL_GPUTransferBufferCreateInfo createInfo{
-        .usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD,
-        .size = width * height * pixel_size,
-    };
-    download_transfer_buffer = SDL_CreateGPUTransferBuffer(device, &createInfo);
-  }
+  SDL_GPUTransferBuffer *download_transfer_buffer =
+      pool.acquireBuffer(requiredSize);
 
   SDL_GPUTextureTransferInfo destination{
       .transfer_buffer = download_transfer_buffer,
@@ -39,72 +76,57 @@ void dumpTextureImgToFile(const Device &device, SDL_GPUTexture *texture,
   SDL_DownloadFromGPUTexture(copy_pass, &source, &destination);
   SDL_EndGPUCopyPass(copy_pass);
 
-  SDL_GPUFence *fence =
-      SDL_SubmitGPUCommandBufferAndAcquireFence(command_buffer);
-  SDL_WaitForGPUFences(device, true, &fence, 1);
-  SDL_ReleaseGPUFence(device, fence);
+  command_buffer.submit();
 
   auto *raw_pixels = reinterpret_cast<Uint32 *>(
       SDL_MapGPUTransferBuffer(device, download_transfer_buffer, false));
 
-  Uint32 img_num_bytes = width * height * pixel_size;
-  auto *rgba_pixels = (Uint32 *)std::malloc(img_num_bytes);
+  return {
+      .data = raw_pixels,
+      .format = format,
+      .width = width,
+      .height = height,
+      .buffer = download_transfer_buffer,
+      .payloadSize = requiredSize,
+  };
+}
+
+void writeToFile(CommandBuffer &command_buffer, const Device &device,
+                 TransferBufferPool &pool, SDL_GPUTexture *texture,
+                 SDL_GPUTextureFormat format, Uint16 width, Uint16 height,
+                 const char *filename) {
+
+  auto res = downloadTexture(command_buffer, device, pool, texture, format,
+                             width, height);
+  auto *raw_pixels = res.data;
+  auto *rgba_pixels = (Uint32 *)SDL_malloc(res.payloadSize);
   if (format == SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM) {
-    bgraToRgbaConvert(raw_pixels, rgba_pixels, width * height);
+    bgraToRgbaConvert(raw_pixels, rgba_pixels, res.width * res.height);
   } else {
-    SDL_memcpy(rgba_pixels, raw_pixels, img_num_bytes);
+    SDL_memcpy(rgba_pixels, raw_pixels, res.payloadSize);
   }
 
-  stbi_write_png(filename, int(width), int(height), 4, rgba_pixels, 0);
+  stbi_write_png(filename, int(res.width), int(res.height), 4, rgba_pixels, 0);
   std::free(rgba_pixels);
+
+  SDL_UnmapGPUTransferBuffer(device, res.buffer);
 }
 
 #ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
-void videoWriteTextureToFrame(const Device &device,
-                              media::VideoRecorder &recorder,
-                              SDL_GPUTexture *texture,
-                              SDL_GPUTextureFormat format, const Uint32 width,
-                              const Uint32 height) {
+void videoWriteTextureToFrame(CommandBuffer &command_buffer,
+                              const Device &device, TransferBufferPool &pool,
+                              VideoRecorder &recorder, SDL_GPUTexture *texture,
+                              SDL_GPUTextureFormat format, const Uint16 width,
+                              const Uint16 height) {
   assert(recorder.initialized());
 
-  SDL_GPUCommandBuffer *command_buffer = SDL_AcquireGPUCommandBuffer(device);
-  SDL_GPUCopyPass *copy_pass = SDL_BeginGPUCopyPass(command_buffer);
-
-  const Uint32 pixel_size = SDL_GPUTextureFormatTexelBlockSize(format);
-  const Uint32 payload_size = width * height * pixel_size;
-
-  SDL_GPUTransferBuffer *download_transfer_buffer;
-  {
-    SDL_GPUTransferBufferCreateInfo info{
-        .usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD,
-        .size = payload_size,
-        .props = 0};
-    download_transfer_buffer = SDL_CreateGPUTransferBuffer(device, &info);
-  }
-
-  SDL_GPUTextureTransferInfo destination{
-      .transfer_buffer = download_transfer_buffer,
-      .offset = 0,
-  };
+  auto res = downloadTexture(command_buffer, device, pool, texture, format,
+                             width, height);
 
-  SDL_GPUTextureRegion source_region{
-      .texture = texture,
-      .layer = 0,
-      .w = width,
-      .h = height,
-  };
-
-  SDL_DownloadFromGPUTexture(copy_pass, &source_region, &destination);
-  SDL_EndGPUCopyPass(copy_pass);
-
-  auto *fence = SDL_SubmitGPUCommandBufferAndAcquireFence(command_buffer);
-  SDL_WaitForGPUFences(device, true, &fence, 1);
-  SDL_ReleaseGPUFence(device, fence);
-
-  Uint8 *raw_data = reinterpret_cast<Uint8 *>(
-      SDL_MapGPUTransferBuffer(device, download_transfer_buffer, false));
+  Uint8 *raw_data = reinterpret_cast<Uint8 *>(res.data);
+  recorder.writeFrame(raw_data, res.payloadSize, format);
 
-  recorder.writeFrame(raw_data, payload_size, format);
+  SDL_UnmapGPUTransferBuffer(device, res.buffer);
 }
 #endif
 

src/candlewick/utils/WriteTextureToImage.h

@@ -9,15 +9,50 @@
 namespace candlewick {
 namespace media {
 
-  void dumpTextureImgToFile(const Device &device, SDL_GPUTexture *texture,
-                            SDL_GPUTextureFormat format, const Uint32 width,
-                            const Uint32 height, const char *filename);
+  struct DownloadResult {
+    Uint32 *data;
+    SDL_GPUTextureFormat format;
+    Uint16 width;
+    Uint16 height;
+    SDL_GPUTransferBuffer *buffer; // used for unmapping later
+    Uint32 payloadSize;
+  };
+
+  /// \brief Transfer buffer for the texture downloader.
+  class TransferBufferPool {
+    SDL_GPUDevice *_device = nullptr;
+    SDL_GPUTransferBuffer *_buffer = nullptr;
+    Uint32 _currentBufSize = 0;
+
+  public:
+    TransferBufferPool(const Device &device);
+    void release() noexcept;
+    ~TransferBufferPool() noexcept { this->release(); }
+
+    SDL_GPUTransferBuffer *acquireBuffer(Uint32 requiredSize);
+  };
+
+  /// \brief Download texture to a mapped buffer.
+  ///
+  /// \warning The user is expected to unmap the buffer in the result struct.
+  DownloadResult downloadTexture(CommandBuffer &command_buffer,
+                                 const Device &device, TransferBufferPool &pool,
+                                 SDL_GPUTexture *texture,
+                                 SDL_GPUTextureFormat format,
+                                 const Uint16 width, const Uint16 height);
+
+  void writeToFile(CommandBuffer &command_buffer, const Device &device,
+                   TransferBufferPool &pool, SDL_GPUTexture *texture,
+                   SDL_GPUTextureFormat format, const Uint16 width,
+                   const Uint16 height, const char *filename);
 
 #ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
-  void videoWriteTextureToFrame(const Device &device, VideoRecorder &recorder,
+  void videoWriteTextureToFrame(CommandBuffer &command_buffer,
+                                const Device &device, TransferBufferPool &pool,
+                                VideoRecorder &recorder,
                                 SDL_GPUTexture *texture,
-                                SDL_GPUTextureFormat format, const Uint32 width,
-                                const Uint32 height);
+                                SDL_GPUTextureFormat format, const Uint16 width,
+                                const Uint16 height);
 #endif
 
 } // namespace media