src/lib/vulkan/swapchain/image_pipe_surface_async.cc

// Copyright 2018 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.

#include "image_pipe_surface_async.h"

#include <fidl/fuchsia.sysmem2/cpp/wire.h>
#include <lib/async/cpp/task.h>
#include <lib/fdio/directory.h>
#include <lib/trace/event.h>
#include <vk_dispatch_table_helper.h>

#include <string>

#include <vulkan/vk_layer.h>

#include "fuchsia/sysmem2/cpp/fidl.h"
#include "src/lib/fsl/handles/object_info.h"
#include "src/lib/vulkan/swapchain/vulkan_utils.h"

zx::channel allocator_endpoint_for_test;
zx::channel flatland_endpoint_for_test;

extern "C" {
__attribute__((visibility("default"))) bool imagepipe_initialize_service_channel(
    zx::channel allocator_endpoint, zx::channel flatland_endpoint) {
  allocator_endpoint_for_test = std::move(allocator_endpoint);
  flatland_endpoint_for_test = std::move(flatland_endpoint);
  return true;
}
}

namespace image_pipe_swapchain {

namespace {

const char* const kTag = "ImagePipeSurfaceAsync";
const fuchsia::ui::composition::TransformId kRootTransform = {1};

const std::string DEBUG_NAME =
    fsl::GetCurrentProcessName() + "-" + std::to_string(fsl::GetCurrentProcessKoid());

const std::string PER_APP_PRESENT_TRACING_NAME = "Flatland::PerAppPresent[" + DEBUG_NAME + "]";

}  // namespace

bool ImagePipeSurfaceAsync::Init() {
  const zx_status_t status = fdio_service_connect(
      "/svc/fuchsia.sysmem2.Allocator", sysmem_allocator_.NewRequest().TakeChannel().release());
  if (status != ZX_OK) {
    fprintf(stderr, "%s: Couldn't connect to Sysmem service: %d\n", kTag, status);
    return false;
  }

  fuchsia::sysmem2::AllocatorSetDebugClientInfoRequest debug_client_request;
  debug_client_request.set_name(fsl::GetCurrentProcessName());
  debug_client_request.set_id(fsl::GetCurrentProcessKoid());
  sysmem_allocator_->SetDebugClientInfo(std::move(debug_client_request));

  async::PostTask(loop_.dispatcher(), [this] {
    if (!view_creation_token_.value.is_valid()) {
      fprintf(stderr, "%s: ViewCreationToken is invalid.\n", kTag);
      std::lock_guard<std::mutex> lock(mutex_);
      OnErrorLocked();
      return;
    }

    if (allocator_endpoint_for_test.is_valid()) {
      flatland_allocator_.Bind(std::move(allocator_endpoint_for_test));
    } else {
      const zx_status_t status =
          fdio_service_connect("/svc/fuchsia.ui.composition.Allocator",
                               flatland_allocator_.NewRequest().TakeChannel().release());
      if (status != ZX_OK) {
        fprintf(stderr, "%s: Couldn't connect to Flatland Allocator: %d\n", kTag, status);
        std::lock_guard<std::mutex> lock(mutex_);
        OnErrorLocked();
        return;
      }
    }
    flatland_allocator_.set_error_handler([this](auto status) {
      std::lock_guard<std::mutex> lock(mutex_);
      OnErrorLocked();
    });

    if (flatland_endpoint_for_test.is_valid()) {
      flatland_connection_ =
          simple_present::FlatlandConnection::Create(std::move(flatland_endpoint_for_test), kTag);
    } else {
      flatland_connection_ = simple_present::FlatlandConnection::Create(kTag);
      if (!flatland_connection_) {
        fprintf(stderr, "%s: Couldn't connect to Flatland\n", kTag);
        std::lock_guard<std::mutex> lock(mutex_);
        OnErrorLocked();
        return;
      }
    }
    flatland_connection_->SetErrorCallback([this]() {
      std::lock_guard<std::mutex> lock(mutex_);
      OnErrorLocked();
    });

    fidl::InterfacePtr<fuchsia::ui::composition::ParentViewportWatcher> parent_viewport_watcher;
    // This Flatland doesn't need input or any hit regions, so CreateView() is used instead of
    // CreateView2().
    flatland_connection_->flatland()->CreateView(std::move(view_creation_token_),
                                                 parent_viewport_watcher.NewRequest());
    flatland_connection_->flatland()->CreateTransform(kRootTransform);
    flatland_connection_->flatland()->SetRootTransform(kRootTransform);
    flatland_connection_->flatland()->SetDebugName(DEBUG_NAME);
  });

  return true;
}

bool ImagePipeSurfaceAsync::CreateImage(VkDevice device, VkLayerDispatchTable* pDisp,
                                        VkFormat format, VkImageUsageFlags usage,
                                        VkSwapchainCreateFlagsKHR swapchain_flags,
                                        VkExtent2D extent, uint32_t image_count,
                                        const VkAllocationCallbacks* pAllocator,
                                        std::vector<ImageInfo>* image_info_out) {
  // To create BufferCollection, the image must have a valid format.
  if (format == VK_FORMAT_UNDEFINED) {
    fprintf(stderr, "%s: Invalid format: %d\n", kTag, format);
    return false;
  }

  // Allocate token for BufferCollection.
  fuchsia::sysmem2::BufferCollectionTokenSyncPtr local_token;
  fuchsia::sysmem2::AllocatorAllocateSharedCollectionRequest local_allocate_request;
  local_allocate_request.set_token_request(local_token.NewRequest());
  zx_status_t status =
      sysmem_allocator_->AllocateSharedCollection(std::move(local_allocate_request));
  if (status != ZX_OK) {
    fprintf(stderr, "%s: AllocateSharedCollection failed: %d\n", kTag, status);
    return false;
  }

  // Duplicate tokens to pass around.
  fuchsia::sysmem2::BufferCollectionTokenDuplicateSyncRequest scenic_duplicate_request;
  scenic_duplicate_request.set_rights_attenuation_masks(
      {ZX_RIGHT_SAME_RIGHTS, ZX_RIGHT_SAME_RIGHTS});
  fuchsia::sysmem2::BufferCollectionToken_DuplicateSync_Result dup_sync_result;
  status = local_token->DuplicateSync(std::move(scenic_duplicate_request), &dup_sync_result);
  if (status != ZX_OK) {
    fprintf(stderr, "%s: DuplicateSync failed: %d\n", kTag, status);
    return false;
  }
  if (dup_sync_result.is_framework_err()) {
    fprintf(stderr, "%s: Sync failed with framework_err\n", kTag);
    return false;
  }
  auto scenic_token = std::move(dup_sync_result.response().mutable_tokens()->at(0));
  auto vulkan_token = std::move(dup_sync_result.response().mutable_tokens()->at(1));

  fuchsia::ui::composition::BufferCollectionExportToken export_token;
  fuchsia::ui::composition::BufferCollectionImportToken import_token;
  status = zx::eventpair::create(0, &export_token.value, &import_token.value);
  if (status != ZX_OK) {
    fprintf(stderr, "%s: Eventpair create failed: %d\n", kTag, status);
    return false;
  }

  async::PostTask(loop_.dispatcher(), [this, scenic_token = std::move(scenic_token),
                                       export_token = std::move(export_token)]() mutable {
    // Pass |scenic_token| to Scenic to collect constraints.
    if (flatland_allocator_.is_bound()) {
      fuchsia::ui::composition::RegisterBufferCollectionArgs args = {};
      args.set_export_token(std::move(export_token));
      args.set_buffer_collection_token(
          fidl::InterfaceHandle<fuchsia::sysmem::BufferCollectionToken>(
              scenic_token.TakeChannel()));
      args.set_usage(fuchsia::ui::composition::RegisterBufferCollectionUsage::DEFAULT);
      flatland_allocator_->RegisterBufferCollection(std::move(args), [this](auto result) {
        if (result.is_err()) {
          fprintf(stderr, "%s: Flatland Allocator registration failed.\n", kTag);
          std::lock_guard<std::mutex> lock(mutex_);
          OnErrorLocked();
        }
      });
    }
  });

  // Set swapchain constraints |vulkan_token|.
  VkBufferCollectionCreateInfoFUCHSIA import_info = {
      .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
      .pNext = nullptr,
      .collectionToken = vulkan_token.TakeChannel().release(),
  };
  VkBufferCollectionFUCHSIA collection;
  VkResult result =
      pDisp->CreateBufferCollectionFUCHSIA(device, &import_info, pAllocator, &collection);
  if (result != VK_SUCCESS) {
    fprintf(stderr, "Failed to import buffer collection: %d\n", result);
    return false;
  }
  uint32_t image_flags = 0;
  if (swapchain_flags & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR)
    image_flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
  if (swapchain_flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR)
    image_flags |= VK_IMAGE_CREATE_PROTECTED_BIT;
  VkImageCreateInfo image_create_info = {
      .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
      .pNext = nullptr,
      .flags = image_flags,
      .imageType = VK_IMAGE_TYPE_2D,
      .format = format,
      .extent = VkExtent3D{extent.width, extent.height, 1},
      .mipLevels = 1,
      .arrayLayers = 1,
      .samples = VK_SAMPLE_COUNT_1_BIT,
      .tiling = VK_IMAGE_TILING_OPTIMAL,
      .usage = usage,
      .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
      .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
  };
  const VkSysmemColorSpaceFUCHSIA kSrgbColorSpace = {
      .sType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA,
      .pNext = nullptr,
      .colorSpace = static_cast<uint32_t>(fuchsia::images2::ColorSpace::SRGB)};
  const VkSysmemColorSpaceFUCHSIA kYuvColorSpace = {
      .sType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA,
      .pNext = nullptr,
      .colorSpace = static_cast<uint32_t>(fuchsia::images2::ColorSpace::REC709)};

  VkImageFormatConstraintsInfoFUCHSIA format_info = {
      .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
      .pNext = nullptr,
      .imageCreateInfo = image_create_info,
      .requiredFormatFeatures = GetFormatFeatureFlagsFromUsage(usage),
      .sysmemPixelFormat = 0u,
      .colorSpaceCount = 1,
      .pColorSpaces = IsYuvFormat(format) ? &kYuvColorSpace : &kSrgbColorSpace,
  };
  VkImageConstraintsInfoFUCHSIA image_constraints_info = {
      .sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
      .pNext = nullptr,
      .formatConstraintsCount = 1,
      .pFormatConstraints = &format_info,
      .bufferCollectionConstraints =
          VkBufferCollectionConstraintsInfoFUCHSIA{
              .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA,
              .pNext = nullptr,
              .minBufferCount = 1,
              .maxBufferCount = 0,
              .minBufferCountForCamping = 0,
              .minBufferCountForDedicatedSlack = 0,
              .minBufferCountForSharedSlack = 0,
          },
      .flags = 0u,
  };

  result = pDisp->SetBufferCollectionImageConstraintsFUCHSIA(device, collection,
                                                             &image_constraints_info);
  if (result != VK_SUCCESS) {
    fprintf(stderr, "Failed to set buffer collection constraints: %d\n", result);
    return false;
  }

  // Set |image_count| constraints on the |local_token|.
  fuchsia::sysmem2::BufferCollectionSyncPtr buffer_collection;
  fuchsia::sysmem2::AllocatorBindSharedCollectionRequest bind_request;
  bind_request.set_token(std::move(local_token));
  bind_request.set_buffer_collection_request(buffer_collection.NewRequest());
  status = sysmem_allocator_->BindSharedCollection(std::move(bind_request));
  if (status != ZX_OK) {
    fprintf(stderr, "%s: BindSharedCollection failed: %d\n", kTag, status);
    return false;
  }
  fuchsia::sysmem2::BufferCollectionConstraints constraints;
  constraints.set_min_buffer_count(image_count);
  fuchsia::sysmem2::BufferUsage buffer_usage;
  buffer_usage.set_vulkan(fuchsia::sysmem2::VULKAN_IMAGE_USAGE_SAMPLED);
  constraints.set_usage(std::move(buffer_usage));
  fuchsia::sysmem2::BufferCollectionSetConstraintsRequest constraints_request;
  constraints_request.set_constraints(std::move(constraints));
  status = buffer_collection->SetConstraints(std::move(constraints_request));
  if (status != ZX_OK) {
    fprintf(stderr, "%s: SetConstraints failed: %d %d\n", kTag, image_count, status);
    return false;
  }

  // Wait for buffer to be allocated.
  fuchsia::sysmem2::BufferCollectionInfo buffer_collection_info;
  fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Result wait_for_buffers_result;
  status = buffer_collection->WaitForAllBuffersAllocated(&wait_for_buffers_result);
  if (status != ZX_OK) {
    fprintf(stderr, "%s: WaitForBuffersAllocated failed: %d\n", kTag, status);
    return false;
  }
  if (!wait_for_buffers_result.is_response()) {
    fprintf(stderr, "%s: WaitForBuffersAllocated failed: %u\n", kTag,
            static_cast<uint32_t>(wait_for_buffers_result.err()));
  }
  if (wait_for_buffers_result.response().buffer_collection_info().buffers().size() < image_count) {
    fprintf(stderr, "%s: Failed to allocate %d buffers: %d\n", kTag, image_count, status);
    return false;
  }

  // Insert width and height information while adding images because it wasn't passed in
  // AddBufferCollection().
  fuchsia::images2::ImageFormat image_format = {};
  image_format.mutable_size()->width = extent.width;
  image_format.mutable_size()->height = extent.height;

  for (uint32_t i = 0; i < image_count; ++i) {
    // Create Vk image.
    VkBufferCollectionImageCreateInfoFUCHSIA image_format_fuchsia = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
        .pNext = nullptr,
        .collection = collection,
        .index = i};
    image_create_info.pNext = &image_format_fuchsia;
    VkImage image;
    result = pDisp->CreateImage(device, &image_create_info, pAllocator, &image);
    if (result != VK_SUCCESS) {
      fprintf(stderr, "%s: vkCreateImage failed: %d\n", kTag, result);
      return false;
    }

    // Extract memory handles from BufferCollection.
    VkMemoryRequirements memory_requirements;
    pDisp->GetImageMemoryRequirements(device, image, &memory_requirements);
    VkBufferCollectionPropertiesFUCHSIA properties = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA};
    result = pDisp->GetBufferCollectionPropertiesFUCHSIA(device, collection, &properties);
    if (result != VK_SUCCESS) {
      fprintf(stderr, "%s: GetBufferCollectionPropertiesFUCHSIA failed: %d\n", kTag, status);
      return false;
    }
    uint32_t memory_type_index =
        __builtin_ctz(memory_requirements.memoryTypeBits & properties.memoryTypeBits);
    VkMemoryDedicatedAllocateInfoKHR dedicated_info = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
        .image = image,
    };
    VkImportMemoryBufferCollectionFUCHSIA import_info = {
        .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
        .pNext = &dedicated_info,
        .collection = collection,
        .index = i,
    };
    VkMemoryAllocateInfo alloc_info{
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .pNext = &import_info,
        .allocationSize = memory_requirements.size,
        .memoryTypeIndex = memory_type_index,
    };
    VkDeviceMemory memory;
    result = pDisp->AllocateMemory(device, &alloc_info, pAllocator, &memory);
    if (result != VK_SUCCESS) {
      fprintf(stderr, "%s: vkAllocateMemory failed: %d\n", kTag, result);
      return false;
    }
    result = pDisp->BindImageMemory(device, image, memory, 0);
    if (result != VK_SUCCESS) {
      fprintf(stderr, "%s: vkBindImageMemory failed: %d\n", kTag, result);
      return false;
    }

    ImageInfo info = {
        .image = image,
        .memory = memory,
        .image_id = next_image_id(),
    };
    image_info_out->push_back(info);

    fuchsia::ui::composition::BufferCollectionImportToken import_token_dup;
    zx_status_t status =
        import_token.value.duplicate(ZX_RIGHT_SAME_RIGHTS, &import_token_dup.value);
    if (status != ZX_OK) {
      fprintf(stderr, "%s: Duplicate failed: %d\n", kTag, status);
      return false;
    }
    async::PostTask(loop_.dispatcher(), [this, info, import_token_dup = std::move(import_token_dup),
                                         i, extent]() mutable {
      std::lock_guard<std::mutex> lock(mutex_);
      if (!channel_closed_) {
        fuchsia::ui::composition::ImageProperties image_properties;
        image_properties.set_size({extent.width, extent.height});
        flatland_connection_->flatland()->CreateImage({info.image_id}, std::move(import_token_dup),
                                                      i, std::move(image_properties));
        flatland_connection_->flatland()->SetImageDestinationSize({info.image_id},
                                                                  {extent.width, extent.height});
        // SRC_OVER determines if this image should be blennded with what is behind and does not
        // ignore alpha channel. It is different than VkCompositeAlphaFlagBitsKHR modes.
        flatland_connection_->flatland()->SetImageBlendingFunction(
            {info.image_id}, fuchsia::ui::composition::BlendMode::SRC_OVER);
      }
    });
  }

  pDisp->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
  buffer_collection->Release();

  return true;
}

