| // 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 <zircon/availability.h> |
| |
| // This file is always in the GN sources list, but its contents should not be |
| // used for API levels other than HEAD where images2 and sysmem2 are supported. |
| |
| #if __Fuchsia_API_level__ < 19 |
| // Enable a subset of functionality. See https://fxbug.dev/42085119. |
| // It cannot be undefined because other Fuchsia headers may indirectly include image_format.h. |
| #define __ALLOW_IMAGES2_AND_SYSMEM2_TYPES_ONLY__ |
| #endif |
| |
| #include <fidl/fuchsia.images2/cpp/fidl.h> |
| #include <fidl/fuchsia.sysmem2/cpp/fidl.h> |
| |
| #include "lib/image-format/image_format.h" |
| |
| #if defined(FIDL_ALLOW_DEPRECATED_C_BINDINGS) |
| #include <fuchsia/sysmem/c/fidl.h> |
| #endif |
| #include <lib/fidl/cpp/wire_natural_conversions.h> |
| #include <lib/sysmem-version/sysmem-version.h> |
| #include <lib/zbi-format/graphics.h> |
| #include <zircon/assert.h> |
| |
| #include <algorithm> |
| #include <map> |
| #include <set> |
| |
| #include <fbl/algorithm.h> |
| #include <safemath/safe_math.h> |
| |
| using safemath::CheckAdd; |
| using safemath::CheckDiv; |
| using safemath::CheckMul; |
| using safemath::CheckSub; |
| |
| #if __Fuchsia_API_level__ < 19 |
| // This is used by the ImageFormatSet implementations before it is defined. |
| // Normally, it is declared by the header. |
| uint32_t ImageFormatStrideBytesPerWidthPixel(const PixelFormatAndModifier& pixel_format); |
| #endif |
| |
| namespace { |
| |
| using ColorSpace = fuchsia_images2::ColorSpace; |
| using ImageFormat = fuchsia_images2::ImageFormat; |
| using ImageFormatConstraints = fuchsia_sysmem2::ImageFormatConstraints; |
| using PixelFormat = fuchsia_images2::PixelFormat; |
| |
| using ColorSpaceWire = fuchsia_images2::wire::ColorSpace; |
| using ImageFormatWire = fuchsia_images2::wire::ImageFormat; |
| using ImageFormatConstraintsWire = fuchsia_sysmem2::wire::ImageFormatConstraints; |
| using PixelFormatWire = fuchsia_images2::wire::PixelFormat; |
| |
| #if __Fuchsia_API_level__ >= 19 |
| // There are two aspects of the ColorSpaceWire and PixelFormatWire that we care about: |
| // * bits-per-sample - bits per primary sample (R, G, B, or Y) |
| // * RGB vs. YUV - whether the system supports the ColorSpaceWire or PixelFormatWire |
| // representing RGB data or YUV data. Any given ColorSpaceWire only supports |
| // one or the other. Currently any given PixelFormatWire only supports one or |
| // the other and this isn't likely to change. |
| // While we could just list all the ColorSpaceWire(s) that each PixelFormatWire could |
| // plausibly support, expressing in terms of bits-per-sample and RGB vs. YUV is |
| // perhaps easier to grok. |
| |
| enum ColorType { kColorType_NONE, kColorType_RGB, kColorType_YUV }; |
| |
| struct SamplingInfo { |
| std::set<uint32_t> possible_bits_per_sample; |
| std::set<ColorType> color_types; |
| }; |
| |
| const std::map<ColorSpaceWire, SamplingInfo> kColorSpaceSamplingInfo = { |
| {ColorSpace::kSrgb, {{8, 10, 12, 16}, {kColorType_RGB}}}, |
| {ColorSpace::kRec601Ntsc, {{8, 10}, {kColorType_YUV}}}, |
| {ColorSpace::kRec601NtscFullRange, {{8, 10}, {kColorType_YUV}}}, |
| {ColorSpace::kRec601Pal, {{8, 10}, {kColorType_YUV}}}, |
| {ColorSpace::kRec601PalFullRange, {{8, 10}, {kColorType_YUV}}}, |
| {ColorSpace::kRec709, {{8, 10}, {kColorType_YUV}}}, |
| {ColorSpace::kRec2020, {{10, 12}, {kColorType_YUV}}}, |
| {ColorSpace::kRec2100, {{10, 12}, {kColorType_YUV}}}, |
| }; |
| const std::map<PixelFormatWire, SamplingInfo> kPixelFormatSamplingInfo = { |
| {PixelFormat::kR8G8B8A8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kR8G8B8X8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kB8G8R8A8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kB8G8R8X8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kI420, {{8}, {kColorType_YUV}}}, |
| {PixelFormat::kM420, {{8}, {kColorType_YUV}}}, |
| {PixelFormat::kNv12, {{8}, {kColorType_YUV}}}, |
| {PixelFormat::kP010, {{10}, {kColorType_YUV}}}, |
| {PixelFormat::kYuy2, {{8}, {kColorType_YUV}}}, |
| // 8 bits RGB when uncompressed - in this context, MJPEG is essentially |
| // pretending to be uncompressed. |
| {PixelFormat::kMjpeg, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kYv12, {{8}, {kColorType_YUV}}}, |
| {PixelFormat::kB8G8R8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kR8G8B8, {{8}, {kColorType_RGB}}}, |
| |
| // These use the same colorspaces as regular 8-bit-per-component formats |
| {PixelFormat::kR5G6B5, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kR3G3B2, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kR2G2B2X2, {{8}, {kColorType_RGB}}}, |
| |
| // Expands to RGB or YUV |
| {PixelFormat::kL8, {{8}, {kColorType_RGB, kColorType_YUV}}}, |
| {PixelFormat::kR8, {{8}, {kColorType_RGB, kColorType_YUV}}}, |
| |
| {PixelFormat::kR8G8, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kA2B10G10R10, {{8}, {kColorType_RGB}}}, |
| {PixelFormat::kA2R10G10B10, {{8}, {kColorType_RGB}}}, |
| }; |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| constexpr uint32_t kTransactionEliminationAlignment = 64; |
| // The transaction elimination buffer is always reported as plane 3. |
| constexpr uint32_t kTransactionEliminationPlane = 3; |
| |
| uint64_t arm_transaction_elimination_row_size(uint32_t width) { |
| uint32_t kTileSize = 32; |
| uint32_t kBytesPerTilePerRow = 16; |
| uint32_t width_in_tiles = fbl::round_up(width, kTileSize) / kTileSize; |
| return fbl::round_up(width_in_tiles * kBytesPerTilePerRow, kTransactionEliminationAlignment); |
| } |
| |
| uint64_t arm_transaction_elimination_buffer_size(uint64_t start, uint32_t width, uint32_t height) { |
| uint32_t kTileSize = 32; |
| uint32_t end = start; |
| end = fbl::round_up(end, kTransactionEliminationAlignment); |
| uint32_t kHeaderSize = kTransactionEliminationAlignment; |
| end += kHeaderSize; |
| uint32_t height_in_tiles = fbl::round_up(height, kTileSize) / kTileSize; |
| end += arm_transaction_elimination_row_size(width) * 2 * height_in_tiles; |
| return end - start; |
| } |
| |
| class ImageFormatSet { |
| public: |
| virtual const char* Name() const = 0; |
| virtual bool IsSupported(const PixelFormatAndModifier& pixel_format) const = 0; |
| virtual uint64_t ImageFormatImageSize(const ImageFormat& image_format) const = 0; |
| virtual bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const = 0; |
| virtual bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const = 0; |
| virtual bool ImageFormatMinimumRowBytes( |
| const fuchsia_sysmem2::ImageFormatConstraints& constraints, uint32_t width, |
| uint32_t* minimum_row_bytes_out) const = 0; |
| }; |
| |
| class IntelTiledFormats : public ImageFormatSet { |
| public: |
| const char* Name() const override { return "IntelTiledFormats"; } |
| |
| bool IsSupported(const PixelFormatAndModifier& pixel_format) const override { |
| if (pixel_format.pixel_format != PixelFormat::kR8G8B8A8 && |
| pixel_format.pixel_format != PixelFormat::kR8G8B8X8 && |
| pixel_format.pixel_format != PixelFormat::kB8G8R8A8 && |
| pixel_format.pixel_format != PixelFormat::kB8G8R8X8 && |
| pixel_format.pixel_format != PixelFormat::kNv12) { |
| return false; |
| } |
| switch (pixel_format.pixel_format_modifier) { |
| case fuchsia_images2::PixelFormatModifier::kIntelI915XTiled: |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YTiled: |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YfTiled: |
| // X-Tiled CCS is not supported. |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YTiledCcs: |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YfTiledCcs: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| uint64_t ImageFormatImageSize(const ImageFormat& image_format) const override { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier(pixel_format_and_modifier))); |
| |
| uint32_t width_in_tiles, height_in_tiles; |
| uint32_t num_of_planes = FormatNumOfPlanes(image_format.pixel_format().value()); |
| uint64_t size = 0u; |
| |
| for (uint32_t plane_idx = 0; plane_idx < num_of_planes; plane_idx += 1) { |
| GetSizeInTiles(image_format, plane_idx, &width_in_tiles, &height_in_tiles); |
| size += (width_in_tiles * height_in_tiles * kIntelTileByteSize); |
| } |
| |
| if (FormatHasCcs(pixel_format_and_modifier)) { |
| size += CcsSize(width_in_tiles, height_in_tiles); |
| } |
| |
| return size; |
| } |
| |
| bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const override { |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier( |
| image_format.pixel_format().value(), image_format.pixel_format_modifier().value()))); |
| |
| uint32_t num_of_planes = FormatNumOfPlanes(image_format.pixel_format().value()); |
| |
| uint32_t end_plane; |
| |
| // For image data planes, calculate the size of all previous the image data planes |
| if (plane < num_of_planes) { |
| end_plane = plane; |
| } else if (plane == kCcsPlane) { // If requesting the CCS Aux plane, calculate the size of all |
| // the image data planes |
| end_plane = num_of_planes; |
| } else { // Plane is out of bounds, return false |
| return false; |
| } |
| |
| uint64_t offset = 0u; |
| for (uint32_t plane_idx = 0u; plane_idx < end_plane; plane_idx += 1u) { |
| uint32_t width_in_tiles, height_in_tiles; |
| GetSizeInTiles(image_format, plane_idx, &width_in_tiles, &height_in_tiles); |
| offset += (width_in_tiles * height_in_tiles * kIntelTileByteSize); |
| } |
| ZX_DEBUG_ASSERT(offset % kIntelTileByteSize == 0); |
| *offset_out = offset; |
| return true; |
| } |
| |
| bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const override { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| ZX_DEBUG_ASSERT(IsSupported(pixel_format_and_modifier)); |
| |
| uint32_t num_of_planes = FormatNumOfPlanes(image_format.pixel_format().value()); |
| |
| if (plane < num_of_planes) { |
| uint32_t width_in_tiles, height_in_tiles; |
| GetSizeInTiles(image_format, plane, &width_in_tiles, &height_in_tiles); |
| const auto& tiling_data = GetTilingData(GetTilingTypeForPixelFormat(PixelFormatAndModifier( |
| image_format.pixel_format().value(), image_format.pixel_format_modifier().value()))); |
| *row_bytes_out = width_in_tiles * tiling_data.bytes_per_row_per_tile; |
| return true; |
| } |
| |
| if (plane == kCcsPlane && FormatHasCcs(pixel_format_and_modifier)) { |
| uint32_t width_in_tiles, height_in_tiles; |
| // Since we only care about the width, just use the first plane |
| GetSizeInTiles(image_format, 0, &width_in_tiles, &height_in_tiles); |
| *row_bytes_out = |
| CcsWidthInTiles(width_in_tiles) * GetTilingData(TilingType::kY).bytes_per_row_per_tile; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) const override { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromConstraints(constraints); |
| ZX_DEBUG_ASSERT(IsSupported(pixel_format_and_modifier)); |
| |
| ZX_DEBUG_ASSERT(minimum_row_bytes_out); |
| // Caller must set pixel_format. |
| ZX_DEBUG_ASSERT(constraints.pixel_format().has_value()); |
| |
| if (constraints.size_alignment().has_value()) { |
| width = fbl::round_up(width, constraints.size_alignment()->width()); |
| } |
| |
| if ((constraints.min_size().has_value() && width < constraints.min_size()->width()) || |
| (constraints.max_size().has_value() && width > constraints.max_size()->width())) { |
| return false; |
| } |
| uint32_t constraints_min_bytes_per_row = |
| constraints.min_bytes_per_row().has_value() ? constraints.min_bytes_per_row().value() : 0; |
| uint32_t constraints_bytes_per_row_divisor = constraints.bytes_per_row_divisor().has_value() |
| ? constraints.bytes_per_row_divisor().value() |
| : 1; |
| |
| const auto& tiling_data = GetTilingData(GetTilingTypeForPixelFormat(pixel_format_and_modifier)); |
| |
| constraints_bytes_per_row_divisor = |
| fbl::round_up(constraints_bytes_per_row_divisor, tiling_data.bytes_per_row_per_tile); |
| |
| // This code should match the code in garnet/public/rust/fuchsia-framebuffer/src/sysmem.rs. |
| uint32_t non_padding_bytes_per_row; |
| if (!CheckMul(ImageFormatStrideBytesPerWidthPixel(pixel_format_and_modifier), width) |
| .AssignIfValid(&non_padding_bytes_per_row)) { |
| return false; |
| } |
| |
| *minimum_row_bytes_out = |
| fbl::round_up(std::max(non_padding_bytes_per_row, constraints_min_bytes_per_row), |
| constraints_bytes_per_row_divisor); |
| if (constraints.max_bytes_per_row().has_value() && |
| *minimum_row_bytes_out > constraints.max_bytes_per_row().value()) { |
| return false; |
| } |
| return true; |
| } |
| |
| private: |
| struct TilingData { |
| uint32_t tile_rows; |
| uint32_t bytes_per_row_per_tile; |
| }; |
| |
| // These are base Intel tilings, with no aux buffers. |
| enum class TilingType { kX, kY, kYf }; |
| |
| // See |
| // https://01.org/sites/default/files/documentation/intel-gfx-prm-osrc-skl-vol05-memory_views.pdf |
| static constexpr uint32_t kIntelTileByteSize = 4096; |
| static constexpr TilingData kTilingData[] = { |
| { |
| // kX |
| .tile_rows = 8, |
| .bytes_per_row_per_tile = 512, |
| }, |
| { |
| // kY |
| .tile_rows = 32, |
| .bytes_per_row_per_tile = 128, |
| }, |
| { |
| // kYf |
| .tile_rows = 32, |
| .bytes_per_row_per_tile = 128, |
| }, |
| }; |
| |
| // For simplicity CCS plane is always 3, leaving room for Y, U, and V planes if the format is I420 |
| // or similar. |
| static constexpr uint32_t kCcsPlane = 3; |
| |
| // See https://01.org/sites/default/files/documentation/intel-gfx-prm-osrc-kbl-vol12-display.pdf |
| // for a description of the color control surface. The CCS is always Y-tiled. A CCS cache-line |
| // (64 bytes, so 2 fit horizontally in a tile) represents 16 horizontal cache line pairs (so 16 |
| // tiles) and 16 pixels tall. |
| static constexpr uint32_t kCcsTileWidthRatio = 2 * 16; |
| static constexpr uint32_t kCcsTileHeightRatio = 16; |
| |
| static TilingType GetTilingTypeForPixelFormat(const PixelFormatAndModifier& pixel_format) { |
| auto modifier_without_ccs_bit = static_cast<fuchsia_images2::PixelFormatModifier>( |
| fidl::ToUnderlying(pixel_format.pixel_format_modifier) & |
| ~fuchsia_images2::kFormatModifierIntelCcsBit); |
| switch (modifier_without_ccs_bit) { |
| case fuchsia_images2::PixelFormatModifier::kIntelI915XTiled: |
| return TilingType::kX; |
| |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YTiled: |
| return TilingType::kY; |
| |
| case fuchsia_images2::PixelFormatModifier::kIntelI915YfTiled: |
| return TilingType::kYf; |
| default: |
| ZX_DEBUG_ASSERT(false); |
| return TilingType::kX; |
| } |
| } |
| |
| static const TilingData& GetTilingData(TilingType type) { |
| static_assert(static_cast<size_t>(TilingType::kYf) < std::size(kTilingData)); |
| ZX_DEBUG_ASSERT(static_cast<uint32_t>(type) < std::size(kTilingData)); |
| return kTilingData[static_cast<uint32_t>(type)]; |
| } |
| |
| // Gets the total size (in tiles) of image data for non-aux planes |
| static void GetSizeInTiles(const ImageFormat& image_format, uint32_t plane, uint32_t* width_out, |
| uint32_t* height_out) { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| const auto& tiling_data = GetTilingData(GetTilingTypeForPixelFormat(pixel_format_and_modifier)); |
| ZX_DEBUG_ASSERT(image_format.bytes_per_row().has_value()); |
| uint32_t bytes_per_row = image_format.bytes_per_row().value(); |
| |
| const auto& bytes_per_row_per_tile = tiling_data.bytes_per_row_per_tile; |
| const auto& tile_rows = tiling_data.tile_rows; |
| |
| switch (pixel_format_and_modifier.pixel_format) { |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: { |
| // Format only has one plane |
| ZX_DEBUG_ASSERT(plane == 0); |
| |
| *width_out = fbl::round_up(bytes_per_row, bytes_per_row_per_tile) / bytes_per_row_per_tile; |
| *height_out = fbl::round_up(image_format.size()->height(), tile_rows) / tile_rows; |
| } break; |
| // Since NV12 is a biplanar format we must handle the size for each plane separately. From |
| // https://github.com/intel/gmmlib/blob/e1f634c5d5a41ac48756b25697ea499605711747/Source/GmmLib/Texture/GmmTextureAlloc.cpp#L1192: |
| // "For Tiled Planar surfaces, the planes must be tile-boundary aligned." Meaning that each |
| // plane must be separately tiled aligned. |
| case PixelFormat::kNv12: |
| if (plane == 0) { |
| // Calculate the Y plane size (8 bpp) |
| *width_out = |
| fbl::round_up(bytes_per_row, bytes_per_row_per_tile) / bytes_per_row_per_tile; |
| *height_out = fbl::round_up(image_format.size()->height(), tile_rows) / tile_rows; |
| } else if (plane == 1) { |
| // Calculate the UV plane size (4 bpp) |
| // We effectively have 1/2 the height of our original image since we are subsampled at |
| // 4:2:0. Since width of the Y plane must match the width of the UV plane we divide the |
| // height of the Y plane by 2 to calculate the height of the UV plane (aligned on tile |
| // height boundaries). Ensure the height is aligned 2 before dividing. |
| uint32_t adjusted_height = fbl::round_up(image_format.size()->height(), 2u) / 2u; |
| |
| *width_out = |
| fbl::round_up(bytes_per_row, bytes_per_row_per_tile) / bytes_per_row_per_tile; |
| *height_out = fbl::round_up(adjusted_height, tile_rows) / tile_rows; |
| } else { |
| ZX_DEBUG_ASSERT(false); |
| } |
| break; |
| default: |
| ZX_DEBUG_ASSERT(false); |
| return; |
| } |
| } |
| |
| static bool FormatHasCcs(const PixelFormatAndModifier& pixel_format) { |
| return fidl::ToUnderlying(pixel_format.pixel_format_modifier) & |
| fuchsia_images2::kFormatModifierIntelCcsBit; |
| } |
| |
| // Does not include aux planes |
| static uint32_t FormatNumOfPlanes(const PixelFormat& pixel_format) { |
| switch (pixel_format) { |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 1u; |
| case PixelFormat::kNv12: |
| return 2u; |
| default: |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| } |
| } |
| |
| static uint64_t CcsWidthInTiles(uint32_t main_plane_width_in_tiles) { |
| return fbl::round_up(main_plane_width_in_tiles, kCcsTileWidthRatio) / kCcsTileWidthRatio; |
| } |
| |
| static uint64_t CcsSize(uint32_t width_in_tiles, uint32_t height_in_tiles) { |
| uint32_t height_in_ccs_tiles = |
| fbl::round_up(height_in_tiles, kCcsTileHeightRatio) / kCcsTileHeightRatio; |
| return CcsWidthInTiles(width_in_tiles) * height_in_ccs_tiles * kIntelTileByteSize; |
| } |
| }; |
| |
| class AfbcFormats : public ImageFormatSet { |
| public: |
| const char* Name() const override { return "AfbcFormats"; } |
| |
| static constexpr uint64_t kAfbcModifierMask = |
| fuchsia_images2::kFormatModifierArmTeBit | fuchsia_images2::kFormatModifierArmSplitBlockBit | |
| fuchsia_images2::kFormatModifierArmSparseBit | fuchsia_images2::kFormatModifierArmYuvBit | |
| fuchsia_images2::kFormatModifierArmBchBit | fuchsia_images2::kFormatModifierArmTiledHeaderBit; |
| bool IsSupported(const PixelFormatAndModifier& pixel_format) const override { |
| if (pixel_format.pixel_format != PixelFormatWire::kR8G8B8A8 && |
| pixel_format.pixel_format != PixelFormatWire::kR8G8B8X8 && |
| pixel_format.pixel_format != PixelFormatWire::kB8G8R8A8 && |
| pixel_format.pixel_format != PixelFormatWire::kB8G8R8X8) { |
| return false; |
| } |
| auto modifier_without_afbc = static_cast<fuchsia_images2::PixelFormatModifier>( |
| fidl::ToUnderlying(pixel_format.pixel_format_modifier) & ~kAfbcModifierMask); |
| switch (modifier_without_afbc) { |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc16X16: |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc32X8: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // Calculate the size of the Raw AFBC image without a transaction elimination buffer. |
| uint64_t NonTESize(const ImageFormat& image_format) const { |
| // See |
| // https://android.googlesource.com/device/linaro/hikey/+/android-o-preview-3/gralloc960/alloc_device.cpp |
| constexpr uint32_t kAfbcBodyAlignment = 1024u; |
| constexpr uint32_t kTiledAfbcBodyAlignment = 4096u; |
| |
| ZX_DEBUG_ASSERT(image_format.pixel_format().has_value()); |
| ZX_DEBUG_ASSERT(image_format.pixel_format_modifier().has_value()); |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier( |
| image_format.pixel_format().value(), image_format.pixel_format_modifier().value()))); |
| uint32_t block_width; |
| uint32_t block_height; |
| uint32_t width_alignment; |
| uint32_t height_alignment; |
| bool tiled_header = fidl::ToUnderlying(image_format.pixel_format_modifier().value()) & |
| fuchsia_images2::kFormatModifierArmTiledHeaderBit; |
| |
| auto modifier_without_afbc = static_cast<fuchsia_images2::PixelFormatModifier>( |
| fidl::ToUnderlying(image_format.pixel_format_modifier().value()) & ~kAfbcModifierMask); |
| switch (modifier_without_afbc) { |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc16X16: |
| block_width = 16; |
| block_height = 16; |
| if (!tiled_header) { |
| width_alignment = block_width; |
| height_alignment = block_height; |
| } else { |
| width_alignment = 128; |
| height_alignment = 128; |
| } |
| break; |
| |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc32X8: |
| block_width = 32; |
| block_height = 8; |
| if (!tiled_header) { |
| width_alignment = block_width; |
| height_alignment = block_height; |
| } else { |
| width_alignment = 256; |
| height_alignment = 64; |
| } |
| break; |
| default: |
| return 0; |
| } |
| |
| uint32_t body_alignment = tiled_header ? kTiledAfbcBodyAlignment : kAfbcBodyAlignment; |
| |
| ZX_DEBUG_ASSERT(image_format.pixel_format().has_value()); |
| ZX_DEBUG_ASSERT(image_format.pixel_format().value() == PixelFormatWire::kR8G8B8A8 || |
| image_format.pixel_format().value() == PixelFormatWire::kR8G8B8X8 || |
| image_format.pixel_format().value() == PixelFormatWire::kB8G8R8A8 || |
| image_format.pixel_format().value() == PixelFormatWire::kB8G8R8X8); |
| constexpr uint32_t kBytesPerPixel = 4; |
| constexpr uint32_t kBytesPerBlockHeader = 16; |
| |
| ZX_DEBUG_ASSERT(image_format.size().has_value()); |
| uint64_t block_count = |
| fbl::round_up(image_format.size()->width(), width_alignment) / block_width * |
| fbl::round_up(image_format.size()->height(), height_alignment) / block_height; |
| return block_count * block_width * block_height * kBytesPerPixel + |
| fbl::round_up(block_count * kBytesPerBlockHeader, body_alignment); |
| } |
| |
| uint64_t ImageFormatImageSize(const ImageFormat& image_format) const override { |
| uint64_t size = NonTESize(image_format); |
| if (fidl::ToUnderlying(image_format.pixel_format_modifier().value()) & |
| fuchsia_images2::kFormatModifierArmTeBit) { |
| size += arm_transaction_elimination_buffer_size(size, image_format.size()->width(), |
| image_format.size()->height()); |
| } |
| |
| return size; |
| } |
| |
| bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const override { |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier( |
| image_format.pixel_format().value(), image_format.pixel_format_modifier().value()))); |
| if (plane == 0) { |
| *offset_out = 0; |
| return true; |
| } |
| if (plane == kTransactionEliminationPlane) { |
| *offset_out = fbl::round_up(NonTESize(image_format), kTransactionEliminationAlignment); |
| return true; |
| } |
| return false; |
| } |
| bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const override { |
| if (plane == 0) { |
| *row_bytes_out = 0; |
| return true; |
| } |
| if (plane == kTransactionEliminationPlane) { |
| *row_bytes_out = arm_transaction_elimination_row_size(image_format.size()->width()); |
| return true; |
| } |
| return false; |
| } |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) const override { |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier( |
| constraints.pixel_format().value(), constraints.pixel_format_modifier().value()))); |
| |
| if (constraints.min_size().has_value() && width < constraints.min_size()->width()) { |
| return false; |
| } |
| if (constraints.max_size().has_value() && width > constraints.max_size()->width()) { |
| return false; |
| } |
| |
| uint32_t block_width; |
| uint32_t width_alignment; |
| bool tiled_header = fidl::ToUnderlying(constraints.pixel_format_modifier().value()) & |
| fuchsia_images2::kFormatModifierArmTiledHeaderBit; |
| |
| auto modifier_without_afbc = static_cast<fuchsia_images2::PixelFormatModifier>( |
| fidl::ToUnderlying(constraints.pixel_format_modifier().value()) & ~kAfbcModifierMask); |
| switch (modifier_without_afbc) { |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc16X16: |
| block_width = 16; |
| if (!tiled_header) { |
| width_alignment = block_width; |
| } else { |
| width_alignment = 128; |
| } |
| break; |
| |
| case fuchsia_images2::PixelFormatModifier::kArmAfbc32X8: |
| block_width = 32; |
| if (!tiled_header) { |
| width_alignment = block_width; |
| } else { |
| width_alignment = 256; |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| // Divide with round up instead of down: (width + (width_alignment - 1)) / width_alignment |
| auto width_in_blocks = CheckDiv(CheckAdd(width, CheckSub(width_alignment, 1)), width_alignment); |
| auto width_in_pixels = CheckMul(width_in_blocks, block_width); |
| constexpr uint32_t kBytesPerPixel = 4; |
| auto width_in_bytes = CheckMul(width_in_pixels, kBytesPerPixel); |
| if (!width_in_bytes.AssignIfValid(minimum_row_bytes_out)) { |
| return false; |
| } |
| |
| return true; |
| } |
| }; |
| |
| uint64_t linear_size(uint32_t surface_height, uint32_t bytes_per_row, PixelFormat type) { |
| switch (type) { |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| case PixelFormat::kR5G6B5: |
| case PixelFormat::kR3G3B2: |
| case PixelFormat::kR2G2B2X2: |
| case PixelFormat::kL8: |
| case PixelFormat::kR8: |
| case PixelFormat::kR8G8: |
| case PixelFormat::kA2B10G10R10: |
| case PixelFormat::kA2R10G10B10: |
| return surface_height * bytes_per_row; |
| case PixelFormat::kI420: |
| return surface_height * bytes_per_row * 3 / 2; |
| case PixelFormat::kM420: |
| return surface_height * bytes_per_row * 3 / 2; |
| case PixelFormat::kNv12: |
| return surface_height * bytes_per_row * 3 / 2; |
| case PixelFormat::kP010: |
| return surface_height * bytes_per_row * 3 / 2; |
| case PixelFormat::kYuy2: |
| return surface_height * bytes_per_row; |
| case PixelFormat::kYv12: |
| return surface_height * bytes_per_row * 3 / 2; |
| default: |
| return 0u; |
| } |
| } |
| |
| bool linear_minimum_row_bytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) { |
| ZX_DEBUG_ASSERT(minimum_row_bytes_out); |
| // Caller must set pixel_format. |
| ZX_DEBUG_ASSERT(constraints.pixel_format().has_value()); |
| |
| if ((constraints.min_size().has_value() && width < constraints.min_size()->width()) || |
| (constraints.max_size().has_value() && width > constraints.max_size()->width())) { |
| return false; |
| } |
| |
| // We don't enforce that width is already aligned up by the caller by the time of this call, but |
| // if the caller is a producer, the caller is nonetheless expected to conform to the |
| // size_alignment.width divisibility requirement for any fuchsia.sysmem.ImageFormat2.coded_width |
| // or fuchsia.images2.ImageFormat.size.width values the caller generates. |
| if (constraints.size_alignment().has_value()) { |
| width = fbl::round_up(width, constraints.size_alignment()->width()); |
| } |
| |
| uint32_t constraints_min_bytes_per_row = |
| constraints.min_bytes_per_row().has_value() ? constraints.min_bytes_per_row().value() : 0; |
| uint32_t constraints_bytes_per_row_divisor = constraints.bytes_per_row_divisor().has_value() |
| ? constraints.bytes_per_row_divisor().value() |
| : 1; |
| |
| // This code should match the code in garnet/public/rust/fuchsia-framebuffer/src/sysmem.rs. |
| *minimum_row_bytes_out = fbl::round_up( |
| std::max( |
| ImageFormatStrideBytesPerWidthPixel(PixelFormatAndModifierFromConstraints(constraints)) * |
| width, |
| constraints_min_bytes_per_row), |
| constraints_bytes_per_row_divisor); |
| if (constraints.max_bytes_per_row().has_value() && |
| *minimum_row_bytes_out > constraints.max_bytes_per_row().value()) { |
| return false; |
| } |
| return true; |
| } |
| |
| class LinearFormats : public ImageFormatSet { |
| public: |
| const char* Name() const override { return "LinearFormats"; } |
| |
| bool IsSupported(const PixelFormatAndModifier& pixel_format) const override { |
| if (pixel_format.pixel_format_modifier != fuchsia_images2::PixelFormatModifier::kLinear) { |
| return false; |
| } |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| return false; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| case PixelFormat::kI420: |
| case PixelFormat::kM420: |
| case PixelFormat::kNv12: |
| case PixelFormat::kP010: |
| case PixelFormat::kYuy2: |
| case PixelFormat::kYv12: |
| case PixelFormat::kR5G6B5: |
| case PixelFormat::kR3G3B2: |
| case PixelFormat::kR2G2B2X2: |
| case PixelFormat::kL8: |
| case PixelFormat::kR8: |
| case PixelFormat::kR8G8: |
| case PixelFormat::kA2B10G10R10: |
| case PixelFormat::kA2R10G10B10: |
| return true; |
| default: |
| return false; |
| } |
| return false; |
| } |
| |
| uint64_t ImageFormatImageSize(const ImageFormat& image_format) const override { |
| ZX_DEBUG_ASSERT(image_format.pixel_format().has_value()); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| ZX_DEBUG_ASSERT(IsSupported(pixel_format_and_modifier)); |
| ZX_DEBUG_ASSERT(image_format.size().has_value()); |
| ZX_DEBUG_ASSERT(image_format.bytes_per_row().has_value()); |
| uint32_t surface_height = image_format.size()->height(); |
| uint32_t bytes_per_row = |
| image_format.bytes_per_row().has_value() ? image_format.bytes_per_row().value() : 0; |
| return linear_size(surface_height, bytes_per_row, pixel_format_and_modifier.pixel_format); |
| } |
| |
| bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const override { |
| if (plane == 0) { |
| *offset_out = 0; |
| return true; |
| } |
| if (plane == 1) { |
| switch (image_format.pixel_format().value()) { |
| case PixelFormat::kP010: |
| case PixelFormat::kNv12: |
| case PixelFormat::kI420: |
| case PixelFormat::kYv12: { |
| *offset_out = |
| CheckMul(image_format.size().value().height(), image_format.bytes_per_row().value()) |
| .ValueOrDie(); |
| return true; |
| } |
| default: |
| return false; |
| } |
| } |
| if (plane == 2) { |
| switch (image_format.pixel_format().value()) { |
| case PixelFormat::kI420: |
| case PixelFormat::kYv12: { |
| auto luma_bytes = |
| CheckMul(image_format.size().value().height(), image_format.bytes_per_row().value()); |
| auto one_chroma_plane_bytes = CheckMul(CheckDiv(image_format.size().value().height(), 2), |
| CheckDiv(image_format.bytes_per_row().value(), 2)); |
| auto offset_just_past_luma_and_one_chroma = CheckAdd(luma_bytes, one_chroma_plane_bytes); |
| // 2nd chroma plane is just past luma and 1st chroma plane |
| *offset_out = offset_just_past_luma_and_one_chroma.ValueOrDie(); |
| return true; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const override { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| if (plane == 0) { |
| *row_bytes_out = image_format.bytes_per_row().value(); |
| return true; |
| } |
| if (plane == 1) { |
| switch (pixel_format_and_modifier.pixel_format) { |
| case PixelFormat::kNv12: |
| case PixelFormat::kP010: |
| *row_bytes_out = image_format.bytes_per_row().value(); |
| return true; |
| case PixelFormat::kI420: |
| case PixelFormat::kYv12: |
| *row_bytes_out = image_format.bytes_per_row().value() / 2; |
| return true; |
| default: |
| return false; |
| } |
| } else if (plane == 2) { |
| switch (pixel_format_and_modifier.pixel_format) { |
| case PixelFormat::kI420: |
| case PixelFormat::kYv12: |
| *row_bytes_out = image_format.bytes_per_row().value() / 2; |
| return true; |
| default: |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) const override { |
| return linear_minimum_row_bytes(constraints, width, minimum_row_bytes_out); |
| } |
| }; |
| |
| constexpr LinearFormats kLinearFormats; |
| |
| class GoldfishFormats : public ImageFormatSet { |
| public: |
| const char* Name() const override { return "GoldfishFormats"; } |
| |
| bool IsSupported(const PixelFormatAndModifier& pixel_format) const override { |
| switch (pixel_format.pixel_format_modifier) { |
| case fuchsia_images2::PixelFormatModifier::kGoogleGoldfishOptimal: |
| return true; |
| default: |
| return false; |
| } |
| } |
| uint64_t ImageFormatImageSize(const ImageFormat& image_format) const override { |
| ZX_DEBUG_ASSERT(image_format.pixel_format().has_value()); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| ZX_DEBUG_ASSERT(IsSupported(pixel_format_and_modifier)); |
| ZX_DEBUG_ASSERT(image_format.size().has_value()); |
| ZX_DEBUG_ASSERT(image_format.bytes_per_row().has_value()); |
| |
| uint32_t surface_height = image_format.size()->height(); |
| uint32_t bytes_per_row = image_format.bytes_per_row().value(); |
| return linear_size(surface_height, bytes_per_row, image_format.pixel_format().value()); |
| } |
| bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const override { |
| ZX_DEBUG_ASSERT(IsSupported(PixelFormatAndModifier( |
| image_format.pixel_format().value(), image_format.pixel_format_modifier().value()))); |
| if (plane == 0) { |
| *offset_out = 0; |
| return true; |
| } |
| return false; |
| } |
| bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const override { |
| if (plane == 0) { |
| *row_bytes_out = image_format.bytes_per_row().value(); |
| return true; |
| } |
| return false; |
| } |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) const override { |
| return false; |
| } |
| }; |
| |
| class ArmTELinearFormats : public ImageFormatSet { |
| public: |
| const char* Name() const override { return "ArmTELinearFormats"; } |
| |
| bool IsSupported(const PixelFormatAndModifier& pixel_format) const override { |
| if (pixel_format.pixel_format_modifier != fuchsia_images2::PixelFormatModifier::kArmLinearTe) |
| return false; |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| return false; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| case PixelFormat::kI420: |
| case PixelFormat::kM420: |
| case PixelFormat::kNv12: |
| case PixelFormat::kYuy2: |
| case PixelFormat::kYv12: |
| case PixelFormat::kR5G6B5: |
| case PixelFormat::kR3G3B2: |
| case PixelFormat::kR2G2B2X2: |
| case PixelFormat::kL8: |
| case PixelFormat::kR8: |
| case PixelFormat::kR8G8: |
| case PixelFormat::kA2B10G10R10: |
| case PixelFormat::kA2R10G10B10: |
| return true; |
| default: |
| return false; |
| } |
| return false; |
| } |
| |
| uint64_t ImageFormatImageSize(const fuchsia_images2::ImageFormat& image_format) const override { |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| ZX_DEBUG_ASSERT(IsSupported(pixel_format_and_modifier)); |
| ZX_DEBUG_ASSERT(image_format.size().has_value()); |
| ZX_DEBUG_ASSERT(image_format.bytes_per_row().has_value()); |
| uint32_t bytes_per_row = image_format.bytes_per_row().value(); |
| uint64_t size = linear_size(image_format.size()->height(), bytes_per_row, |
| pixel_format_and_modifier.pixel_format); |
| uint64_t crc_size = arm_transaction_elimination_buffer_size(size, image_format.size()->width(), |
| image_format.size()->height()); |
| return size + crc_size; |
| } |
| |
| bool ImageFormatPlaneByteOffset(const fuchsia_images2::ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) const override { |
| if (plane < kTransactionEliminationPlane) { |
| return kLinearFormats.ImageFormatPlaneByteOffset(image_format, plane, offset_out); |
| } |
| if (plane == kTransactionEliminationPlane) { |
| ZX_DEBUG_ASSERT(image_format.size().has_value()); |
| ZX_DEBUG_ASSERT(image_format.bytes_per_row().has_value()); |
| uint32_t bytes_per_row = image_format.bytes_per_row().value(); |
| uint64_t size = linear_size(image_format.size()->height(), bytes_per_row, |
| image_format.pixel_format().value()); |
| *offset_out = fbl::round_up(size, 64u); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool ImageFormatPlaneRowBytes(const fuchsia_images2::ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) const override { |
| if (plane < kTransactionEliminationPlane) { |
| return kLinearFormats.ImageFormatPlaneRowBytes(image_format, plane, row_bytes_out); |
| } |
| if (plane == kTransactionEliminationPlane) { |
| if (!image_format.size().has_value()) { |
| return false; |
| } |
| *row_bytes_out = arm_transaction_elimination_row_size(image_format.size()->width()); |
| return true; |
| } |
| return false; |
| } |
| |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) const override { |
| return linear_minimum_row_bytes(constraints, width, minimum_row_bytes_out); |
| } |
| }; |
| |
| constexpr IntelTiledFormats kIntelFormats; |
| constexpr AfbcFormats kAfbcFormats; |
| constexpr ArmTELinearFormats kArmTELinearFormats; |
| constexpr GoldfishFormats kGoldfishFormats; |
| |
| constexpr const ImageFormatSet* kImageFormats[] = { |
| &kLinearFormats, &kIntelFormats, &kAfbcFormats, &kArmTELinearFormats, &kGoldfishFormats, |
| }; |
| |
| } // namespace |
| |
| #if __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatIsPixelFormatEqual(const PixelFormatAndModifier& a, |
| const PixelFormatAndModifier& b) { |
| if (a.pixel_format != b.pixel_format) { |
| return false; |
| } |
| if (a.pixel_format_modifier != b.pixel_format_modifier) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool ImageFormatIsPixelFormatEqual(const fuchsia_sysmem::wire::PixelFormat& wire_a_v1, |
| const fuchsia_sysmem::wire::PixelFormat& wire_b_v1) { |
| auto a_v1 = fidl::ToNatural(wire_a_v1); |
| auto b_v1 = fidl::ToNatural(wire_b_v1); |
| auto a_v2 = sysmem::V2CopyFromV1PixelFormat(a_v1); |
| auto b_v2 = sysmem::V2CopyFromV1PixelFormat(b_v1); |
| return ImageFormatIsPixelFormatEqual(a_v2, b_v2); |
| } |
| |
| bool ImageFormatIsSupportedColorSpaceForPixelFormat(const fuchsia_images2::ColorSpace& color_space, |
| const PixelFormatAndModifier& pixel_format) { |
| if (color_space == ColorSpace::kPassthrough) { |
| return true; |
| } |
| // Ignore pixel format modifier - assume it has already been checked. |
| auto color_space_sampling_info_iter = kColorSpaceSamplingInfo.find(color_space); |
| if (color_space_sampling_info_iter == kColorSpaceSamplingInfo.end()) { |
| return false; |
| } |
| auto pixel_format_sampling_info_iter = kPixelFormatSamplingInfo.find(pixel_format.pixel_format); |
| if (pixel_format_sampling_info_iter == kPixelFormatSamplingInfo.end()) { |
| return false; |
| } |
| const SamplingInfo& color_space_sampling_info = color_space_sampling_info_iter->second; |
| const SamplingInfo& pixel_format_sampling_info = pixel_format_sampling_info_iter->second; |
| std::vector<ColorType> color_type_intersection; |
| std::set_intersection( |
| color_space_sampling_info.color_types.begin(), color_space_sampling_info.color_types.end(), |
| pixel_format_sampling_info.color_types.begin(), pixel_format_sampling_info.color_types.end(), |
| std::back_inserter(color_type_intersection)); |
| if (color_type_intersection.empty()) { |
| return false; |
| } |
| bool is_bits_per_sample_match_found = false; |
| for (uint32_t bits_per_sample : color_space_sampling_info.possible_bits_per_sample) { |
| auto pixel_format_bits_per_sample_iter = |
| pixel_format_sampling_info.possible_bits_per_sample.find(bits_per_sample); |
| if (pixel_format_bits_per_sample_iter != |
| pixel_format_sampling_info.possible_bits_per_sample.end()) { |
| is_bits_per_sample_match_found = true; |
| break; |
| } |
| } |
| return is_bits_per_sample_match_found; |
| } |
| |
| bool ImageFormatIsSupportedColorSpaceForPixelFormat( |
| const fuchsia_sysmem::wire::ColorSpace& wire_color_space_v1, |
| const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto color_space_v1 = fidl::ToNatural(wire_color_space_v1); |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto color_space_v2 = sysmem::V2CopyFromV1ColorSpace(color_space_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatIsSupportedColorSpaceForPixelFormat(color_space_v2, pixel_format_v2); |
| } |
| |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatIsSupported(const PixelFormatAndModifier& pixel_format) { |
| return std::any_of(std::begin(kImageFormats), std::end(kImageFormats), |
| [pixel_format](const ImageFormatSet* format_set) { |
| return format_set->IsSupported(pixel_format); |
| }); |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatIsSupported(const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatIsSupported(pixel_format_v2); |
| } |
| |
| uint32_t ImageFormatBitsPerPixel(const PixelFormatAndModifier& pixel_format) { |
| ZX_DEBUG_ASSERT(ImageFormatIsSupported(pixel_format)); |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| // impossible; checked previously. |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| return 4u * 8u; |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 4u * 8u; |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| return 3u * 8u; |
| case PixelFormat::kI420: |
| return 12u; |
| case PixelFormat::kM420: |
| return 12u; |
| case PixelFormat::kNv12: |
| return 12u; |
| case PixelFormat::kP010: |
| return 15u; |
| case PixelFormat::kYuy2: |
| return 2u * 8u; |
| case PixelFormat::kYv12: |
| return 12u; |
| case PixelFormat::kR5G6B5: |
| return 16u; |
| case PixelFormat::kR3G3B2: |
| case PixelFormat::kR2G2B2X2: |
| case PixelFormat::kL8: |
| case PixelFormat::kR8: |
| return 8u; |
| case PixelFormat::kR8G8: |
| return 16u; |
| case PixelFormat::kA2B10G10R10: |
| case PixelFormat::kA2R10G10B10: |
| return 2u + 3 * 10u; |
| default: |
| ZX_PANIC("Unknown Pixel Format: %u", sysmem::fidl_underlying_cast(pixel_format.pixel_format)); |
| } |
| } |
| |
| uint32_t ImageFormatBitsPerPixel(const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatBitsPerPixel(pixel_format_v2); |
| } |
| |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| uint32_t ImageFormatStrideBytesPerWidthPixel(const PixelFormatAndModifier& pixel_format) { |
| ZX_DEBUG_ASSERT(ImageFormatIsSupported(pixel_format)); |
| // This list should match the one in garnet/public/rust/fuchsia-framebuffer/src/sysmem.rs. |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| // impossible; checked previously. |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| return 4u; |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 4u; |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| return 3u; |
| case PixelFormat::kI420: |
| return 1u; |
| case PixelFormat::kM420: |
| return 1u; |
| case PixelFormat::kNv12: |
| return 1u; |
| case PixelFormat::kP010: |
| return 2u; |
| case PixelFormat::kYuy2: |
| return 2u; |
| case PixelFormat::kYv12: |
| return 1u; |
| case PixelFormat::kR5G6B5: |
| return 2u; |
| case PixelFormat::kR3G3B2: |
| return 1u; |
| case PixelFormat::kR2G2B2X2: |
| return 1u; |
| case PixelFormat::kL8: |
| return 1u; |
| case PixelFormat::kR8: |
| return 1u; |
| case PixelFormat::kR8G8: |
| return 2u; |
| case PixelFormat::kA2B10G10R10: |
| return 4u; |
| case PixelFormat::kA2R10G10B10: |
| return 4u; |
| default: |
| ZX_PANIC("Unknown Pixel Format: %u", sysmem::fidl_underlying_cast(pixel_format.pixel_format)); |
| } |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| |
| uint32_t ImageFormatStrideBytesPerWidthPixel( |
| const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatStrideBytesPerWidthPixel(pixel_format_v2); |
| } |
| |
| uint64_t ImageFormatImageSize(const fuchsia_images2::ImageFormat& image_format) { |
| ZX_DEBUG_ASSERT(image_format.pixel_format().has_value()); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| for (auto format_set : kImageFormats) { |
| if (format_set->IsSupported(pixel_format_and_modifier)) { |
| return format_set->ImageFormatImageSize(image_format); |
| } |
| } |
| ZX_PANIC("Unknown Pixel Format: %u", |
| sysmem::fidl_underlying_cast(image_format.pixel_format().value())); |
| return 0; |
| } |
| |
| uint64_t ImageFormatImageSize(const fuchsia_images2::wire::ImageFormat& image_format) { |
| return ImageFormatImageSize(fidl::ToNatural(image_format)); |
| } |
| |
| uint64_t ImageFormatImageSize(const fuchsia_sysmem::wire::ImageFormat2& wire_image_format_v1) { |
| auto image_format_v1 = fidl::ToNatural(wire_image_format_v1); |
| auto image_format_v2 = sysmem::V2CopyFromV1ImageFormat(image_format_v1).take_value(); |
| return ImageFormatImageSize(image_format_v2); |
| } |
| |
| uint32_t ImageFormatSurfaceWidthMinDivisor(const PixelFormatAndModifier& pixel_format) { |
| ZX_DEBUG_ASSERT(ImageFormatIsSupported(pixel_format)); |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| // impossible; checked previously. |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| return 1u; |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 1u; |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| return 1u; |
| case PixelFormat::kI420: |
| return 2u; |
| case PixelFormat::kM420: |
| return 2u; |
| case PixelFormat::kNv12: |
| return 2u; |
| case PixelFormat::kP010: |
| return 2u; |
| case PixelFormat::kYuy2: |
| return 2u; |
| case PixelFormat::kYv12: |
| return 2u; |
| case PixelFormat::kR5G6B5: |
| return 1u; |
| case PixelFormat::kR3G3B2: |
| return 1u; |
| case PixelFormat::kR2G2B2X2: |
| return 1u; |
| case PixelFormat::kL8: |
| return 1u; |
| case PixelFormat::kR8: |
| return 1u; |
| case PixelFormat::kR8G8: |
| return 1u; |
| case PixelFormat::kA2B10G10R10: |
| return 1u; |
| case PixelFormat::kA2R10G10B10: |
| return 1u; |
| default: |
| ZX_PANIC("Unknown Pixel Format: %u", sysmem::fidl_underlying_cast(pixel_format.pixel_format)); |
| } |
| } |
| |
| uint32_t ImageFormatCodedWidthMinDivisor( |
| const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatSurfaceWidthMinDivisor(pixel_format_v2); |
| } |
| |
| uint32_t ImageFormatSurfaceHeightMinDivisor(const PixelFormatAndModifier& pixel_format) { |
| ZX_DEBUG_ASSERT(ImageFormatIsSupported(pixel_format)); |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| // impossible; checked previously. |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| return 1u; |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 1u; |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| return 1u; |
| case PixelFormat::kI420: |
| return 2u; |
| case PixelFormat::kM420: |
| return 2u; |
| case PixelFormat::kNv12: |
| return 2u; |
| case PixelFormat::kP010: |
| return 2u; |
| case PixelFormat::kYuy2: |
| return 2u; |
| case PixelFormat::kYv12: |
| return 2u; |
| case PixelFormat::kR5G6B5: |
| return 1u; |
| case PixelFormat::kR3G3B2: |
| return 1u; |
| case PixelFormat::kR2G2B2X2: |
| return 1u; |
| case PixelFormat::kL8: |
| return 1u; |
| case PixelFormat::kR8: |
| return 1u; |
| case PixelFormat::kR8G8: |
| return 1u; |
| case PixelFormat::kA2B10G10R10: |
| return 1u; |
| case PixelFormat::kA2R10G10B10: |
| return 1u; |
| default: |
| ZX_PANIC("Unknown Pixel Format: %u", sysmem::fidl_underlying_cast(pixel_format.pixel_format)); |
| } |
| } |
| |
| uint32_t ImageFormatCodedHeightMinDivisor( |
| const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatSurfaceHeightMinDivisor(pixel_format_v2); |
| } |
| |
| uint32_t ImageFormatSampleAlignment(const PixelFormatAndModifier& pixel_format) { |
| ZX_DEBUG_ASSERT(ImageFormatIsSupported(pixel_format)); |
| switch (pixel_format.pixel_format) { |
| case PixelFormat::kInvalid: |
| case PixelFormat::kDoNotCare: |
| case PixelFormat::kMjpeg: |
| // impossible; checked previously. |
| ZX_DEBUG_ASSERT(false); |
| return 0u; |
| case PixelFormat::kR8G8B8A8: |
| case PixelFormat::kR8G8B8X8: |
| return 4u; |
| case PixelFormat::kB8G8R8A8: |
| case PixelFormat::kB8G8R8X8: |
| return 4u; |
| case PixelFormat::kB8G8R8: |
| case PixelFormat::kR8G8B8: |
| return 1u; |
| case PixelFormat::kI420: |
| return 2u; |
| case PixelFormat::kM420: |
| return 2u; |
| case PixelFormat::kNv12: |
| return 2u; |
| case PixelFormat::kP010: |
| return 4u; |
| case PixelFormat::kYuy2: |
| return 2u; |
| case PixelFormat::kYv12: |
| return 2u; |
| case PixelFormat::kR5G6B5: |
| return 2u; |
| case PixelFormat::kR3G3B2: |
| return 1u; |
| case PixelFormat::kR2G2B2X2: |
| return 1u; |
| case PixelFormat::kL8: |
| return 1u; |
| case PixelFormat::kR8: |
| return 1u; |
| case PixelFormat::kR8G8: |
| return 2u; |
| case PixelFormat::kA2B10G10R10: |
| return 4u; |
| case PixelFormat::kA2R10G10B10: |
| return 4u; |
| default: |
| ZX_PANIC("Unknown Pixel Format: %u", sysmem::fidl_underlying_cast(pixel_format.pixel_format)); |
| } |
| } |
| |
| uint32_t ImageFormatSampleAlignment(const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatSampleAlignment(pixel_format_v2); |
| } |
| |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatMinimumRowBytes(const fuchsia_sysmem2::ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t* minimum_row_bytes_out) { |
| ZX_ASSERT(width != 0); |
| ZX_DEBUG_ASSERT(minimum_row_bytes_out); |
| // Caller must set pixel_format. |
| ZX_DEBUG_ASSERT(constraints.pixel_format().has_value()); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromConstraints(constraints); |
| for (auto& format_set : kImageFormats) { |
| if (format_set->IsSupported(pixel_format_and_modifier)) { |
| bool result = |
| format_set->ImageFormatMinimumRowBytes(constraints, width, minimum_row_bytes_out); |
| ZX_ASSERT(!result || *minimum_row_bytes_out != 0); |
| return result; |
| } |
| } |
| return false; |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatMinimumRowBytes( |
| const fuchsia_sysmem2::wire::ImageFormatConstraints& wire_constraints, uint32_t width, |
| uint32_t* minimum_row_bytes_out) { |
| return ImageFormatMinimumRowBytes(fidl::ToNatural(wire_constraints), width, |
| minimum_row_bytes_out); |
| } |
| |
| bool ImageFormatMinimumRowBytes( |
| const fuchsia_sysmem::wire::ImageFormatConstraints& wire_image_format_constraints_v1, |
| uint32_t width, uint32_t* minimum_row_bytes_out) { |
| auto image_format_constraints_v1 = fidl::ToNatural(wire_image_format_constraints_v1); |
| auto image_format_constraints_v2 = |
| sysmem::V2CopyFromV1ImageFormatConstraints(image_format_constraints_v1).take_value(); |
| return ImageFormatMinimumRowBytes(image_format_constraints_v2, width, minimum_row_bytes_out); |
| } |
| |
| fpromise::result<fuchsia_images2::wire::PixelFormat> ImageFormatConvertZbiToSysmemPixelFormat_v2( |
| zbi_pixel_format_t zx_pixel_format) { |
| switch (zx_pixel_format) { |
| case ZBI_PIXEL_FORMAT_RGB_565: |
| return fpromise::ok(PixelFormat::kR5G6B5); |
| case ZBI_PIXEL_FORMAT_RGB_332: |
| return fpromise::ok(PixelFormat::kR3G3B2); |
| case ZBI_PIXEL_FORMAT_RGB_2220: |
| return fpromise::ok(PixelFormat::kR2G2B2X2); |
| case ZBI_PIXEL_FORMAT_ARGB_8888: |
| // Switching to using alpha. |
| case ZBI_PIXEL_FORMAT_RGB_X888: |
| // TODO(b/329142833): Change this to B8G8R8X8 when relevant participants support R8G8B8X8. The |
| // main benefit is ensuring that consumer participants reliably ignore the X/A byte, treating |
| // the RGB portion as fully opaque regardless of the contents of the X/A byte. Currently this |
| // happens to work out ok, but really we should ensure that participants agree re. X vs. A. |
| return fpromise::ok(PixelFormat::kB8G8R8A8); |
| case ZBI_PIXEL_FORMAT_MONO_8: |
| return fpromise::ok(PixelFormat::kL8); |
| case ZBI_PIXEL_FORMAT_I420: |
| return fpromise::ok(PixelFormat::kI420); |
| case ZBI_PIXEL_FORMAT_NV12: |
| return fpromise::ok(PixelFormat::kNv12); |
| case ZBI_PIXEL_FORMAT_RGB_888: |
| return fpromise::ok(PixelFormat::kB8G8R8); |
| case ZBI_PIXEL_FORMAT_ABGR_8888: |
| // Switching to using alpha. |
| case ZBI_PIXEL_FORMAT_BGR_888_X: |
| // TODO(b/329142833): Change this to R8G8B8X8 when relevant participants support R8G8B8X8. The |
| // main benefit is ensuring that consumer participants reliably ignore the X/A byte, treating |
| // the RGB portion as fully opaque regardless of the contents of the X/A byte. Currently this |
| // happens to work out ok, but really we should ensure that participants agree re. X vs. A. |
| return fpromise::ok(PixelFormat::kR8G8B8A8); |
| case ZBI_PIXEL_FORMAT_ARGB_2_10_10_10: |
| return fpromise::ok(PixelFormat::kA2R10G10B10); |
| case ZBI_PIXEL_FORMAT_ABGR_2_10_10_10: |
| return fpromise::ok(PixelFormat::kA2B10G10R10); |
| default: |
| return fpromise::error(); |
| } |
| } |
| |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| fpromise::result<ImageFormat> ImageConstraintsToFormat(const ImageFormatConstraints& constraints, |
| uint32_t width, uint32_t height) { |
| if ((constraints.min_size().has_value() && height < constraints.min_size()->height()) || |
| (constraints.max_size().has_value() && height > constraints.max_size()->height())) { |
| return fpromise::error(); |
| } |
| if ((constraints.min_size().has_value() && width < constraints.min_size()->width()) || |
| (constraints.max_size().has_value() && width > constraints.max_size()->width())) { |
| return fpromise::error(); |
| } |
| ImageFormat result; |
| uint32_t minimum_row_bytes; |
| if (!ImageFormatMinimumRowBytes(constraints, width, &minimum_row_bytes)) { |
| return fpromise::error(); |
| } |
| ZX_ASSERT(minimum_row_bytes != 0); |
| result.bytes_per_row() = minimum_row_bytes; |
| result.pixel_format() = constraints.pixel_format().value(); |
| result.pixel_format_modifier() = constraints.pixel_format_modifier().value(); |
| result.size() = {width, height}; |
| // We intentionally default to x, y == 0, 0 here, since that's by far the most common. The caller |
| // can fix this up if the caller needs non-zero x or non-zero y. |
| result.display_rect() = {0, 0, width, height}; |
| if (constraints.color_spaces().has_value() && !constraints.color_spaces()->empty()) { |
| result.color_space() = constraints.color_spaces()->at(0); |
| } |
| // result's pixel_aspect_ratio field remains un-set which is equivalent to 1,1 |
| return fpromise::ok(std::move(result)); |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| fpromise::result<ImageFormatWire> ImageConstraintsToFormat( |
| fidl::AnyArena& allocator, const ImageFormatConstraintsWire& wire_constraints, uint32_t width, |
| uint32_t height) { |
| auto constraints = fidl::ToNatural(wire_constraints); |
| auto result = ImageConstraintsToFormat(constraints, width, height); |
| if (!result.is_ok()) { |
| return fpromise::error(); |
| } |
| return fpromise::ok(fidl::ToWire(allocator, result.take_value())); |
| } |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| fpromise::result<fuchsia_sysmem::wire::ImageFormat2> ImageConstraintsToFormat( |
| const fuchsia_sysmem::wire::ImageFormatConstraints& wire_image_format_constraints_v1, |
| uint32_t width, uint32_t height) { |
| auto image_format_constraints_v1 = fidl::ToNatural(wire_image_format_constraints_v1); |
| auto image_format_constraints_v2_result = |
| sysmem::V2CopyFromV1ImageFormatConstraints(image_format_constraints_v1); |
| if (!image_format_constraints_v2_result.is_ok()) { |
| return fpromise::error(); |
| } |
| auto image_format_constraints_v2 = image_format_constraints_v2_result.take_value(); |
| auto v2_out_result = ImageConstraintsToFormat(image_format_constraints_v2, width, height); |
| if (!v2_out_result.is_ok()) { |
| return fpromise::error(); |
| } |
| auto v2_out = v2_out_result.take_value(); |
| auto v1_out_result = sysmem::V1CopyFromV2ImageFormat(v2_out); |
| if (!v1_out_result) { |
| return fpromise::error(); |
| } |
| // This arena isn't relied upon by the returned value, because kMaxOutOfLine == 0. |
| fidl::Arena arena; |
| ZX_DEBUG_ASSERT(fidl::TypeTraits<fuchsia_sysmem::wire::ImageFormat2>::kMaxOutOfLine == 0); |
| auto wire_v1 = fidl::ToWire(arena, v1_out_result.take_value()); |
| return fpromise::ok(wire_v1); |
| } |
| |
| bool ImageFormatPlaneByteOffset(const ImageFormat& image_format, uint32_t plane, |
| uint64_t* offset_out) { |
| ZX_DEBUG_ASSERT(offset_out); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| for (auto& format_set : kImageFormats) { |
| if (format_set->IsSupported(pixel_format_and_modifier)) { |
| return format_set->ImageFormatPlaneByteOffset(image_format, plane, offset_out); |
| } |
| } |
| return false; |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| bool ImageFormatPlaneByteOffset(const ImageFormatWire& image_format, uint32_t plane, |
| uint64_t* offset_out) { |
| return ImageFormatPlaneByteOffset(fidl::ToNatural(image_format), plane, offset_out); |
| } |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatPlaneByteOffset(const fuchsia_sysmem::wire::ImageFormat2& wire_image_format_v1, |
| uint32_t plane, uint64_t* offset_out) { |
| ZX_DEBUG_ASSERT(offset_out); |
| auto image_format_v1 = fidl::ToNatural(wire_image_format_v1); |
| auto image_format_v2_result = sysmem::V2CopyFromV1ImageFormat(image_format_v1); |
| if (!image_format_v2_result.is_ok()) { |
| return false; |
| } |
| auto image_format_v2 = image_format_v2_result.take_value(); |
| return ImageFormatPlaneByteOffset(image_format_v2, plane, offset_out); |
| } |
| |
| bool ImageFormatPlaneRowBytes(const ImageFormat& image_format, uint32_t plane, |
| uint32_t* row_bytes_out) { |
| ZX_DEBUG_ASSERT(row_bytes_out); |
| auto pixel_format_and_modifier = PixelFormatAndModifierFromImageFormat(image_format); |
| for (auto& format_set : kImageFormats) { |
| if (format_set->IsSupported(pixel_format_and_modifier)) { |
| return format_set->ImageFormatPlaneRowBytes(image_format, plane, row_bytes_out); |
| } |
| } |
| return false; |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| bool ImageFormatPlaneRowBytes(const ImageFormatWire& wire_image_format, uint32_t plane, |
| uint32_t* row_bytes_out) { |
| return ImageFormatPlaneRowBytes(fidl::ToNatural(wire_image_format), plane, row_bytes_out); |
| } |
| #endif // __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatPlaneRowBytes(const fuchsia_sysmem::wire::ImageFormat2& wire_image_format_v1, |
| uint32_t plane, uint32_t* row_bytes_out) { |
| ZX_DEBUG_ASSERT(row_bytes_out); |
| auto image_format_v1 = fidl::ToNatural(wire_image_format_v1); |
| auto image_format_v2_result = sysmem::V2CopyFromV1ImageFormat(image_format_v1); |
| if (!image_format_v2_result.is_ok()) { |
| return false; |
| } |
| auto image_format_v2 = image_format_v2_result.take_value(); |
| return ImageFormatPlaneRowBytes(image_format_v2, plane, row_bytes_out); |
| } |
| |
| #if __Fuchsia_API_level__ >= 19 |
| |
| bool ImageFormatCompatibleWithProtectedMemory(const PixelFormatAndModifier& pixel_format) { |
| // AKA kFormatModifierLinear |
| if (pixel_format.pixel_format_modifier == fuchsia_images2::PixelFormatModifier::kLinear) { |
| return true; |
| } |
| constexpr uint64_t kArmLinearFormat = 0x0800000000000000ul; |
| switch (fidl::ToUnderlying(pixel_format.pixel_format_modifier) & |
| ~AfbcFormats::kAfbcModifierMask) { |
| case kArmLinearFormat: |
| case fidl::ToUnderlying(fuchsia_images2::PixelFormatModifier::kArmAfbc16X16): |
| case fidl::ToUnderlying(fuchsia_images2::PixelFormatModifier::kArmAfbc32X8): |
| // TE formats occasionally need CPU writes to the TE buffer. |
| return !(fidl::ToUnderlying(pixel_format.pixel_format_modifier) & |
| fuchsia_images2::kFormatModifierArmTeBit); |
| |
| default: |
| return true; |
| } |
| } |
| |
| bool ImageFormatCompatibleWithProtectedMemory( |
| const fuchsia_sysmem::wire::PixelFormat& wire_pixel_format_v1) { |
| auto pixel_format_v1 = fidl::ToNatural(wire_pixel_format_v1); |
| auto pixel_format_v2 = sysmem::V2CopyFromV1PixelFormat(pixel_format_v1); |
| return ImageFormatCompatibleWithProtectedMemory(pixel_format_v2); |
| } |
| |
| #endif // __Fuchsia_API_level__ >= 19 |
