pixel_codec.hpp

Go to the documentation of this file.

#pragma once
 
#include "epaper/color/color.hpp" // For RGB struct? If RGB is used.
#include "epaper/core/types.hpp"
#include "epaper/drivers/driver.hpp"
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
 
namespace epaper {
 
// ============================================================================
// Constants for bit manipulation
// ============================================================================
 
namespace pixel_constants {
 
constexpr std::uint8_t BW_PIXELS_PER_BYTE = 8;
constexpr std::uint8_t BW_MSB_MASK = 0x80;
 
constexpr std::uint8_t GRAY_PIXELS_PER_BYTE = 4;
constexpr std::uint8_t GRAY_BITS_PER_PIXEL = 2;
constexpr std::uint8_t GRAY_PIXEL_MASK = 0xC0;
 
constexpr std::uint8_t SPECTRA6_BITS_PER_PIXEL = 3;
constexpr std::uint8_t SPECTRA6_COLOR_MASK = 0x07;
 
constexpr std::uint8_t GRAY_THRESHOLD_WHITE = 192;
constexpr std::uint8_t GRAY_THRESHOLD_LIGHT = 128;
constexpr std::uint8_t GRAY_THRESHOLD_DARK = 64;
 
} // namespace pixel_constants
 
// ============================================================================
// Spectra6 Color Mapping
// ============================================================================
 
constexpr std::array<Color, 8> SPECTRA6_VALUE_TO_COLOR = {{
    Color::Black,  // 0
    Color::White,  // 1
    Color::Red,    // 2
    Color::Yellow, // 3
    Color::Blue,   // 4
    Color::Green,  // 5
    Color::Black,  // 6 (undefined, fallback)
    Color::Black   // 7 (undefined, fallback)
}};
 
[[nodiscard]] constexpr auto spectra6_color_to_value(Color color) noexcept -> std::uint8_t {
  switch (color) {
  case Color::Black:
    return 0;
  case Color::White:
    return 1;
  case Color::Red:
    return 2;
  case Color::Yellow:
    return 3;
  case Color::Blue:
    return 4;
  case Color::Green:
    return 5;
  default:
    return 0; // Fallback to black
  }
}
 
[[nodiscard]] constexpr auto spectra6_value_to_color(std::uint8_t value) noexcept -> Color {
  return SPECTRA6_VALUE_TO_COLOR.at(value & pixel_constants::SPECTRA6_COLOR_MASK);
}
 
// ============================================================================
// Color <-> RGB Conversion
// ============================================================================
 
[[nodiscard]] constexpr auto color_to_rgb(Color color) noexcept -> RGB {
  switch (color) {
  case Color::White:
    return {255, 255, 255};
  case Color::Gray1:
    return {170, 170, 170};
  case Color::Gray2:
    return {85, 85, 85};
  case Color::Black:
    return {0, 0, 0};
  case Color::Red:
    return {255, 0, 0};
  case Color::Yellow:
    return {255, 255, 0};
  case Color::Blue:
    return {0, 0, 255};
  case Color::Green:
    return {0, 255, 0};
  }
  return {0, 0, 0}; // Fallback to black
}
 
[[nodiscard]] constexpr auto rgb_to_grayscale(std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept -> std::uint8_t {
  // Use integer arithmetic to avoid floating point
  // Formula: (299*R + 587*G + 114*B) / 1000
  return static_cast<std::uint8_t>((299U * r + 587U * g + 114U * b) / 1000U);
}
 
[[nodiscard]] constexpr auto rgb_to_color_bw(std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept -> Color {
  const auto gray = rgb_to_grayscale(r, g, b);
  return gray >= pixel_constants::GRAY_THRESHOLD_LIGHT ? Color::White : Color::Black;
}
 
[[nodiscard]] constexpr auto rgb_to_color_grayscale4(std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept -> Color {
  const auto gray = rgb_to_grayscale(r, g, b);
  if (gray >= pixel_constants::GRAY_THRESHOLD_WHITE) {
    return Color::White;
  }
  if (gray >= pixel_constants::GRAY_THRESHOLD_LIGHT) {
    return Color::Gray1;
  }
  if (gray >= pixel_constants::GRAY_THRESHOLD_DARK) {
    return Color::Gray2;
  }
  return Color::Black;
}
 
[[nodiscard]] constexpr auto rgb_to_color(DisplayMode mode, std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept
    -> Color {
  switch (mode) {
  case DisplayMode::BlackWhite:
    return rgb_to_color_bw(r, g, b);
  case DisplayMode::Grayscale4:
    return rgb_to_color_grayscale4(r, g, b);
  default:
    // For color modes, use grayscale conversion as fallback
    return rgb_to_color_grayscale4(r, g, b);
  }
}
 
// ============================================================================
// Framebuffer Position Calculations
// ============================================================================
 
[[nodiscard]] constexpr auto calculate_bw_position(std::size_t width, std::size_t x, std::size_t y) noexcept
    -> std::pair<std::size_t, std::uint8_t> {
  const auto width_bytes = (width + 7) / 8;
  const auto byte_index = (x / 8) + (y * width_bytes);
  const auto bit_offset = static_cast<std::uint8_t>(x % 8);
  const auto bit_mask = static_cast<std::uint8_t>(pixel_constants::BW_MSB_MASK >> bit_offset);
  return {byte_index, bit_mask};
}
 
[[nodiscard]] constexpr auto calculate_gray_position(std::size_t width, std::size_t x, std::size_t y) noexcept
    -> std::pair<std::size_t, std::uint8_t> {
  const auto width_bytes = (width + 3) / 4;
  const auto byte_index = (x / 4) + (y * width_bytes);
  const auto pixel_offset = static_cast<std::uint8_t>((x % 4) * 2);
  return {byte_index, pixel_offset};
}
 
[[nodiscard]] constexpr auto calculate_spectra6_position(std::size_t width, std::size_t x, std::size_t y) noexcept
    -> std::pair<std::size_t, std::size_t> {
  const std::size_t pixel_index = (y * width) + x;
  const std::size_t byte_index = (pixel_index * 3) / 8;
  const std::size_t bit_offset = (pixel_index * 3) % 8;
  return {byte_index, bit_offset};
}
 
// ============================================================================
// Pixel Getters (Read from buffer)
// ============================================================================
 
[[nodiscard]] inline auto get_pixel_bw(std::span<const std::byte> buffer, std::size_t width, std::size_t x,
                                       std::size_t y) noexcept -> Color {
  const auto [byte_index, bit_mask] = calculate_bw_position(width, x, y);
  if (byte_index >= buffer.size()) {
    return Color::White;
  }
  const auto byte_val = static_cast<std::uint8_t>(buffer[byte_index]);
  return ((byte_val & bit_mask) != 0) ? Color::White : Color::Black;
}
 
[[nodiscard]] inline auto get_pixel_grayscale4(std::span<const std::byte> buffer, std::size_t width, std::size_t x,
                                               std::size_t y) noexcept -> Color {
  const auto [byte_index, pixel_shift] = calculate_gray_position(width, x, y);
  if (byte_index >= buffer.size()) {
    return Color::White;
  }
  const auto byte_val = static_cast<std::uint8_t>(buffer[byte_index]);
  const auto gray_level = (byte_val >> (6 - pixel_shift)) & 0x03;
 
  switch (gray_level) {
  case 0:
    return Color::Black;
  case 1:
    return Color::Gray2;
  case 2:
    return Color::Gray1;
  case 3:
    return Color::White;
  default:
    return Color::White;
  }
}
 
[[nodiscard]] inline auto get_pixel_bwr_bwy(std::span<const std::byte> buffer, std::size_t width, std::size_t height,
                                            std::size_t x, std::size_t y, bool is_bwr) noexcept -> Color {
  const std::size_t plane_size = (width * height + 7) / 8;
  const auto [byte_index, bit_mask] = calculate_bw_position(width, x, y);
 
  if (byte_index >= buffer.size()) {
    return Color::White;
  }
 
  // Check B/W plane (first plane)
  const auto bw_byte = static_cast<std::uint8_t>(buffer[byte_index]);
  const bool is_white = (bw_byte & bit_mask) != 0;
 
  // Check color plane (second plane) if available
  if (byte_index + plane_size < buffer.size()) {
    const auto color_byte = static_cast<std::uint8_t>(buffer[byte_index + plane_size]);
 
    // In e-paper color planes, 0 usually means "Color" (Ink) and 1 means "No Color" (Transparent/White)
    // This is active-low logic.
    const bool is_color = (color_byte & bit_mask) == 0;
 
    if (is_color) {
      return is_bwr ? Color::Red : Color::Yellow;
    }
  }
 
  return is_white ? Color::White : Color::Black;
}
 
[[nodiscard]] inline auto get_pixel_spectra6(std::span<const std::byte> buffer, std::size_t width, std::size_t x,
                                             std::size_t y) noexcept -> Color {
  const auto [byte_index, bit_offset] = calculate_spectra6_position(width, x, y);
 
  if (byte_index >= buffer.size()) {
    return Color::White;
  }
 
  std::uint8_t color_value = 0;
 
  if (bit_offset <= 5) {
    // 3-bit value fits within single byte
    const auto shift = static_cast<std::uint8_t>(5 - bit_offset);
    const auto byte_val = static_cast<std::uint8_t>(buffer[byte_index]);
    color_value = (byte_val >> shift) & pixel_constants::SPECTRA6_COLOR_MASK;
  } else {
    // 3-bit value spans two bytes
    const auto high_bits = static_cast<std::uint8_t>(8 - bit_offset);
    const auto low_bits = static_cast<std::uint8_t>(3 - high_bits);
 
    const auto high_byte = static_cast<std::uint8_t>(buffer[byte_index]);
    color_value = static_cast<std::uint8_t>((high_byte & ((1U << high_bits) - 1)) << low_bits);
 
    if (byte_index + 1 < buffer.size()) {
      const auto low_byte = static_cast<std::uint8_t>(buffer[byte_index + 1]);
      color_value = static_cast<std::uint8_t>(color_value | ((low_byte >> (8 - low_bits)) & ((1U << low_bits) - 1)));
    }
  }
 
  return spectra6_value_to_color(color_value);
}
 
[[nodiscard]] inline auto get_pixel_from_buffer(DisplayMode mode, std::span<const std::byte> buffer, std::size_t width,
                                                std::size_t height, std::size_t x, std::size_t y) noexcept -> Color {
  switch (mode) {
  case DisplayMode::BlackWhite:
    return get_pixel_bw(buffer, width, x, y);
  case DisplayMode::Grayscale4:
    return get_pixel_grayscale4(buffer, width, x, y);
  case DisplayMode::BWR:
    return get_pixel_bwr_bwy(buffer, width, height, x, y, true);
  case DisplayMode::BWY:
    return get_pixel_bwr_bwy(buffer, width, height, x, y, false);
  case DisplayMode::Spectra6:
    return get_pixel_spectra6(buffer, width, x, y);
  }
  return Color::White;
}
 
// ============================================================================
// Pixel Setters (Write to buffer)
// ============================================================================
 
inline auto set_pixel_bw(std::span<std::byte> buffer, std::size_t width, std::size_t x, std::size_t y,
                         Color color) noexcept -> void {
  const auto [byte_index, bit_mask] = calculate_bw_position(width, x, y);
  if (byte_index >= buffer.size()) {
    return;
  }
 
  auto &byte_val = buffer[byte_index];
  if (color == Color::White) {
    byte_val = static_cast<std::byte>(static_cast<std::uint8_t>(byte_val) | bit_mask);
  } else {
    byte_val = static_cast<std::byte>(static_cast<std::uint8_t>(byte_val) & ~bit_mask);
  }
}
 
inline auto set_pixel_grayscale4(std::span<std::byte> buffer, std::size_t width, std::size_t x, std::size_t y,
                                 Color color) noexcept -> void {
  const auto [byte_index, pixel_shift] = calculate_gray_position(width, x, y);
  if (byte_index >= buffer.size()) {
    return;
  }
 
  auto &byte_val = buffer[byte_index];
  const auto mask = static_cast<std::uint8_t>(pixel_constants::GRAY_PIXEL_MASK >> pixel_shift);
  const std::uint8_t color_bits = (static_cast<std::uint8_t>(color) & pixel_constants::GRAY_PIXEL_MASK) >> pixel_shift;
 
  // Clear the 2 bits and set new color
  byte_val = static_cast<std::byte>((static_cast<std::uint8_t>(byte_val) & ~mask) | (color_bits & mask));
}
 
inline auto set_pixel_bwr_bwy(std::span<std::byte> buffer, std::size_t width, std::size_t height, std::size_t x,
                              std::size_t y, Color color, bool is_bwr) noexcept -> void {
  const std::size_t plane_size = (width * height + 7) / 8;
  const auto [byte_index, bit_mask] = calculate_bw_position(width, x, y);
 
  if (byte_index >= buffer.size() || byte_index + plane_size >= buffer.size()) {
    return;
  }
 
  // Determine plane values based on color
  bool is_bw_white = false;
  bool is_color = false;
 
  const auto target_color = is_bwr ? Color::Red : Color::Yellow;
  if (color == Color::White) {
    is_bw_white = true;
    is_color = false;
  } else if (color == target_color) {
    is_bw_white = false;
    is_color = true;
  } else {
    // Black or other colors -> black
    is_bw_white = false;
    is_color = false;
  }
 
  // Set B/W plane (first plane)
  auto &bw_byte = buffer[byte_index];
  if (is_bw_white) {
    bw_byte = static_cast<std::byte>(static_cast<std::uint8_t>(bw_byte) | bit_mask);
  } else {
    bw_byte = static_cast<std::byte>(static_cast<std::uint8_t>(bw_byte) & ~bit_mask);
  }
 
  // Set color plane (second plane)
  auto &color_byte = buffer[byte_index + plane_size];
  if (is_color) {
    color_byte = static_cast<std::byte>(static_cast<std::uint8_t>(color_byte) | bit_mask);
  } else {
    color_byte = static_cast<std::byte>(static_cast<std::uint8_t>(color_byte) & ~bit_mask);
  }
}
 
inline auto set_pixel_spectra6(std::span<std::byte> buffer, std::size_t width, std::size_t x, std::size_t y,
                               Color color) noexcept -> void {
  const auto [byte_index, bit_offset] = calculate_spectra6_position(width, x, y);
 
  if (byte_index >= buffer.size()) {
    return;
  }
 
  const std::uint8_t color_value = spectra6_color_to_value(color);
 
  if (bit_offset <= 5) {
    // 3-bit value fits within single byte
    const auto shift = static_cast<std::uint8_t>(5 - bit_offset);
    const auto mask = static_cast<std::uint8_t>(pixel_constants::SPECTRA6_COLOR_MASK << shift);
    auto &byte_val = buffer[byte_index];
    byte_val = static_cast<std::byte>((static_cast<std::uint8_t>(byte_val) & ~mask) | ((color_value & 0x07) << shift));
  } else {
    // 3-bit value spans two bytes
    const auto high_bits = static_cast<std::uint8_t>(8 - bit_offset);
    const auto low_bits = static_cast<std::uint8_t>(3 - high_bits);
 
    // First byte: set the high bits
    const auto high_mask = static_cast<std::uint8_t>((1U << high_bits) - 1);
    auto &high_byte = buffer[byte_index];
    high_byte = static_cast<std::byte>((static_cast<std::uint8_t>(high_byte) & ~high_mask) |
                                       ((color_value >> low_bits) & high_mask));
 
    // Second byte: set the low bits
    if (byte_index + 1 < buffer.size()) {
      const auto low_mask = static_cast<std::uint8_t>(((1U << low_bits) - 1) << (8 - low_bits));
      auto &low_byte = buffer[byte_index + 1];
      low_byte = static_cast<std::byte>((static_cast<std::uint8_t>(low_byte) & ~low_mask) |
                                        ((color_value & ((1U << low_bits) - 1)) << (8 - low_bits)));
    }
  }
}
 
inline auto set_pixel_in_buffer(DisplayMode mode, std::span<std::byte> buffer, std::size_t width, std::size_t height,
                                std::size_t x, std::size_t y, Color color) noexcept -> void {
  switch (mode) {
  case DisplayMode::BlackWhite:
    set_pixel_bw(buffer, width, x, y, color);
    break;
  case DisplayMode::Grayscale4:
    set_pixel_grayscale4(buffer, width, x, y, color);
    break;
  case DisplayMode::BWR:
    set_pixel_bwr_bwy(buffer, width, height, x, y, color, true);
    break;
  case DisplayMode::BWY:
    set_pixel_bwr_bwy(buffer, width, height, x, y, color, false);
    break;
  case DisplayMode::Spectra6:
    set_pixel_spectra6(buffer, width, x, y, color);
    break;
  }
}
 
} // namespace epaper