bool ImagePipeSurfaceAsync::IsLost() {
  std::lock_guard<std::mutex> lock(mutex_);
  return channel_closed_;
}

void ImagePipeSurfaceAsync::RemoveImage(uint32_t image_id) {
  std::lock_guard<std::mutex> lock(mutex_);
  for (auto iter = queue_.begin(); iter != queue_.end();) {
    if (iter->image_id == image_id) {
      iter = queue_.erase(iter);
    } else {
      iter++;
    }
  }

  async::PostTask(loop_.dispatcher(), [this, image_id]() {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!channel_closed_)
      flatland_connection_->flatland()->ReleaseImage({image_id});
  });
}

void ImagePipeSurfaceAsync::PresentImage(uint32_t image_id,
                                         std::vector<std::unique_ptr<PlatformEvent>> acquire_fences,
                                         std::vector<std::unique_ptr<PlatformEvent>> release_fences,
                                         VkQueue queue) {
  std::lock_guard<std::mutex> lock(mutex_);
  TRACE_FLOW_BEGIN("gfx", "image_pipe_swapchain_to_present", image_id);

  std::vector<std::unique_ptr<FenceSignaler>> release_fence_signalers;
  release_fence_signalers.reserve(release_fences.size());

  for (auto& fence : release_fences) {
    zx::event event = static_cast<FuchsiaEvent*>(fence.get())->Take();
    release_fence_signalers.push_back(std::make_unique<FenceSignaler>(std::move(event)));
  }

  if (channel_closed_)
    return;

  std::vector<zx::event> acquire_events;
  acquire_events.reserve(acquire_fences.size());
  for (auto& fence : acquire_fences) {
    zx::event event = static_cast<FuchsiaEvent*>(fence.get())->Take();
    acquire_events.push_back(std::move(event));
  }

  queue_.push_back({image_id, std::move(acquire_events), std::move(release_fence_signalers)});

  if (!present_pending_) {
    async::PostTask(loop_.dispatcher(), [this]() {
      std::lock_guard<std::mutex> lock(mutex_);
      PresentNextImageLocked();
    });
  }
}

