mono_framebuffer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/epaper/panel>
#include <idfxx/error>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
namespace idfxx::epaper {
 
class mono_framebuffer {
public:
    using pixel_type = bool;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] mono_framebuffer(size_t width, size_t height)
        : mono_framebuffer(unwrap(make(width, height))) {}
#endif
 
    [[nodiscard]] static result<mono_framebuffer> make(size_t width, size_t height) {
        if (width == 0 || height == 0) {
            return error(errc::invalid_arg);
        }
        return mono_framebuffer{width, height, std::vector<uint8_t>(((width + 7) / 8) * height, 0xFF)};
    }
 
    [[nodiscard]] size_t width() const noexcept { return _width; }
 
    [[nodiscard]] size_t height() const noexcept { return _height; }
 
    [[nodiscard]] size_t stride_bytes() const noexcept { return (_width + 7) / 8; }
 
    void set_pixel(size_t x, size_t y, bool ink) noexcept {
        if (x >= _width || y >= _height) {
            return;
        }
        uint8_t& byte = _data[y * stride_bytes() + x / 8];
        uint8_t mask = static_cast<uint8_t>(1u << (7 - x % 8));
        // Controller RAM convention: a set bit is white, a cleared bit is ink.
        if (ink) {
            byte &= static_cast<uint8_t>(~mask);
        } else {
            byte |= mask;
        }
    }
 
    [[nodiscard]] bool get_pixel(size_t x, size_t y) const noexcept {
        if (x >= _width || y >= _height) {
            return false;
        }
        return (_data[y * stride_bytes() + x / 8] & (1u << (7 - x % 8))) == 0;
    }
 
    void fill(bool ink) noexcept { std::ranges::fill(_data, ink ? uint8_t{0x00} : uint8_t{0xFF}); }
 
    void clear() noexcept { fill(false); }
 
    [[nodiscard]] std::span<const uint8_t> data() const noexcept { return _data; }
 
    [[nodiscard]] std::span<const uint8_t> row(size_t y) const noexcept {
        return std::span<const uint8_t>(_data).subspan(y * stride_bytes(), stride_bytes());
    }
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void flush(panel& panel, size_t x = 0, size_t y = 0) const { unwrap(try_flush(panel, x, y)); }
 
    void flush_rows(panel& panel, size_t y_start, size_t y_end) const { unwrap(try_flush_rows(panel, y_start, y_end)); }
#endif
 
    [[nodiscard]] result<void> try_flush(panel& panel, size_t x = 0, size_t y = 0) const {
        return panel.try_write(*this, x, y);
    }
 
    [[nodiscard]] result<void> try_flush_rows(panel& panel, size_t y_start, size_t y_end) const {
        return panel.try_write_rows(*this, y_start, y_end);
    }
 
private:
    mono_framebuffer(size_t width, size_t height, std::vector<uint8_t> data)
        : _width(width)
        , _height(height)
        , _data(std::move(data)) {}
 
    size_t _width;
    size_t _height;
    std::vector<uint8_t> _data;
};
 
} // namespace idfxx::epaper