// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//
// Vulkan WSI platforms are included first
//

#if defined(__linux__)
#define VK_USE_PLATFORM_XCB_KHR
#elif defined(__Fuchsia__)
// VK_USE_PLATFORM_FUCHSIA is already defined
#else
#error "Unsupported WSI platform"
#endif

#include <vulkan/vulkan.h>

//
//
//

#include <getopt.h>
#include <math.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common/macros.h"
#include "common/vk/assert.h"
#include "common/vk/debug_utils.h"
#include "common/vk/find_mem_type_idx.h"
#include "common/vk/pipeline_cache.h"
#include "spinel/platforms/vk/ext/find_target/find_target.h"
#include "spinel/platforms/vk/spinel_vk.h"
#include "spinel/spinel_assert.h"
#include "svg/svg.h"
#include "widget/coords.h"
#include "widget/fps.h"
#include "widget/mouse.h"
#include "widget/svg.h"

//
//
//

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

//////////////////////////////////////////////
//
// Define a platform-specific prefix for the pipeline cache
//

#ifdef __Fuchsia__
#define SPN_PLATFORM_PIPELINE_CACHE_PREFIX_STRING "/cache/."
#else
#define SPN_PLATFORM_PIPELINE_CACHE_PREFIX_STRING "."
#endif

//////////////////////////////////////////////
//
// LINUX
//
// clang-format off
//
#if defined(__linux__)

#include "surface/surface_xcb.h"

#define SPN_PLATFORM_EXTENSION_NAMES         // For example: VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME

#define SPN_PLATFORM_MIN_IMAGE_COUNT         2

#define SPN_PLATFORM_PRESENT_MODE            VK_PRESENT_MODE_FIFO_KHR
                                             // VK_PRESENT_MODE_IMMEDIATE_KHR
                                             // VK_PRESENT_MODE_MAILBOX_KHR
                                             // VK_PRESENT_MODE_FIFO_RELAXED_KHR

#define SPN_PLATFORM_IMAGE_VIEW_FORMAT       VK_FORMAT_B8G8R8A8_UNORM

#define SPN_PLATFORM_SURFACE_FORMAT          (VkSurfaceFormatKHR){ .format     = SPN_PLATFORM_IMAGE_VIEW_FORMAT, \
                                                                   .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };

//////////////////////////////////////////////
//
// FUCHSIA
//
#elif defined(__Fuchsia__)

#include "surface/surface_fuchsia_fb.h"

#define SPN_PLATFORM_EXTENSION_NAMES

#define SPN_PLATFORM_MIN_IMAGE_COUNT         2

#define SPN_PLATFORM_PRESENT_MODE            VK_PRESENT_MODE_FIFO_KHR
                                             // VK_PRESENT_MODE_MAILBOX_KHR
                                             // VK_PRESENT_MODE_IMMEDIATE_KHR
                                             // VK_PRESENT_MODE_FIFO_RELAXED_KHR

#define SPN_PLATFORM_IMAGE_VIEW_FORMAT       VK_FORMAT_R8G8B8A8_UNORM

#define SPN_PLATFORM_SURFACE_FORMAT          (VkSurfaceFormatKHR){ .format     = SPN_PLATFORM_IMAGE_VIEW_FORMAT, \
                                                                   .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };

//////////////////////////////////////////////
//
// UNSUPPORTED
//
#else
#error "Unsupported WSI platform"
#endif

//
// clang-format on
//

//
// What are the max number of queues?
//
// FIXME(allanmac): There should be no limits.
//
#define SPN_VK_Q_COMPUTE_MAX_QUEUES UINT32_MAX
#define SPN_VK_Q_PRESENT_MAX_QUEUES 1

//
//
//

#define SPN_ACQUIRE_DEFAULT_TIMEOUT ((uint64_t)15e9)  // 15 seconds

//
// Support acquiring either a fenced or unfenced presentable
//
typedef VkResult  //
  (*spinel_acquire_presentable_pfn_t)(VkDevice                                  vk_d,
                                      struct surface * const                    surface,
                                      struct surface_presentable const ** const presentable,
                                      void *                                    payload);

//
// Acquire a fenced presentable
//
static VkResult
spinel_acquire_fenced_presentable(VkDevice                            vk_d,
                                  struct surface *                    surface,
                                  struct surface_presentable const ** presentable,
                                  void *                              payload)
{
  //
  // Wait for fence to signal
  //
  VkFence  fence;
  VkResult result = surface_next_fence(surface, &fence);

  switch (result)
    {
      case VK_SUCCESS:
        result = vkWaitForFences(vk_d, 1, &fence, VK_TRUE, SPN_ACQUIRE_DEFAULT_TIMEOUT);

        if (result != VK_SUCCESS)
          {
            return result;
          }
        break;

      case VK_ERROR_OUT_OF_DATE_KHR:
      case VK_ERROR_INITIALIZATION_FAILED:
      case VK_ERROR_DEVICE_LOST:
      default:
        return result;
    }

  //
  // Fence is signaled so attempt to acquire a presentable
  //
  result = surface_acquire(surface, SPN_ACQUIRE_DEFAULT_TIMEOUT, presentable, payload);

  return result;
}

//
// Acquire an unfenced presentable
//
static VkResult
spinel_acquire_unfenced_presentable(VkDevice                            vk_d,
                                    struct surface *                    surface,
                                    struct surface_presentable const ** presentable,
                                    void *                              payload)
{
  VkResult const result = surface_acquire(surface,  //
                                          SPN_ACQUIRE_DEFAULT_TIMEOUT,
                                          presentable,
                                          payload);

  return result;
}

