ra8_epaper_geom.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_epaper.h"
#include "ra8_err.h"

static const char* const s_tag = "EPAPER";

typedef enum : uint16_t {
  k_ra8_epaper_geom_bits_per_byte = 8U,    
  k_ra8_epaper_geom_panel_max_dim = 4096U, 
} ra8_epaper_geom_const_t;

typedef enum : uint8_t {
  k_ra8_epaper_bpp_1 = 1U, 
  k_ra8_epaper_bpp_2 = 2U, 
  k_ra8_epaper_bpp_4 = 4U, 
  k_ra8_epaper_bpp_8 = 8U, 
} ra8_epaper_bpp_t;

typedef enum : uint8_t {
  k_ra8_epaper_lut_init    = 0U, 
  k_ra8_epaper_lut_du      = 1U, 
  k_ra8_epaper_lut_gc16    = 2U, 
  k_ra8_epaper_lut_a2_m641 = 4U, 
  k_ra8_epaper_lut_a2_gen  = 6U, 
} ra8_epaper_lut_mode_t;

static const char* const s_lut_m641 = "M641";
 
[[nodiscard]] uint8_t ra8_epaper_bits_per_pixel(ra8_epaper_pixel_format_t pf)
{
  switch (pf) {
    case k_ra8_epaper_pf_1bpp:
      return (uint8_t)k_ra8_epaper_bpp_1;
    case k_ra8_epaper_pf_2bpp:
      return (uint8_t)k_ra8_epaper_bpp_2;
    case k_ra8_epaper_pf_4bpp:
      return (uint8_t)k_ra8_epaper_bpp_4;
    case k_ra8_epaper_pf_8bpp:
    default:
      return (uint8_t)k_ra8_epaper_bpp_8;
  }
}
 
[[nodiscard]] ra8_err_t ra8_epaper_image_bytes(const ra8_epaper_area_t*  area,
                                               ra8_epaper_pixel_format_t pf,
                                               size_t*                   out_bytes)
{
  RA8_CHECK_NULL_PTR(area, s_tag, "image_bytes: area null");
  RA8_CHECK_NULL_PTR(out_bytes, s_tag, "image_bytes: out null");
  if ((area->width == 0U) || (area->height == 0U)) {
    return k_ra8_err_invalid_size;
  }
  const size_t bpp           = (size_t)ra8_epaper_bits_per_pixel(pf);
  const size_t bits_per_byte = (size_t)k_ra8_epaper_geom_bits_per_byte;
  /* Rows are packed independently and each starts on a byte boundary. */
  const size_t row_bytes = (((size_t)area->width * bpp) + (bits_per_byte - 1U)) / bits_per_byte;
  *out_bytes             = row_bytes * (size_t)area->height;
  return k_ra8_ok;
}
 
[[nodiscard]] bool ra8_epaper_area_is_aligned(const ra8_epaper_area_t*  area,
                                              ra8_epaper_pixel_format_t pf)
{
  if (area == nullptr) {
    return false;
  }
  if (pf != k_ra8_epaper_pf_1bpp) {
    return true;
  }
  const uint16_t grid = (uint16_t)k_ra8_epaper_align_1bpp_px;
  return ((area->x % grid) == 0U) && ((area->width % grid) == 0U);
}
 
[[nodiscard]] ra8_err_t
ra8_epaper_align_area(ra8_epaper_area_t* area, ra8_epaper_pixel_format_t pf, uint16_t panel_width)
{
  RA8_CHECK_NULL_PTR(area, s_tag, "align_area: area null");
  if (panel_width == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (((uint32_t)area->x + (uint32_t)area->width) > (uint32_t)panel_width) {
    return k_ra8_err_invalid_arg;
  }
  if (pf != k_ra8_epaper_pf_1bpp) {
    return k_ra8_ok;
  }
  const uint32_t grid  = (uint32_t)k_ra8_epaper_align_1bpp_px;
  const uint32_t right = (uint32_t)area->x + (uint32_t)area->width;
  const uint32_t x_lo  = ((uint32_t)area->x / grid) * grid;
  /* Grow outward so the caller's rectangle stays wholly covered. */
  uint32_t x_hi = ((right + grid - 1U) / grid) * grid;
  if (x_hi > (uint32_t)panel_width) {
    x_hi = (uint32_t)panel_width;
  }
  if ((x_hi <= x_lo) || (((x_hi - x_lo) % grid) != 0U)) {
    /* The clamp cut the window off the grid: the panel width is itself not
     * a multiple of the 1 bpp grid, so no aligned superset exists here. */
    return k_ra8_err_invalid_arg;
  }
  area->x     = (uint16_t)x_lo;
  area->width = (uint16_t)(x_hi - x_lo);
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_epaper_waveform_cfg_for_lut(const char*                lut_version,
                                                        ra8_epaper_waveform_cfg_t* out_cfg)
{
  RA8_CHECK_NULL_PTR(lut_version, s_tag, "waveform_cfg: lut null");
  RA8_CHECK_NULL_PTR(out_cfg, s_tag, "waveform_cfg: out null");
  bool is_m641 = true;
  for (uint32_t i = 0U; s_lut_m641[i] != '\0'; i++) {
    if (lut_version[i] != s_lut_m641[i]) {
      is_m641 = false;
      break;
    }
  }
  out_cfg->init = (uint8_t)k_ra8_epaper_lut_init;
  out_cfg->du   = (uint8_t)k_ra8_epaper_lut_du;
  out_cfg->gc16 = (uint8_t)k_ra8_epaper_lut_gc16;
  out_cfg->a2   = is_m641 ? (uint8_t)k_ra8_epaper_lut_a2_m641 : (uint8_t)k_ra8_epaper_lut_a2_gen;
  return k_ra8_ok;
}

RA8_INTERNAL
[[nodiscard]] static ra8_err_t
internal_ra8_epaper_validate_waveform(const ra8_epaper_waveform_cfg_t* wf)
{
  if ((wf->du == 0U) || (wf->gc16 == 0U) || (wf->a2 == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  if ((wf->init > (uint8_t)k_ra8_epaper_wf_mode_max) ||
      (wf->du > (uint8_t)k_ra8_epaper_wf_mode_max) ||
      (wf->gc16 > (uint8_t)k_ra8_epaper_wf_mode_max) ||
      (wf->a2 > (uint8_t)k_ra8_epaper_wf_mode_max)) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_epaper_validate_cfg(const ra8_epaper_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "validate_cfg: cfg null");
  if ((cfg->bus.xfer8 == nullptr) || (cfg->panel_width == 0U) || (cfg->panel_height == 0U) ||
      (cfg->panel_width > (uint16_t)k_ra8_epaper_geom_panel_max_dim) ||
      (cfg->panel_height > (uint16_t)k_ra8_epaper_geom_panel_max_dim)) {
    return k_ra8_err_invalid_arg;
  }
  return internal_ra8_epaper_validate_waveform(&cfg->waveform);
}
 
[[nodiscard]] bool ra8_epaper_geometry_agrees(const ra8_epaper_dev_info_t* info,
                                              const ra8_epaper_cfg_t*      cfg)
{
  if ((info == nullptr) || (cfg == nullptr)) {
    return false;
  }
  return (info->panel_width == cfg->panel_width) && (info->panel_height == cfg->panel_height);
}