src/camera/lib/image_utils/image_format_rgba.cc

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

#include "src/camera/lib/image_utils/image_format_rgba.h"

namespace camera {

constexpr uint8_t kOneByteMask = 0xff;

uint8_t BitWidthToByteMask(uint8_t bit_width) {
  ZX_DEBUG_ASSERT(bit_width <= 8);
  return static_cast<uint8_t>(0xff << (8 - bit_width));
}

Rgba Min(const Rgba &a, const Rgba &b) {
  return {std::min(a.r, b.r), std::min(a.g, b.g), std::min(a.b, b.b), std::min(a.a, b.a)};
}

Rgba BitWidthToByteMask(Rgba bit_width) {
  return {BitWidthToByteMask(bit_width.r), BitWidthToByteMask(bit_width.g),
          BitWidthToByteMask(bit_width.b), BitWidthToByteMask(bit_width.a)};
}
// RgbaPixelFormatInfo stores all the information needed to encode an RGBA pixel.
struct RgbaPixelFormatInfo {
  // bit_width is the width in bits of each channel.
  // bit offset is the offset of the start of the channel from the start of the pixel.
  Rgba bit_width, bit_offset;
  uint8_t bytes_per_pixel;
  char name[9];  // used for debug messages

  uint32_t Pack(Rgba in) const {
    // For each color, first shift it over to get just the most significant (bit_width) pixels,
    // then shift it to the correct alignment
    return static_cast<uint32_t>(in.r >> (8 - bit_width.r)) << bit_offset.r |
           static_cast<uint32_t>(in.g >> (8 - bit_width.g)) << bit_offset.g |
           static_cast<uint32_t>(in.b >> (8 - bit_width.b)) << bit_offset.b |
           static_cast<uint32_t>(in.a >> (8 - bit_width.a)) << bit_offset.a;
  }

  Rgba Unpack(uint32_t packed) const {
    return {
        .r = static_cast<uint8_t>(((packed >> bit_offset.r) << (8 - bit_width.r)) & kOneByteMask),
        .g = static_cast<uint8_t>(((packed >> bit_offset.g) << (8 - bit_width.g)) & kOneByteMask),
        .b = static_cast<uint8_t>(((packed >> bit_offset.b) << (8 - bit_width.b)) & kOneByteMask),
        .a = static_cast<uint8_t>(((packed >> bit_offset.a) << (8 - bit_width.a)) & kOneByteMask)};
  }
};

const std::map<fuchsia::sysmem::PixelFormatType, RgbaPixelFormatInfo> kPixelFormatInfo = {
    {fuchsia::sysmem::PixelFormatType::R8G8B8A8, {{8, 8, 8, 8}, {24, 16, 8, 0}, 4u, "R8G8B8A8"}},
    {fuchsia::sysmem::PixelFormatType::BGRA32, {{8, 8, 8, 8}, {8, 16, 24, 0}, 4u, "BGRA32\0"}},
    {fuchsia::sysmem::PixelFormatType::BGR24, {{8, 8, 8, 0}, {16, 8, 0, 0}, 3u, "BGR24\0"}},
    {fuchsia::sysmem::PixelFormatType::RGB565, {{5, 6, 5, 0}, {11, 5, 0, 0}, 2u, "RGB565\0"}},
    {fuchsia::sysmem::PixelFormatType::RGB332, {{3, 3, 2, 0}, {5, 2, 0, 0}, 1u, "RGB332\0"}},
    {fuchsia::sysmem::PixelFormatType::RGB2220, {{2, 2, 2, 0}, {6, 4, 2, 0}, 1u, "RGB2220\0"}},
};

RgbaPixelFormatInfo GetPixelInfo(const fuchsia::sysmem::PixelFormatType &format) {
  ZX_ASSERT(kPixelFormatInfo.count(format));
  return kPixelFormatInfo.find(format)->second;
}

Rgba RgbaUnpack(fuchsia::sysmem::PixelFormatType format, uint32_t packed) {
  return GetPixelInfo(format).Unpack(packed);
}

uint32_t RgbaPack(fuchsia::sysmem::PixelFormatType format, Rgba in) {
  return GetPixelInfo(format).Pack(in);
}

bool ComparePacked(fuchsia::sysmem::PixelFormatType format1, uint32_t value1,
                   fuchsia::sysmem::PixelFormatType format2, uint32_t value2) {
  auto pixel_info1 = GetPixelInfo(format1);
  Rgba unpacked1 = pixel_info1.Unpack(value1);
  auto pixel_info2 = GetPixelInfo(format2);
  Rgba unpacked2 = pixel_info2.Unpack(value2);
  // Since the formats may have different bit widths, mask the unpacked values
  // so we only compare bits that both values share.
  Rgba min_mask = BitWidthToByteMask(Min(pixel_info1.bit_width, pixel_info2.bit_width));
  return (unpacked1 & min_mask) == (unpacked2 & min_mask);
}

std::string ToString(const fuchsia::sysmem::PixelFormatType &type) {
  return GetPixelInfo(type).name;
}

Rgba BitWidth(const fuchsia::sysmem::PixelFormatType &type) { return GetPixelInfo(type).bit_width; }

uint32_t BytesPerPixel(const fuchsia::sysmem::PixelFormatType &type) {
  return GetPixelInfo(type).bytes_per_pixel;
}
bool IsSupportedPixelFormat(const fuchsia::sysmem::PixelFormatType &type) {
  return kPixelFormatInfo.count(type);
}

std::vector<fuchsia::sysmem::PixelFormatType> GetSupportedFormats() {
  std::vector<fuchsia::sysmem::PixelFormatType> ret;
  ret.reserve(kPixelFormatInfo.size());
  for (auto &entry : kPixelFormatInfo) {
    ret.push_back(entry.first);
  }
  return ret;
}

fuchsia_sysmem::wire::PixelFormat ConvertPixelFormatToWire(
    const fuchsia::sysmem::PixelFormat &format) {
  return {
      .type = static_cast<const fuchsia_sysmem::wire::PixelFormatType>(format.type),
      .has_format_modifier = format.has_format_modifier,
      .format_modifier =
          {
              .value = format.format_modifier.value,
          },
  };
}

fuchsia_sysmem::wire::ImageFormat2 ConvertImageFormatToWire(
    const fuchsia::sysmem::ImageFormat_2 &format) {
  return {
      .pixel_format = ConvertPixelFormatToWire(format.pixel_format),
      .coded_width = format.coded_width,
      .coded_height = format.coded_height,
      .bytes_per_row = format.bytes_per_row,
      .display_width = format.display_width,
      .display_height = format.display_height,
      .layers = format.layers,
      .color_space =
          {
              .type = static_cast<fuchsia_sysmem::wire::ColorSpaceType>(format.color_space.type),
          },
      .has_pixel_aspect_ratio = format.has_pixel_aspect_ratio,
      .pixel_aspect_ratio_width = format.pixel_aspect_ratio_width,
      .pixel_aspect_ratio_height = format.pixel_aspect_ratio_height,
  };
}

}  // namespace camera