//
//
//
static void
spinel_usage(char * const argv[])
{
  static char const * const pms[] = { "VK_PRESENT_MODE_IMMEDIATE_KHR",
                                      "VK_PRESENT_MODE_MAILBOX_KHR",
                                      "VK_PRESENT_MODE_FIFO_KHR",
                                      "VK_PRESENT_MODE_FIFO_RELAXED_KHR" };
  //
  // clang-format off
  //
  fprintf(stderr,
          "\n"
          "Usage: %s -f <filename> [...]\n"
          " -h                        Print usage.\n"
          " -d <vendorID>:<deviceID>  Execute on a specific Vulkan physical device.  Defaults to first device.\n"
          " -f <filename>             Filename of SVG file.\n"
          " -i <min image count>      Minimum number of images in swapchain. Defaults to %u.\n"
          " -j <pipeline stage>       Select which pipeline stages are enabled on the first loop.    Defaults to `11111`.\n"
          " -k <pipeline stage>       Select which pipeline stages are enabled after the first loop. Defaults to `11111`.\n"
          " -n <frames>               Maximum frames before exiting. Defaults to UINT32_MAX\n"
          " -p <present mode>         Select present mode [0-3]*. Defaults to %u/%s.\n"
          " -q <compute>:<present>    Select the compute and presentation queue family indices.  Defaults to `0:0`\n"
          " -r                        Rotate the SVG file around the origin.  Disabled by default.\n"
          " -t <seconds>              Maximum seconds before exiting. Defaults to UINT32_MAX\n"
          " -v                        Verbose SVG parsing output.  Quiet by default.\n"
          " -F                        Use VkFences to meter swapchain image acquires.\n"
          " -Q                        Disable Vulkan validation layers.  Enabled by default.\n"
          " -D                        Disable Vulkan debug info labels.  Enabled by default.\n"
          " -X                        Skip clearing the image entirely before every render.\n"
          " -c <x>,<y>:<scale>        (<x>,<y>) is the SVG center. Scale by <scale> and translate to center of surface.\n"
          "\n"
          " * Present Modes\n"
          "   -------------\n"
          "   0 : %s *\n"
          "   1 : %s\n"
          "   2 : %s\n"
          "   3 : %s *\n"
          "   * may result in tearing\n"
          "\n",
          argv[0],
          SPN_PLATFORM_MIN_IMAGE_COUNT,
          SPN_PLATFORM_PRESENT_MODE,
          pms[SPN_PLATFORM_PRESENT_MODE],
          pms[0],
          pms[1],
          pms[2],
          pms[3]);
  //
  // clang-format on
  //
}

//
//
//
struct spinel_state
{
  spinel_context_t      context;
  spinel_swapchain_t    swapchain;
  VkExtent2D            extent;
  uint32_t              image_count;
  struct widget_control initial;
  struct widget_control control;

  struct
  {
    float cx;
    float cy;
    float scale;
  } center;

  uint64_t t0;

  bool is_center;
  bool is_rotate;
  bool is_exit;
};

//
//
//
struct spinel_vk
{
  VkInstance                    i;
  VkPhysicalDevice              pd;
  VkDevice                      d;
  VkAllocationCallbacks const * ac;

  struct
  {
    struct
    {
      uint32_t                index;
      VkQueueFamilyProperties props;
    } compute;

    struct
    {
      uint32_t                index;
      VkQueueFamilyProperties props;

      struct
      {
        uint32_t count;
        uint32_t next;
        VkQueue  queues[SPN_VK_Q_PRESENT_MAX_QUEUES];
      } pool;
    } present;
  } q;

  struct
  {
    uint32_t          count;
    uint32_t          next;
    VkCommandPool *   pools;
    VkCommandBuffer * buffers;
    VkSemaphore *     timelines;
    uint64_t *        values;
  } cmd;
};

//
//
//
static void
spinel_secs_set(struct spinel_state * state)
{
  struct timespec ts;

  timespec_get(&ts, TIME_UTC);

  state->t0 = ts.tv_sec * 1000000000UL + ts.tv_nsec;
}

static bool
spinel_secs_lte(struct spinel_state * state, uint32_t seconds)
{
  struct timespec ts;

  timespec_get(&ts, TIME_UTC);

  uint64_t const t1 = ts.tv_sec * 1000000000UL + ts.tv_nsec;

  uint64_t const elapsed = t1 - state->t0;

  return (elapsed <= 1000000000UL * seconds);
}

//
// NOTE(allanmac): Validation layers either correctly or incorrectly identifying
// that the presentation queue submissions are hanging on to the command buffers
// a little longer than expected.
//
// The "+2" appears to resolve this when I expected a "+1" to be all that was
// required given the self-clocking behavior of the render loop.
//
// The assumption was that every swapchain image could be "in flight" and its
// associated command buffer in the post-submission "pending" state.  Adding one
// more command buffer enabled recording while the pending command buffers are
// in flight.
//
// Acquiring a fenced presentable doesn't impact this observation.
//
static void
spinel_vk_cmd_create(struct spinel_vk * vk, uint32_t image_count)
{
  uint32_t const count = image_count + 2;

  vk->cmd.count     = count;
  vk->cmd.next      = 0;
  vk->cmd.pools     = MALLOC_MACRO(count * sizeof(*vk->cmd.pools));
  vk->cmd.buffers   = MALLOC_MACRO(count * sizeof(*vk->cmd.buffers));
  vk->cmd.timelines = MALLOC_MACRO(count * sizeof(*vk->cmd.timelines));
  vk->cmd.values    = CALLOC_MACRO(count, sizeof(*vk->cmd.values));

  VkCommandPoolCreateInfo const cpci = {

    .sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
    .pNext            = NULL,
    .flags            = 0,
    .queueFamilyIndex = vk->q.present.index,
  };

  VkCommandBufferAllocateInfo cbai = {

    .sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
    .pNext              = NULL,
    .level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
    .commandBufferCount = 1,
    /* .commandPool     =  */  // updated on each iteration
  };

  VkSemaphoreTypeCreateInfo const stci = {

    .sType         = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR,
    .pNext         = NULL,
    .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
    .initialValue  = 0UL
  };

  VkSemaphoreCreateInfo const sci = {

    .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    .pNext = &stci,
    .flags = 0
  };

  for (uint32_t ii = 0; ii < count; ii++)
    {
      vk(CreateCommandPool(vk->d, &cpci, vk->ac, vk->cmd.pools + ii));

      cbai.commandPool = vk->cmd.pools[ii];

      vk(AllocateCommandBuffers(vk->d, &cbai, vk->cmd.buffers + ii));

      vk(CreateSemaphore(vk->d, &sci, vk->ac, vk->cmd.timelines + ii));
    }
}

