src/devices/lib/sysmem/sysmem.cc

// Copyright 2021 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 "src/devices/lib/sysmem/sysmem.h"

#include <fidl/fuchsia.sysmem/cpp/hlcpp_conversion.h>
#include <fidl/fuchsia.sysmem2/cpp/hlcpp_conversion.h>
#include <lib/sysmem-version/sysmem-version.h>

namespace sysmem {

fuchsia_sysmem::wire::PixelFormat banjo_to_fidl(const pixel_format_t& source) {
  return {
      .type = static_cast<fuchsia_sysmem::wire::PixelFormatType>(source.type),
      .has_format_modifier = source.has_format_modifier,
      .format_modifier =
          {
              .value = source.has_format_modifier ? source.format_modifier.value
                                                  : fuchsia_sysmem::wire::kFormatModifierNone,
          },
  };
}

image_format_2_t fidl_to_banjo(const fuchsia_sysmem::wire::ImageFormat2& source) {
  return {
      .pixel_format =
          {
              .type = static_cast<pixel_format_type_t>(source.pixel_format.type),
              .has_format_modifier = source.pixel_format.has_format_modifier,
              .format_modifier =
                  {
                      .value = source.pixel_format.has_format_modifier
                                   ? source.pixel_format.format_modifier.value
                                   : fuchsia_sysmem::wire::kFormatModifierNone,
                  },
          },
      .coded_width = source.coded_width,
      .coded_height = source.coded_height,
      .bytes_per_row = source.bytes_per_row,
      .display_width = source.display_width,
      .display_height = source.display_height,
      .layers = source.layers,
      .color_space = {static_cast<color_space_type_t>(source.color_space.type)},
      .has_pixel_aspect_ratio = source.has_pixel_aspect_ratio,
      .pixel_aspect_ratio_width = source.pixel_aspect_ratio_width,
      .pixel_aspect_ratio_height = source.pixel_aspect_ratio_height,
  };
}

fuchsia_sysmem::wire::ImageFormat2 banjo_to_fidl(const image_format_2_t& source) {
  return {
      .pixel_format = banjo_to_fidl(source.pixel_format),
      .coded_width = source.coded_width,
      .coded_height = source.coded_height,
      .bytes_per_row = source.bytes_per_row,
      .display_width = source.display_width,
      .display_height = source.display_height,
      .layers = source.layers,
      .color_space =
          {
              .type = static_cast<fuchsia_sysmem::wire::ColorSpaceType>(source.color_space.type),
          },
      .has_pixel_aspect_ratio = source.has_pixel_aspect_ratio,
      .pixel_aspect_ratio_width = source.pixel_aspect_ratio_width,
      .pixel_aspect_ratio_height = source.pixel_aspect_ratio_height,
  };
}

buffer_collection_info_2_t fidl_to_banjo(const fuchsia::sysmem::BufferCollectionInfo_2& source) {
  buffer_collection_info_2_t destination = {
      .buffer_count = source.buffer_count,
      .settings =
          {
              .buffer_settings =
                  {
                      .size_bytes = source.settings.buffer_settings.size_bytes,
                      .is_physically_contiguous =
                          source.settings.buffer_settings.is_physically_contiguous,
                      .is_secure = source.settings.buffer_settings.is_secure,
                      .coherency_domain = static_cast<coherency_domain_t>(
                          source.settings.buffer_settings.coherency_domain),
                      .heap = static_cast<heap_type_t>(source.settings.buffer_settings.heap),
                  },
              .has_image_format_constraints = source.settings.has_image_format_constraints,
          },
  };
  if (source.settings.has_image_format_constraints) {
    const fuchsia::sysmem::ImageFormatConstraints& image_format_constraints =
        source.settings.image_format_constraints;
    destination.settings.image_format_constraints = {
        .pixel_format =
            {
                .type =
                    static_cast<pixel_format_type_t>(image_format_constraints.pixel_format.type),
                .has_format_modifier = image_format_constraints.pixel_format.has_format_modifier,
                .format_modifier =
                    {.value = image_format_constraints.pixel_format.has_format_modifier
                                  ? image_format_constraints.pixel_format.format_modifier.value
                                  : fuchsia_sysmem::wire::kFormatModifierNone},
            },
        .color_spaces_count = image_format_constraints.color_spaces_count,
        .min_coded_width = image_format_constraints.min_coded_width,
        .max_coded_width = image_format_constraints.max_coded_width,
        .min_coded_height = image_format_constraints.min_coded_height,
        .max_coded_height = image_format_constraints.max_coded_height,
        .min_bytes_per_row = image_format_constraints.min_bytes_per_row,
        .max_bytes_per_row = image_format_constraints.max_bytes_per_row,
        .max_coded_width_times_coded_height =
            image_format_constraints.max_coded_width_times_coded_height,
        .layers = image_format_constraints.layers,
        .coded_width_divisor = image_format_constraints.coded_width_divisor,
        .coded_height_divisor = image_format_constraints.coded_height_divisor,
        .bytes_per_row_divisor = image_format_constraints.bytes_per_row_divisor,
        .start_offset_divisor = image_format_constraints.start_offset_divisor,
        .display_width_divisor = image_format_constraints.display_width_divisor,
        .display_height_divisor = image_format_constraints.display_height_divisor,
        .required_min_coded_width = image_format_constraints.required_min_coded_width,
        .required_max_coded_width = image_format_constraints.required_max_coded_width,
        .required_min_coded_height = image_format_constraints.required_min_coded_height,
        .required_max_coded_height = image_format_constraints.required_max_coded_height,
        .required_min_bytes_per_row = image_format_constraints.required_min_bytes_per_row,
        .required_max_bytes_per_row = image_format_constraints.required_max_bytes_per_row,
    };
    for (size_t i = 0; i < image_format_constraints.color_spaces_count; i++) {
      destination.settings.image_format_constraints.color_space[i].type =
          static_cast<color_space_type_t>(image_format_constraints.color_space[i].type);
    }
  }
  for (size_t i = 0; i < source.buffer_count; i++) {
    destination.buffers[i].vmo = source.buffers[i].vmo.get();
    destination.buffers[i].vmo_usable_start = source.buffers[i].vmo_usable_start;
  }
  return destination;
}

buffer_collection_info_2_t fidl_to_banjo(const fuchsia::sysmem2::BufferCollectionInfo& source) {
  // we don't actually use the dup'ed vmo handles for anything (see below)
  auto v1_result =
      sysmem::V1MoveFromV2BufferCollectionInfo(fidl::HLCPPToNatural(fidl::Clone(source)));
  ZX_ASSERT(v1_result.is_ok());
  auto v1_natural = std::move(v1_result.value());
  auto v1 = fidl::NaturalToHLCPP(std::move(v1_natural));

  // the semantics of fidl_to_banjo are that the source handle values are directly placed in the
  // returned buffer_collection_info_2_t
  for (uint32_t i = 0; i < v1.buffer_count; ++i) {
    // we temporarily let v1 believe it owns the lifetimes of the vmos, even though source actually
    // owns the lifetimes of the vmos - this also closes the un-needed vmo handles dup'ed above
    v1.buffers[i].vmo.reset(source.buffers()[i].vmo().get());
  }
  // result gets raw zx_handle_t values from source
  auto result = fidl_to_banjo(v1);
  // the lifetimes of the vmos are actually owned by source not v1, so release v1's vmo handles and
  // intentionally ignore the released handle value as they're still owned by source; this ends the
  // lifetime shenanigans, aside from the fact that fidl_to_banjo is returning a banjo struct with
  // handle lifetimes controlled by source, but ... it's a banjo struct, so ... it is what it is.
  for (uint32_t i = 0; i < v1.buffer_count; ++i) {
    (void)v1.buffers[i].vmo.release();
  }

  return result;
}

}  // namespace sysmem