SupportedImageProperties& ImagePipeSurfaceAsync::GetSupportedImageProperties() {
  return supported_image_properties_;
}

void ImagePipeSurfaceAsync::PresentNextImageLocked() {
  if (present_pending_)
    return;
  if (queue_.empty())
    return;
  TRACE_DURATION("gfx", "ImagePipeSurfaceAsync::PresentNextImageLocked");

  // To guarantee FIFO mode, we can't have Scenic drop any of our frames.
  // We accomplish that by setting unsquashable flag.
  uint64_t presentation_time = zx_clock_get_monotonic();

  auto& present = queue_.front();
  TRACE_FLOW_END("gfx", "image_pipe_swapchain_to_present", present.image_id);

  TRACE_FLOW_BEGIN("gfx", PER_APP_PRESENT_TRACING_NAME.c_str(), present.image_id);
  if (!channel_closed_) {
    std::vector<zx::event> release_events;
    release_events.reserve(present.release_fences.size());
    for (auto& signaler : present.release_fences) {
      zx::event event;
      signaler->event().duplicate(ZX_RIGHT_SAME_RIGHTS, &event);
      release_events.push_back(std::move(event));
    }

    // In Flatland, release fences apply to the content of the previous present. Keeping track of
    // the previous frame's release fences and swapping ensure we set the correct ones. When the
    // current frame's OnFramePresented callback is called, it is safe to stop tracking the
    // previous frame's |release_fences|.
    previous_present_release_fences_.swap(present.release_fences);

    fuchsia::ui::composition::PresentArgs present_args;
    present_args.set_requested_presentation_time(presentation_time);
    present_args.set_acquire_fences(std::move(present.acquire_fences));
    present_args.set_release_fences(std::move(release_events));
    present_args.set_unsquashable(true);
    flatland_connection_->flatland()->SetContent(kRootTransform, {present.image_id});
    flatland_connection_->Present(std::move(present_args),
                                  // Called on the async loop.
                                  [this, release_fences = std::move(present.release_fences)](
                                      zx_time_t actual_presentation_time) {
                                    std::lock_guard<std::mutex> lock(mutex_);
                                    present_pending_ = false;
                                    for (auto& fence : release_fences) {
                                      fence->reset();
                                    }
                                    PresentNextImageLocked();
                                  });
  }

  queue_.erase(queue_.begin());
  present_pending_ = true;
}

void ImagePipeSurfaceAsync::OnErrorLocked() {
  channel_closed_ = true;
  queue_.clear();
  flatland_connection_.reset();
  previous_present_release_fences_.clear();
}

}  // namespace image_pipe_swapchain