//
//
//
static void
spinel_vk_cmd_destroy(struct spinel_vk * vk)
{
  // VkCommand*
  for (uint32_t ii = 0; ii < vk->cmd.count; ii++)
    {
      vkDestroySemaphore(vk->d, vk->cmd.timelines[ii], vk->ac);
      vkFreeCommandBuffers(vk->d, vk->cmd.pools[ii], 1, vk->cmd.buffers + ii);
      vkDestroyCommandPool(vk->d, vk->cmd.pools[ii], vk->ac);
    }

  free(vk->cmd.values);
  free(vk->cmd.timelines);
  free(vk->cmd.buffers);
  free(vk->cmd.pools);
}

//
//
//
static void
spinel_vk_cmd_regen(struct spinel_vk * vk, uint32_t image_count)
{
  spinel_vk_cmd_destroy(vk);

  spinel_vk_cmd_create(vk, image_count);
}

//
//
//
static void
spinel_vk_q_cmd_create(struct spinel_vk * vk, uint32_t image_count)
{
  vk->q.present.pool.count = MIN_MACRO(uint32_t,  //
                                       SPN_VK_Q_PRESENT_MAX_QUEUES,
                                       vk->q.present.props.queueCount);
  vk->q.present.pool.next  = 0;

  for (uint32_t ii = 0; ii < vk->q.present.pool.count; ii++)
    {
      vkGetDeviceQueue(vk->d, vk->q.present.index, ii, vk->q.present.pool.queues + ii);
    }

  spinel_vk_cmd_create(vk, image_count);
}

//
//
//
static VkQueue
spinel_vk_q_next(struct spinel_vk * vk)
{
  return vk->q.present.pool.queues[vk->q.present.pool.next++ % vk->q.present.pool.count];
}

//
// This is very simple and is only possible because Spinel and the surface
// module will meter access to images.
//
static void
spinel_vk_cb_next(struct spinel_vk * vk,
                  VkCommandBuffer *  cb,
                  VkSemaphore *      timeline,
                  uint64_t *         value)
{
  uint32_t const next = vk->cmd.next++ % vk->cmd.count;

  VkSemaphoreWaitInfo const swi = {
    .sType          = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
    .pNext          = NULL,
    .flags          = 0,
    .semaphoreCount = 1,
    .pSemaphores    = vk->cmd.timelines + next,
    .pValues        = vk->cmd.values + next,
  };

  vk(WaitSemaphores(vk->d, &swi, UINT64_MAX));

  vk(ResetCommandPool(vk->d, vk->cmd.pools[next], 0));

  *cb       = vk->cmd.buffers[next];
  *timeline = vk->cmd.timelines[next];
  *value    = ++vk->cmd.values[next];
}

//
//
//
static void
spinel_vk_destroy(struct spinel_vk * vk)
{
  // VkQueue
  // -- nothing to destroy

  // VkCommand*
  spinel_vk_cmd_destroy(vk);

  // VkDevice
  vkDestroyDevice(vk->d, NULL);

  // VkInstance
  vkDestroyInstance(vk->i, NULL);
}

//
//
//
static void
spinel_state_input(void * data, struct surface_event const * event)
{
  struct spinel_state * const state = data;

  switch (event->type)
    {
        case SURFACE_EVENT_TYPE_EXIT: {
          state->is_exit = true;
          break;
        }

        case SURFACE_EVENT_TYPE_KEYBOARD_PRESS: {
          switch (event->keyboard.code)
            {
              case SURFACE_KEY_1:
                state->control.paths ^= true;
                break;

              case SURFACE_KEY_2:
                state->control.rasters ^= true;
                break;

              case SURFACE_KEY_3:
                state->control.styling ^= true;
                break;

              case SURFACE_KEY_4:
                state->control.composition ^= true;
                break;

              case SURFACE_KEY_5:
                state->control.render ^= true;
                break;

              case SURFACE_KEY_6:
                state->control.flags = 0;
                break;

              case SURFACE_KEY_R:
                state->is_rotate ^= true;
                break;

              case SURFACE_KEY_ESCAPE:
                state->is_exit = true;
                break;

              default:
                break;
            }
          break;
        }

        case SURFACE_EVENT_TYPE_TOUCH_INPUT_CONTACT_COUNT: {
          if (event->touch.contact_count.curr == 4)
            {
              state->is_rotate ^= true;
            }
          else if (event->touch.contact_count.curr == 5)
            {
              state->is_exit = true;
            }
          break;
        }

        default: {
          break;
        }
    }
}

//
// Regen will either succeed or terminally fail
//
static void
spinel_surface_regen(struct surface * surface, struct spinel_state * state)
{
  VkResult result = surface_regen(surface, &state->extent, &state->image_count);

  switch (result)
    {
      case VK_SUCCESS:
        break;

      case VK_ERROR_DEVICE_LOST:
        vk_ok(result);  // fatal -- vk_ok() aborts
        break;

      case VK_ERROR_OUT_OF_HOST_MEMORY:
      case VK_ERROR_OUT_OF_DEVICE_MEMORY:
      case VK_ERROR_SURFACE_LOST_KHR:
      case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
      case VK_ERROR_INITIALIZATION_FAILED:
      default:
        vk_ok(result);  // fatal -- vk_ok() aborts
        break;
    }

  //
  // Regen spinel swapchain
  //
  if (state->swapchain != NULL)
    {
      spinel(swapchain_release(state->swapchain));
    }

  spinel_swapchain_create_info_t const create_info = {
    .extent = {
      .width  = state->extent.width,
      .height = state->extent.height,
    },
    .count = state->image_count,
  };

  spinel(swapchain_create(state->context, &create_info, &state->swapchain));
}

