gray4_framebuffer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/epaper/color>
#include <idfxx/epaper/panel>
#include <idfxx/error>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <span>
#include <utility>
#include <vector>
 
namespace idfxx::epaper {
 
class gray4_framebuffer {
public:
    using pixel_type = gray4;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] gray4_framebuffer(size_t width, size_t height)
        : gray4_framebuffer(unwrap(make(width, height))) {}
#endif
 
    [[nodiscard]] static result<gray4_framebuffer> make(size_t width, size_t height) {
        if (width == 0 || height == 0) {
            return error(errc::invalid_arg);
        }
        // Both planes live in one allocation: plane 0 first, then plane 1.
        return gray4_framebuffer{width, height, std::vector<uint8_t>(2 * ((width + 7) / 8) * height)};
    }
 
    [[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, gray4 level) noexcept {
        if (x >= _width || y >= _height) {
            return;
        }
        const size_t index = y * stride_bytes() + x / 8;
        const uint8_t mask = static_cast<uint8_t>(1u << (7 - x % 8));
        const auto bits = std::to_underlying(level);
        _set_plane_bit(_data[index], mask, (bits & 0x01) != 0);
        _set_plane_bit(_data[_plane_size() + index], mask, (bits & 0x02) != 0);
    }
 
    [[nodiscard]] gray4 get_pixel(size_t x, size_t y) const noexcept {
        if (x >= _width || y >= _height) {
            return gray4::white;
        }
        const size_t index = y * stride_bytes() + x / 8;
        const uint8_t mask = static_cast<uint8_t>(1u << (7 - x % 8));
        uint8_t bits = 0;
        if ((_data[index] & mask) != 0) {
            bits |= 0x01;
        }
        if ((_data[_plane_size() + index] & mask) != 0) {
            bits |= 0x02;
        }
        return static_cast<gray4>(bits);
    }
 
    void fill(gray4 level) noexcept {
        const auto bits = std::to_underlying(level);
        auto plane0 = std::span<uint8_t>(_data).first(_plane_size());
        auto plane1 = std::span<uint8_t>(_data).last(_plane_size());
        std::ranges::fill(plane0, (bits & 0x01) != 0 ? uint8_t{0xFF} : uint8_t{0x00});
        std::ranges::fill(plane1, (bits & 0x02) != 0 ? uint8_t{0xFF} : uint8_t{0x00});
    }
 
    void clear() noexcept { fill(gray4::white); }
 
    [[nodiscard]] std::span<const uint8_t> plane(size_t index) const noexcept {
        return std::span<const uint8_t>(_data).subspan(index * _plane_size(), _plane_size());
    }
 
    [[nodiscard]] std::span<const uint8_t> plane_row(size_t index, size_t y) const noexcept {
        return plane(index).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:
    gray4_framebuffer(size_t width, size_t height, std::vector<uint8_t> data)
        : _width(width)
        , _height(height)
        , _data(std::move(data)) {}
 
    [[nodiscard]] size_t _plane_size() const noexcept { return stride_bytes() * _height; }
 
    static void _set_plane_bit(uint8_t& byte, uint8_t mask, bool on) noexcept {
        if (on) {
            byte |= mask;
        } else {
            byte &= static_cast<uint8_t>(~mask);
        }
    }
 
    size_t _width;
    size_t _height;
    std::vector<uint8_t> _data; // plane 0 followed by plane 1
};
 
} // namespace idfxx::epaper