//
//
//
int
main(int argc, char * const argv[])
{
  //
  // set defaults
  //
  uint32_t         vendor_id              = 0;
  uint32_t         device_id              = 0;
  uint32_t         min_image_count        = SPN_PLATFORM_MIN_IMAGE_COUNT;
  uint32_t         frame_count            = UINT32_MAX;
  uint32_t         seconds                = UINT32_MAX;
  uint32_t         qfis[2]                = { 0, 0 };
  VkPresentModeKHR present_mode           = SPN_PLATFORM_PRESENT_MODE;
  bool             is_verbose             = false;
  VkBool32         is_fence_acquired      = false;
  bool             is_validation          = true;
  bool             is_debug_info          = true;
  bool             is_clear_before_render = true;
  char const *     filename               = NULL;

  //
  // initial state of widgets
  //
  struct spinel_state state =  //
    {                          //
      .initial = WIDGET_CONTROL_PRSCR(),
      .control = WIDGET_CONTROL_PRSCR()
    };

  //
  // process options
  //
  int opt;

  while ((opt = getopt(argc, argv, "c:d:f:i:j:k:n:p:q:t:R:rvFQDXh")) != EOF)
    {
      switch (opt)
        {
          case 'c':
            // formatting
            {
              state.is_center    = true;
              state.center.scale = 1.0f;

              char * str_comma;

              state.center.cx = strtof(optarg, &str_comma);

              if (str_comma != optarg)
                {
                  if (*str_comma == ',')
                    {
                      char * str_colon;

                      state.center.cy = strtof(str_comma + 1, &str_colon);

                      if (*str_colon == ':')
                        {
                          state.center.scale = strtof(str_colon + 1, NULL);
                        }
                    }
                }
            }
            break;

          case 'd':
            // formatting
            {
              char * str_colon;

              vendor_id = (uint32_t)strtoul(optarg, &str_colon, 16);  // returns 0 on error

              if (str_colon != optarg)
                {
                  if (*str_colon == ':')
                    {
                      device_id = (uint32_t)strtoul(str_colon + 1, NULL, 16);  // returns 0 on error
                    }
                }
            }
            break;

          case 'f':
            filename = optarg;
            break;

          case 'i':
            min_image_count = (uint32_t)strtoul(optarg, NULL, 10);
            min_image_count = MAX_MACRO(uint32_t, 1, min_image_count);
            break;

          case 'j':
            state.initial.flags = (uint32_t)strtoul(optarg, NULL, 2);
            break;

          case 'k':
            state.control.flags = (uint32_t)strtoul(optarg, NULL, 2);
            break;

          case 'n':
            frame_count = (uint32_t)strtoul(optarg, NULL, 10);
            frame_count = MAX_MACRO(uint32_t, 1, frame_count);
            break;

          case 'p':
            present_mode = (uint32_t)strtoul(optarg, NULL, 10);
            present_mode = MIN_MACRO(uint32_t, present_mode, VK_PRESENT_MODE_FIFO_RELAXED_KHR);
            break;

          case 'q':
            qfis[0] = (uint32_t)strtoul(optarg, NULL, 10);                   // returns 0 on error
            qfis[1] = (uint32_t)strtoul(strchr(optarg, ':') + 1, NULL, 10);  // returns 0 on error
            break;

          case 'r':
            state.is_rotate ^= true;
            break;

          case 't':
            seconds = (uint32_t)strtoul(optarg, NULL, 10);
            break;

          case 'v':
            is_verbose = true;
            break;

          case 'F':
            is_fence_acquired = VK_TRUE;
            break;

          case 'Q':
            is_validation = false;
            break;

          case 'D':
            is_debug_info = false;
            break;

          case 'X':
            is_clear_before_render = false;
            break;

          case 'h':
          default:
            spinel_usage(argv);
            return EXIT_FAILURE;
        }
    }

  //
  // Vulkan handles that we'll need until shutdown
  //
  struct spinel_vk vk = { 0 };

  //
  // define Vulkan 1.2 app
  //
  VkApplicationInfo const app_info = {

    .sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO,
    .pNext              = NULL,
    .pApplicationName   = "Fuchsia Spinel/VK Bench",
    .applicationVersion = 0,
    .pEngineName        = "Fuchsia Spinel/VK",
    .engineVersion      = 0,
    .apiVersion         = VK_API_VERSION_1_2
  };

  //
  // create a Vulkan instance
  //
  char const * const instance_layers[] = {
#if defined(__Fuchsia__)
    "VK_LAYER_FUCHSIA_imagepipe_swapchain_fb",
#endif
    //
    // additional layers here...
    //
    "VK_LAYER_KHRONOS_validation"  // keep this layer name last
  };

  char const * const instance_extensions[] = {
    VK_KHR_SURFACE_EXTENSION_NAME,
#if defined(__linux__)
    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
#elif defined(__Fuchsia__)
    VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME,
#endif
    //
    // additional extensions here...
    //
    VK_EXT_DEBUG_UTILS_EXTENSION_NAME,  // keep this instance name last
  };

  uint32_t const instance_layer_count = ARRAY_LENGTH_MACRO(instance_layers) -  //
                                        (is_validation ? 0 : 1);

  uint32_t const instance_extension_count = ARRAY_LENGTH_MACRO(instance_extensions) -  //
                                            (is_debug_info ? 0 : 1);

  VkInstanceCreateInfo const ici = {

    .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
    .pNext                   = NULL,
    .flags                   = 0,
    .pApplicationInfo        = &app_info,
    .enabledLayerCount       = instance_layer_count,
    .ppEnabledLayerNames     = instance_layers,
    .enabledExtensionCount   = instance_extension_count,
    .ppEnabledExtensionNames = instance_extensions
  };

  vk(CreateInstance(&ici, NULL, &vk.i));

  //
  // initialize debug util pfns
  //
  if (is_debug_info)
    {
      vk_debug_utils_init(vk.i);
    }

  //
  // acquire all physical devices
  //
  uint32_t pd_count;

  vk(EnumeratePhysicalDevices(vk.i, &pd_count, NULL));

  if (pd_count == 0)
    {
      fprintf(stderr, "No device found\n");

      return EXIT_FAILURE;
    }

  VkPhysicalDevice * pds = MALLOC_MACRO(pd_count * sizeof(*pds));

  vk(EnumeratePhysicalDevices(vk.i, &pd_count, pds));

  //
  // default to selecting the first id
  //
  VkPhysicalDeviceProperties pdp;

  vkGetPhysicalDeviceProperties(pds[0], &pdp);

  //
  // default vendor/device is the first physical device
  //
  if ((vendor_id == 0) && (device_id == 0))
    {
      vendor_id = pdp.vendorID;
      device_id = pdp.deviceID;
    }

  //
  // list all devices
  //
  for (uint32_t ii = 0; ii < pd_count; ii++)
    {
      VkPhysicalDeviceProperties pdp_tmp;

      vkGetPhysicalDeviceProperties(pds[ii], &pdp_tmp);

      bool const is_match = (pdp_tmp.vendorID == vendor_id) &&  //
                            (pdp_tmp.deviceID == device_id);

      if (is_match)
        {
          pdp   = pdp_tmp;
          vk.pd = pds[ii];
        }

      fprintf(stdout,
              "%c %X : %X : %s\n",
              is_match ? '*' : ' ',
              pdp_tmp.vendorID,
              pdp_tmp.deviceID,
              pdp_tmp.deviceName);
    }

  if (vk.pd == VK_NULL_HANDLE)
    {
      fprintf(stderr, "Error -- device %X : %X not found.\n", vendor_id, device_id);

      return EXIT_FAILURE;
    }

  //
  // free physical devices
  //
  free(pds);

  //
  // find Spinel target
  //
  spinel_vk_target_t * target = spinel_vk_find_target(vendor_id, device_id);

  if (target == NULL)
    {
      fprintf(stderr, "Error: No target for %X:%X\n", vendor_id, device_id);

      return EXIT_FAILURE;
    }

  //
  // check that we have a valid filename before proceeding
  //
  if ((filename == NULL) || (optind != argc))
    {
      spinel_usage(argv);

      return EXIT_FAILURE;
    }

  //
  // try to load the svg doc
  //
  struct svg * svg_doc;

  svg_doc = svg_open(filename, is_verbose);

  if (svg_doc == NULL)
    {
      fprintf(stderr, "Not a valid SVG file: \"%s\"\n", filename);

      return EXIT_FAILURE;
    }

  //
  // create surface
  //
  struct surface * surface;

#if defined(__linux__)
  surface = surface_xcb_create(vk.i,
                               vk.ac,
                               (VkRect2D[]){ { .offset = { 100, 100 },  //
                                               .extent = { 1024, 1024 } } },
                               "Fuchsia Spinel/VK Bench");
#elif defined(__Fuchsia__)
  surface = surface_fuchsia_create(vk.i, vk.ac);
#else
#error "Unsupported WSI platform"
#endif

  if (surface == NULL)
    {
      fprintf(stderr, "Error -- surface creation failed!\n");
      exit(EXIT_FAILURE);
    }

  //
  // get queue properties
  //
  uint32_t qfp_count;

  vkGetPhysicalDeviceQueueFamilyProperties(vk.pd, &qfp_count, NULL);

  VkQueueFamilyProperties qfp[qfp_count];

  vkGetPhysicalDeviceQueueFamilyProperties(vk.pd, &qfp_count, qfp);

  //
  // make sure qfis[2] are in range
  //
  if ((qfis[0] >= qfp_count) || (qfis[1] >= qfp_count))
    {
      fprintf(stderr,
              "Error -- queue indices out of range: %u:%u >= [0-%u]:[0-%u].\n",
              qfis[0],
              qfis[1],
              qfp_count - 1,
              qfp_count - 1);
    }

  //
  // Validate a compute-capable queue has been selected.
  //
  if ((qfp[qfis[0]].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0)
    {
      fprintf(stderr,
              "Error -- .queueFamilyIndex %u does not not support VK_QUEUE_COMPUTE_BIT.\n",
              qfis[0]);

      exit(EXIT_FAILURE);
    }

  //
  // Validate a graphics-capable queue has been selected.
  //
  if ((qfp[qfis[1]].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)
    {
      fprintf(stderr,
              "Error -- .queueFamilyIndex %u does not not support VK_QUEUE_GRAPHICS_BIT.\n",
              qfis[0]);

      exit(EXIT_FAILURE);
    }

  //
  // Validate a presentable queue has been selected.
  //
  VkBool32 is_queue_presentable;

  vk(GetPhysicalDeviceSurfaceSupportKHR(vk.pd,
                                        qfis[1],
                                        surface_to_vk(surface),
                                        &is_queue_presentable));

  if (!is_queue_presentable)
    {
      fprintf(stderr,
              "Error -- .queueFamilyIndex %u does not not support surface presentation.\n",
              qfis[1]);

      exit(EXIT_FAILURE);
    }

  //
  // save queue props and index
  //
  vk.q.compute.index = qfis[0];
  vk.q.compute.props = qfp[qfis[0]];
  vk.q.present.index = qfis[1];
  vk.q.present.props = qfp[qfis[1]];

  //
  // max queue sizes
  //
  uint32_t const vk_q_compute_count = MIN_MACRO(uint32_t,  //
                                                SPN_VK_Q_COMPUTE_MAX_QUEUES,
                                                vk.q.compute.props.queueCount);

  uint32_t const vk_q_present_count = MIN_MACRO(uint32_t,  //
                                                SPN_VK_Q_PRESENT_MAX_QUEUES,
                                                vk.q.present.props.queueCount);

  //
  // find max queue count
  //
  uint32_t const qps_size = MAX_MACRO(uint32_t, vk_q_compute_count, vk_q_present_count);

  //
  // default queue priorities
  //
  float qps[qps_size];

  for (uint32_t ii = 0; ii < qps_size; ii++)
    {
      qps[ii] = 1.0f;
    }

  //
  // These are the queues that will be used
  //
  VkDeviceQueueCreateInfo dqcis[2] = {
    { .sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
      .pNext            = NULL,
      .flags            = 0,
      .queueFamilyIndex = vk.q.compute.index,
      .queueCount       = vk_q_compute_count,
      .pQueuePriorities = qps },

    { .sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
      .pNext            = NULL,
      .flags            = 0,
      .queueFamilyIndex = vk.q.present.index,
      .queueCount       = vk_q_present_count,
      .pQueuePriorities = qps },
  };

  //
  // Are the queue families the same?  If so, then only list one.
  //
  bool const is_same_queue = (vk.q.compute.index == vk.q.present.index);

  //
  // probe Spinel device requirements for this target
  //
  spinel_vk_target_requirements_t spinel_tr = { 0 };

  spinel_vk_target_get_requirements(target, &spinel_tr);

  //
  // platform extensions
  //
  char const * platform_ext_names[] = {

    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
    SPN_PLATFORM_EXTENSION_NAMES
  };

  uint32_t const platform_ext_count = ARRAY_LENGTH_MACRO(platform_ext_names);
  uint32_t const ext_name_count     = spinel_tr.ext_name_count + platform_ext_count;

  char const * ext_names[ext_name_count];

  memcpy(ext_names, platform_ext_names, sizeof(*ext_names) * platform_ext_count);

  //
  // features
  //
  VkPhysicalDeviceVulkan12Features pdf12 = {
    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
  };

  VkPhysicalDeviceVulkan11Features pdf11 = {
    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
    .pNext = &pdf12
  };

  VkPhysicalDeviceFeatures2 pdf2 = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
                                     .pNext = &pdf11 };

  //
  // populate Spinel device requirements
  //
  spinel_tr.ext_names = ext_names + platform_ext_count;
  spinel_tr.pdf       = &pdf2.features;
  spinel_tr.pdf11     = &pdf11;
  spinel_tr.pdf12     = &pdf12;

  if (!spinel_vk_target_get_requirements(target, &spinel_tr))
    {
      fprintf(stderr, "Error: spinel_vk_target_get_requirements() failure.\n");

      exit(EXIT_FAILURE);
    }

  //
  // create VkDevice
  //
  VkDeviceCreateInfo const vk_dci = {

    .sType                   = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
    .pNext                   = &pdf2,
    .flags                   = 0,
    .queueCreateInfoCount    = is_same_queue ? 1 : 2,
    .pQueueCreateInfos       = dqcis,
    .enabledLayerCount       = 0,
    .ppEnabledLayerNames     = NULL,
    .enabledExtensionCount   = ext_name_count,
    .ppEnabledExtensionNames = ext_names,
    .pEnabledFeatures        = NULL
  };

  vk(CreateDevice(vk.pd, &vk_dci, NULL, &vk.d));

  //
  // create pipeline cache
  //
  VkPipelineCache vk_pc;

  vk_ok(vk_pipeline_cache_create(vk.d,
                                 NULL,
                                 SPN_PLATFORM_PIPELINE_CACHE_PREFIX_STRING "spinel_vk_bench_cache",
                                 &vk_pc));

  //
  // save compute queue index and count
  //
  spinel_vk_context_create_info_t const cci = {
    .vk = {
      .pd = vk.pd,
      .d  = vk.d,
      .pc = vk_pc,
      .ac = vk.ac,
      .q  = {
        .compute = {
          .flags        = dqcis[0].flags,
          .count        = dqcis[0].queueCount,
          .family_index = dqcis[0].queueFamilyIndex,
        },
        .shared  = {
          .family_count   = is_same_queue ? 1 : 2,
          .family_indices = {
            dqcis[0].queueFamilyIndex,
            dqcis[1].queueFamilyIndex,
          },
        },
      },
    },
    .target          = target,
    .block_pool_size = 256UL << 20,  // 256 MB
    .handle_count    = 1 << 18,      // 256K handles
  };

  state.context = spinel_vk_context_create(&cci);

  if (state.context == NULL)
    {
      fprintf(stderr, "Error: failed to create context!\n");

      exit(EXIT_FAILURE);
    }

  //
  // the target is no longer needed
  //
  spinel_vk_target_dispose(target);

  //
  // destroy pipeline cache
  //
  vk_ok(vk_pipeline_cache_destroy(vk.d,
                                  NULL,
                                  SPN_PLATFORM_PIPELINE_CACHE_PREFIX_STRING "spinel_vk_bench_cache",
                                  vk_pc));

  //
  // Get context limits
  //
  spinel_context_limits_t limits;

  spinel(context_get_limits(state.context, &limits));

  //
  // create surface presentables
  //
  VkSurfaceFormatKHR const surface_format    = SPN_PLATFORM_SURFACE_FORMAT;
  VkFormat const           image_view_format = SPN_PLATFORM_IMAGE_VIEW_FORMAT;

  VkImageUsageFlags const image_usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |  //
                                        VK_IMAGE_USAGE_TRANSFER_DST_BIT |  //
                                        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

  VkExtent2D const max_image_extent = { limits.extent.width,  //
                                        limits.extent.height };

  VkComponentMapping const image_view_components = {
    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
  };

  vk_ok(surface_attach(surface,
                       vk.pd,
                       vk.d,
                       is_fence_acquired,
                       &surface_format,
                       min_image_count,
                       &max_image_extent,
                       image_usage,
                       image_view_format,
                       &image_view_components,
                       present_mode));

  //
  // create a transform stack
  //
  struct spinel_transform_stack * const ts = spinel_transform_stack_create(16);

  //
  // Apply world space transform (reflect over y=x at subpixel resolution)
  //
  spinel_transform_stack_push_transform(ts, &limits.global_transform);

  //
  // create builders
  //
  spinel_path_builder_t pb;

  spinel(path_builder_create(state.context, &pb));

  spinel_raster_builder_t rb;

  spinel(raster_builder_create(state.context, &rb));

  //
  // create widgets
  //
  widget_svg_t svg = widget_svg_create(svg_doc, false);  // don't linearize SVG colors

  struct widget * ws[] =
  {
#if !defined(__linux__)
    widget_mouse_create().widget,       // topmost layer
#endif                                  //
    widget_coords_create(8.0f).widget,  //
    widget_fps_create(16.0f).widget,    //
    svg.widget,                         // bottommost layer
  };

  //
  // initialize layout of widgets
  //
  struct widget_layout w_layout        = { 0 };
  uint32_t             group_depth_max = 0;

  widget_layout(ws, ARRAY_LENGTH_MACRO(ws), &w_layout, &group_depth_max);

  spinel_group_id parents[group_depth_max + 1];  // 1 or 2 for now

  //
  // Create composition
  //

  spinel_composition_t composition;

  spinel(composition_create(state.context, &composition));

  //
  // Create styling
  //
  // Sizing: 16 cmds per layer is conservative plus the number of groups and
  // their trail back to the parent
  //
  uint32_t const layer_count = w_layout.group.layer.base + w_layout.group.layer.count;

  spinel_styling_create_info_t const styling_create_info = {

    .layer_count = layer_count,
    .cmd_count   = layer_count * 8 + ARRAY_LENGTH_MACRO(ws) * 32,
  };

  spinel_styling_t styling;

  spinel(styling_create(state.context, &styling_create_info, &styling));

  //
  //
  //
  struct widget_context w_context = {
    .context          = state.context,
    .pb               = pb,
    .rb               = rb,
    .ts               = ts,
    .styling.curr     = styling,
    .composition.curr = composition,
    .parents          = parents,
  };

  //
  // initialize the first loop
  //
  struct widget_control w_control = state.initial;

  //
  // set up rendering extensions
  //
  spinel_vk_swapchain_submit_ext_graphics_signal_t ext_graphics_signal = {
    .ext    = NULL,
    .type   = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_GRAPHICS_SIGNAL,
    .signal = {
      .count = 2,
      //
      // .semaphores[]
      // .values[]
      //
    },
  };

  spinel_vk_swapchain_submit_ext_graphics_store_t ext_graphics_store = {
    .ext                    = &ext_graphics_signal,
    .type                   = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_GRAPHICS_STORE,
    .queue_family_index     = qfis[1],
    .image_info.imageLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
    //
    // .extent_index
    // .cb
    // .queue
    // .old_layout
    // .image
    // .image_info
    //
  };

  spinel_vk_swapchain_submit_ext_graphics_wait_t ext_graphics_wait = {
    .ext  = &ext_graphics_store,
    .type = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_GRAPHICS_WAIT,
    .wait = {
      .count  = 1,
      .stages = { VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT },
      //
      // .semaphores[]
      // .values[]
      //
    },
  };

  spinel_vk_swapchain_submit_ext_compute_acquire_t ext_compute_acquire = {
    .ext                     = &ext_graphics_wait,
    .type                    = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_COMPUTE_ACQUIRE,
    .from_queue_family_index = qfis[1],
  };

  spinel_vk_swapchain_submit_ext_compute_fill_t ext_compute_fill = {
    .ext   = NULL,  // &ext_graphics_wait or &ext_compute_acquire
    .type  = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_COMPUTE_FILL,
    .dword = 0xFFFFFFFF,
  };

  spinel_vk_swapchain_submit_ext_compute_render_t ext_compute_render = {
    .ext  = NULL,  // &ext_compute_fill or &ext_compute_acquire,
    .type = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_COMPUTE_RENDER,
    //
    // .clip = { 0, 0, ... },
    // .extent_index
    //
  };

  spinel_vk_swapchain_submit_ext_compute_release_t ext_compute_release = {
    .ext                   = &ext_compute_render,
    .type                  = SPN_VK_SWAPCHAIN_SUBMIT_EXT_TYPE_COMPUTE_RELEASE,
    .to_queue_family_index = qfis[1],
  };

  spinel_swapchain_submit_t swapchain_submit = {
    .ext         = &ext_compute_release,
    .styling     = styling,
    .composition = composition,
  };

  //
  // refresh the platform surface and spinel swapchain
  //
  spinel_surface_regen(surface, &state);

  //
  // create presentation queue pool and command buffers
  //
  spinel_vk_q_cmd_create(&vk, state.image_count);

  //
  // which "acquire_presentable" function?
  //
  spinel_acquire_presentable_pfn_t acquire_presentable_pfn =  //
    is_fence_acquired                                         //
      ? spinel_acquire_fenced_presentable
      : spinel_acquire_unfenced_presentable;

  //
  // RENDER/INPUT LOOP
  //
  // render and process input
  //
  spinel_secs_set(&state);

  for (uint32_t ii = 0; (ii < frame_count) && spinel_secs_lte(&state, seconds); ii++)
    {
      //
      // Explicit flushing is only for accurately benchmarking a path declaration.
      //
      if (w_control.paths)
        {
          spinel(path_builder_flush(pb));
        }

      //
      // Explicit flushing is only for accurately benchmarking rasterization.
      //
      if (w_control.rasters)
        {
          spinel(raster_builder_flush(rb));
        }

      //
      // RESET WIDGET COMPOSITION?
      //
      if (w_control.composition)
        {
          // unseal and reset composition
          spinel(composition_unseal(composition));
          spinel(composition_reset(composition));

          // update clip
          spinel_pixel_clip_t const clip = {
            .x0 = 0,
            .y0 = 0,
            .x1 = state.extent.width,
            .y1 = state.extent.height,
          };

          spinel(composition_set_clip(composition, &clip));
        }

      //
      // RESET WIDGET STYLING?
      //
      if (w_control.styling)
        {
          // unseal and reset styling
          spinel(styling_unseal(styling));
          spinel(styling_reset(styling));

          //
          // until there is a container widget to implicitly initialize the
          // root, explicitly initialize the styling root group
          //
          widget_regen_styling_root(&w_control, &w_context, &w_layout);
        }

      //
      // REGENERATE WIDGETS
      //
      widget_regen(ws, ARRAY_LENGTH_MACRO(ws), &w_control, &w_context);

      //
      // SEAL COMPOSITION & STYLING
      //
      // The composition and styling are implicitly sealed by render() but let's
      // explicitly seal them here in case we're skipping rendering in the
      // benchmark.
      //
      // NOTE(allanmac): the composition/styling/render API is in flux.
      //
      spinel_composition_seal(composition);
      spinel_styling_seal(styling);

      //
      // RENDER?
      //
      if (w_control.render)
        {
          //
          // ACQUIRE A PRESENTABLE
          //
          struct surface_presentable const * presentable;

          VkResult const acquire_result = acquire_presentable_pfn(vk.d,  //
                                                                  surface,
                                                                  &presentable,
                                                                  NULL);
          //
          // Possible results:
          //
          //   VK_SUCCESS                                   : render
          //   VK_TIMEOUT                                   : fatal
          //   VK_SUBOPTIMAL_KHR                            : render then regen
          //   VK_ERROR_OUT_OF_DATE_KHR                     : regen
          //   VK_ERROR_DEVICE_LOST                         : fatal for now
          //   VK_ERROR_OUT_OF_HOST_MEMORY                  : fatal
          //   VK_ERROR_OUT_OF_DEVICE_MEMORY                : fatal
          //   VK_ERROR_SURFACE_LOST_KHR                    : fatal for now
          //   VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT : fatal for now
          //
          bool is_fatal  = false;
          bool is_render = false;
          bool is_regen  = false;

          switch (acquire_result)
            {
              case VK_SUCCESS:
                is_render = true;
                break;

              case VK_TIMEOUT:
                is_fatal = true;
                break;

              case VK_SUBOPTIMAL_KHR:
                is_render = true;
                is_regen  = true;
                break;

              case VK_ERROR_OUT_OF_DATE_KHR:
              case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
                is_regen = true;
                break;

              case VK_ERROR_DEVICE_LOST:
              case VK_ERROR_OUT_OF_HOST_MEMORY:
              case VK_ERROR_OUT_OF_DEVICE_MEMORY:
              case VK_ERROR_SURFACE_LOST_KHR:
              default:
                is_fatal = true;
                break;
            }

          //
          // UNHANDLED ERROR
          //
          if (is_fatal)
            {
              vk_ok(acquire_result);

              break;
            }

          //
          // RENDER
          //
          if (is_render)
            {
              //
              // Is this a new presentable with an implicit undefined layout?
              //
              bool const is_layout_undefined = (presentable->acquire_count == 1);

              if (is_layout_undefined)
                {
                  // compute_render -> compute_fill -> graphics_wait -> ...
                  ext_compute_render.ext = &ext_compute_fill;
                  ext_compute_fill.ext   = &ext_graphics_wait;
                }
              else if (is_clear_before_render)
                {
                  // compute_render -> compute_fill -> compute_acquire -> graphics_wait -> ...
                  ext_compute_render.ext = &ext_compute_fill;
                  ext_compute_fill.ext   = &ext_compute_acquire;
                }
              else
                {
                  // compute_render -> compute_acquire -> graphics_wait -> ...
                  ext_compute_render.ext = &ext_compute_acquire;
                }

              //
              // Update compute render extension for this presentable
              //
              ext_compute_render.clip.x1      = state.extent.width;
              ext_compute_render.clip.y1      = state.extent.height;
              ext_compute_render.extent_index = presentable->image_index;

              //
              // Wait on presentable's "wait" semaphore
              //
              ext_graphics_wait.wait.semaphores[0] = presentable->wait.semaphore;

              //
              // Update graphics store extension for this presentable
              //
              VkImageLayout const layout_prev = is_layout_undefined  //
                                                  ? VK_IMAGE_LAYOUT_UNDEFINED
                                                  : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

              ext_graphics_store.extent_index         = presentable->image_index;
              ext_graphics_store.queue                = spinel_vk_q_next(&vk);
              ext_graphics_store.layout_prev          = layout_prev;
              ext_graphics_store.image                = presentable->image;
              ext_graphics_store.image_info.imageView = presentable->image_view;

              //
              // Signal presentable's "signal" semaphore
              //
              ext_graphics_signal.signal.semaphores[0] = presentable->signal;

              //
              // Get a command buffer and its associated availability semaphore
              //
              spinel_vk_cb_next(&vk,
                                &ext_graphics_store.cb,
                                ext_graphics_signal.signal.semaphores + 1,
                                ext_graphics_signal.signal.values + 1);

              //
              // Submit compute work
              //
              spinel(swapchain_submit(state.swapchain, &swapchain_submit));

              //
              // Present graphics work
              //
              VkPresentInfoKHR const pi = {
                .sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
                .pNext              = NULL,
                .waitSemaphoreCount = 1,
                .pWaitSemaphores    = &presentable->signal,  // wait on "signal" semaphore
                .swapchainCount     = 1,
                .pSwapchains        = &presentable->swapchain,
                .pImageIndices      = &presentable->image_index,
                .pResults           = NULL,
              };

              (void)vkQueuePresentKHR(ext_graphics_store.queue, &pi);
            }

          //
          // REGEN SWAPCHAIN
          //
          if (is_regen)
            {
              spinel_surface_regen(surface, &state);

              //
              // Why regenerate the command buffers?  It seems unlikely that
              // swapchain image count will ever change -- even when resized --
              // but the spec says nothing about this.  The only way to
              // determine the actual image count is through
              // vkGetSwapchainImagesKHR() after creation of a new swapchain.
              //
              // Note that there is a vkDeviceWaitIdle() hiding in
              // spinel_surface_regen() so we know the queue command buffers
              // aren't executing.
              //
              spinel_vk_cmd_regen(&vk, state.image_count);
            }
        }

      //
      // WIDGET INPUT
      //
      w_control = state.control;  // reset control flags

      widget_surface_input(ws,
                           ARRAY_LENGTH_MACRO(ws),
                           &w_control,
                           surface,
                           spinel_state_input,
                           &state);

      if (state.is_center)
        {
          widget_svg_center(svg,
                            &w_control,
                            &state.extent,
                            state.center.cx,
                            state.center.cy,
                            state.center.scale);
        }

      if (state.is_rotate)
        {
          widget_svg_rotate(svg, &w_control, (float)((ii % 360) * (M_PI * 2.0 / 360.0)));
        }

      //
      // EXIT?
      //
      if (state.is_exit)
        {
          break;
        }
    }

  ////////////////////////////////////
  //
  // DISPOSAL
  //

  // done with swapchain
  spinel_swapchain_release(state.swapchain);

  // unseal Spinel composition and styling to ensure rendering is complete
  spinel(composition_unseal(composition));
  spinel(styling_unseal(styling));

  // widgets -- may release paths and rasters
  widget_destroy(ws, ARRAY_LENGTH_MACRO(ws), &w_context);

  // release the Spinel builders, composition and styling
  spinel(path_builder_release(pb));
  spinel(raster_builder_release(rb));
  spinel(composition_release(composition));
  spinel(styling_release(styling));

  // release the transform stack
  spinel_transform_stack_release(ts);

  // release the Spinel context
  spinel(context_release(state.context));

  // svg doc
  svg_dispose(svg_doc);

  // surface
  surface_destroy(surface);  // will implicitly `detach(surface)`

  // destroy vk handles
  spinel_vk_destroy(&vk);

  return EXIT_SUCCESS;
}

//
//
//