//! Basic graphics types and blitter traits for platform backends.
//!
//! These types describe pixel surfaces and operations that can be
//! accelerated by different platform implementations.
#[cfg(any(
feature = "canvas",
feature = "gif",
feature = "apng",
feature = "nes",
feature = "png",
feature = "jpeg",
feature = "qrcode",
feature = "lottie",
feature = "fontdue",
test,
))]
use alloc::vec::Vec;
#[cfg(feature = "fontdue")]
use alloc::{collections::BTreeMap, vec};
use bitflags::bitflags;
use heapless::Vec as HVec;
use rlvgl_core::cmd::{BlendMode, Cmd, CommandList};
use rlvgl_core::font::{FontMetrics, ShapedText};
#[cfg(feature = "fontdue")]
use rlvgl_core::fontdue::{Metrics, line_metrics, rasterize_glyph};
use rlvgl_core::renderer::Renderer;
use rlvgl_core::widget::{Color, Rect as WidgetRect};
#[cfg(feature = "fontdue")]
const FONT_DATA: &[u8] = include_bytes!("../assets/fonts/DejaVuSans.ttf");
#[cfg(feature = "fontdue")]
fn round_to_i32(value: f32) -> i32 {
if value.is_nan() {
0
} else if value >= 0.0 {
(value + 0.5) as i32
} else {
(value - 0.5) as i32
}
}
#[cfg(feature = "fontdue")]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
/// Key identifying a cached glyph by font, size, and character.
struct GlyphKey {
/// Pointer to the font data used to rasterize the glyph.
font: *const u8,
/// Font size in pixels, stored as raw bits for ordering.
size: u32,
/// Unicode codepoint of the glyph.
ch: char,
}
/// Supported pixel formats.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PixelFmt {
/// 32-bit ARGB8888 format.
Argb8888,
/// 16-bit RGB565 format.
Rgb565,
/// 8-bit grayscale format.
L8,
/// 8-bit alpha-only format.
A8,
/// 4-bit alpha-only format.
A4,
}
/// Rectangular region within a surface.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Rect {
/// Left coordinate of the rectangle.
pub x: i32,
/// Top coordinate of the rectangle.
pub y: i32,
/// Width of the rectangle in pixels.
pub w: u32,
/// Height of the rectangle in pixels.
pub h: u32,
}
/// A pixel buffer with dimension and format metadata.
pub struct Surface<'a> {
/// Underlying pixel storage.
pub buf: &'a mut [u8],
/// Number of bytes between consecutive lines.
pub stride: usize,
/// Pixel format used by the buffer.
pub format: PixelFmt,
/// Width of the surface in pixels.
pub width: u32,
/// Height of the surface in pixels.
pub height: u32,
}
impl<'a> Surface<'a> {
/// Create a new surface from raw parts.
pub fn new(
buf: &'a mut [u8],
stride: usize,
format: PixelFmt,
width: u32,
height: u32,
) -> Self {
Self {
buf,
stride,
format,
width,
height,
}
}
}
bitflags! {
/// Capabilities supported by a blitter implementation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BlitCaps: u32 {
/// Ability to fill regions with a solid color.
const FILL = 0b0001;
/// Ability to copy pixels between surfaces.
const BLIT = 0b0010;
/// Ability to blend a source over a destination.
const BLEND = 0b0100;
/// Ability to convert between pixel formats.
const PFC = 0b1000;
}
}
/// Trait implemented by types capable of transferring pixel data.
pub trait Blitter {
/// Return the capabilities supported by this blitter.
fn caps(&self) -> BlitCaps;
/// Fill `area` within `dst` with a solid `color`.
fn fill(&mut self, dst: &mut Surface, area: Rect, color: u32);
/// Copy pixels from `src` within `src_area` to `dst` at `dst_pos`.
fn blit(&mut self, src: &Surface, src_area: Rect, dst: &mut Surface, dst_pos: (i32, i32));
/// Blend pixels from `src` over `dst`.
fn blend(&mut self, src: &Surface, src_area: Rect, dst: &mut Surface, dst_pos: (i32, i32));
}
/// Collects dirty rectangles for a frame and optionally coalesces them.
///
/// The planner stores up to `N` rectangles in a stack-allocated buffer. Call
/// [`Self::add`] to register a region that changed during rendering and
/// [`Self::rects`] to obtain the batched list for flushing. After presenting
/// the frame, call [`Self::clear`] to reuse the planner for the next frame.
///
/// Adds beyond `N` are silently dropped, but [`Self::overflowed`] flips to
/// `true` so callers driving a dirty-rect present path know the rect set is
/// incomplete and can fall back to a full-frame repaint for that frame.
pub struct BlitPlanner<const N: usize> {
rects: HVec<Rect, N>,
overflowed: bool,
}
impl<const N: usize> BlitPlanner<N> {
/// Create an empty planner.
pub fn new() -> Self {
Self {
rects: HVec::new(),
overflowed: false,
}
}
/// Record a dirty rectangle.
pub fn add(&mut self, rect: Rect) {
if self.rects.push(rect).is_err() {
self.overflowed = true;
}
}
/// Return all accumulated rectangles.
pub fn rects(&self) -> &[Rect] {
&self.rects
}
/// Whether [`Self::add`] dropped a rect because the planner was full.
pub fn overflowed(&self) -> bool {
self.overflowed
}
/// Remove all stored rectangles.
pub fn clear(&mut self) {
self.rects.clear();
self.overflowed = false;
}
}
impl<const N: usize> Default for BlitPlanner<N> {
fn default() -> Self {
Self::new()
}
}
/// Renderer implementation backed by a [`Blitter`].
///
/// A `BlitterRenderer` owns a target [`Surface`] and batches dirty regions
/// using a [`BlitPlanner`]. Widgets interact with the generic [`Renderer`] trait
/// without being aware of the underlying blitter.
pub struct BlitterRenderer<'a, B: Blitter, const N: usize> {
blitter: &'a mut B,
surface: Surface<'a>,
planner: BlitPlanner<N>,
#[cfg(any(
feature = "canvas",
feature = "gif",
feature = "apng",
feature = "nes",
all(feature = "png", not(target_os = "none")),
all(feature = "jpeg", not(target_os = "none")),
all(feature = "qrcode", not(target_os = "none")),
feature = "lottie",
test,
))]
scratch: Option<Vec<u8>>,
#[cfg(feature = "fontdue")]
glyph_cache: BTreeMap<GlyphKey, (Metrics, Vec<u8>)>,
}
impl<'a, B: Blitter, const N: usize> BlitterRenderer<'a, B, N> {
/// Create a new renderer targeting `surface` using `blitter`.
pub fn new(blitter: &'a mut B, surface: Surface<'a>) -> Self {
Self {
blitter,
surface,
planner: BlitPlanner::new(),
#[cfg(any(
feature = "canvas",
feature = "gif",
feature = "apng",
feature = "nes",
all(feature = "png", not(target_os = "none")),
all(feature = "jpeg", not(target_os = "none")),
all(feature = "qrcode", not(target_os = "none")),
feature = "lottie",
test,
))]
scratch: None,
#[cfg(feature = "fontdue")]
glyph_cache: BTreeMap::new(),
}
}
/// Access the internal dirty-rectangle planner.
pub fn planner(&mut self) -> &mut BlitPlanner<N> {
&mut self.planner
}
#[cfg(any(
feature = "canvas",
feature = "gif",
feature = "apng",
feature = "nes",
all(feature = "png", not(target_os = "none")),
all(feature = "jpeg", not(target_os = "none")),
all(feature = "qrcode", not(target_os = "none")),
feature = "lottie",
test,
))]
fn blit_colors(&mut self, position: (i32, i32), pixels: &[Color], w: u32, h: u32) {
let required = (w * h * 4) as usize;
let buf = self.scratch.get_or_insert_with(Vec::new);
if buf.len() < required {
buf.resize(required, 0);
}
for (i, c) in pixels.iter().enumerate() {
buf[i * 4..i * 4 + 4].copy_from_slice(&c.to_argb8888().to_le_bytes());
}
let src = Surface::new(
&mut buf[..required],
(w * 4) as usize,
PixelFmt::Argb8888,
w,
h,
);
self.blitter
.blit(&src, Rect { x: 0, y: 0, w, h }, &mut self.surface, position);
self.planner.add(Rect {
x: position.0,
y: position.1,
w,
h,
});
}
#[cfg(all(feature = "png", not(target_os = "none")))]
/// Decode a PNG image and blit it onto the target surface.
pub fn draw_png(
&mut self,
position: (i32, i32),
data: &[u8],
) -> Result<(), rlvgl_core::png::DecodingError> {
let (pixels, w, h) = rlvgl_core::png::decode(data)?;
self.blit_colors(position, &pixels, w, h);
Ok(())
}
#[cfg(all(feature = "jpeg", not(target_os = "none")))]
/// Decode a JPEG image and blit it onto the target surface.
pub fn draw_jpeg(
&mut self,
position: (i32, i32),
data: &[u8],
) -> Result<(), rlvgl_core::jpeg::Error> {
let (pixels, w, h) = rlvgl_core::jpeg::decode(data)?;
self.blit_colors(position, &pixels, w as u32, h as u32);
Ok(())
}
#[cfg(all(feature = "qrcode", not(target_os = "none")))]
/// Generate a QR code from `data` and blit it onto the target surface.
pub fn draw_qr(
&mut self,
position: (i32, i32),
data: &[u8],
) -> Result<(), rlvgl_core::qrcode::QrError> {
let (pixels, w, h) = rlvgl_core::qrcode::generate(data)?;
self.blit_colors(position, &pixels, w, h);
Ok(())
}
#[cfg(feature = "lottie")]
/// Render a Lottie JSON animation frame and blit it onto the target surface.
///
/// Returns an error if the JSON data is invalid.
pub fn draw_lottie_frame(
&mut self,
position: (i32, i32),
json: &str,
frame: usize,
width: u32,
height: u32,
) -> Result<(), rlvgl_core::lottie::Error> {
let pixels =
rlvgl_core::lottie::render_lottie_frame(json, frame, width as usize, height as usize)?;
self.blit_colors(position, &pixels, width, height);
Ok(())
}
#[cfg(feature = "canvas")]
/// Blit an [`rlvgl_core::canvas::Canvas`] onto the target surface.
pub fn draw_canvas(&mut self, position: (i32, i32), canvas: &rlvgl_core::canvas::Canvas) {
let (w, h) = canvas.size();
let pixels = canvas.pixels();
self.blit_colors(position, &pixels, w, h);
}
#[cfg(feature = "gif")]
/// Decode a GIF and blit the selected frame onto the target surface.
pub fn draw_gif_frame(
&mut self,
position: (i32, i32),
data: &[u8],
frame: usize,
) -> Result<(), rlvgl_core::gif::DecodingError> {
let (frames, w, h) = rlvgl_core::gif::decode(data)?;
if let Some(f) = frames.get(frame) {
self.blit_colors(position, &f.pixels, w as u32, h as u32);
}
Ok(())
}
#[cfg(feature = "apng")]
/// Decode an APNG and blit the selected frame onto the target surface.
pub fn draw_apng_frame(
&mut self,
position: (i32, i32),
data: &[u8],
frame: usize,
) -> Result<(), image::ImageError> {
let (frames, w, h) = rlvgl_core::apng::decode(data)?;
if let Some(f) = frames.get(frame) {
self.blit_colors(position, &f.pixels, w, h);
}
Ok(())
}
#[cfg(all(feature = "pinyin", feature = "fontdue"))]
/// Render Pinyin IME candidate characters via the blitter.
///
/// Returns `true` if any candidates were rendered for `input`.
pub fn draw_pinyin_candidates(
&mut self,
position: (i32, i32),
ime: &rlvgl_core::pinyin::PinyinInputMethod,
input: &str,
color: Color,
) -> bool {
if let Some(chars) = ime.candidates(input) {
// Determine remaining space on the surface.
let max_w = self.surface.width as i32 - position.0;
let max_h = self.surface.height as i32 - position.1;
if max_w <= 0 || max_h < 16 {
return false;
}
// Truncate the candidate string to fit within the surface width.
let text: alloc::string::String = chars.into_iter().collect();
let max_chars = (max_w / 16) as usize;
let clipped: alloc::string::String = text.chars().take(max_chars).collect();
if clipped.is_empty() {
return false;
}
Renderer::draw_text(self, position, &clipped, color);
true
} else {
false
}
}
#[cfg(all(feature = "fatfs", feature = "fontdue"))]
/// List a FAT directory and render the entries line by line.
pub fn draw_fatfs_dir<T>(
&mut self,
position: (i32, i32),
image: &mut T,
dir: &str,
color: Color,
) -> Result<(), std::io::Error>
where
T: std::io::Read + std::io::Write + std::io::Seek,
{
let max_w = self.surface.width as i32 - position.0;
let max_h = self.surface.height as i32 - position.1;
if max_w <= 0 || max_h <= 0 {
return Ok(());
}
let line_h = 16;
let max_lines = (max_h / line_h) as usize;
let max_chars = (max_w / 16) as usize;
let names = rlvgl_core::fatfs::list_dir(image, dir)?;
for (i, name) in names.iter().take(max_lines).enumerate() {
let y = position.1 + (i as i32) * line_h;
let clipped: alloc::string::String = name.chars().take(max_chars).collect();
if clipped.is_empty() {
break;
}
Renderer::draw_text(self, (position.0, y), &clipped, color);
}
Ok(())
}
#[cfg(feature = "nes")]
/// Blit an NES frame represented as ARGB8888 [`Color`] pixels.
pub fn draw_nes_frame(
&mut self,
position: (i32, i32),
pixels: &[Color],
width: u32,
height: u32,
) {
self.blit_colors(position, pixels, width, height);
}
#[cfg(feature = "fontdue")]
/// Draw UTF-8 text using the supplied font and size.
pub fn draw_text(
&mut self,
position: (i32, i32),
text: &str,
color: Color,
font_data: &[u8],
px: f32,
) {
let vm = line_metrics(font_data, px).unwrap();
let ascent = round_to_i32(vm.ascent);
let baseline = position.1 + ascent;
let mut x_cursor = position.0;
for ch in text.chars() {
let key = GlyphKey {
font: font_data.as_ptr(),
size: px.to_bits(),
ch,
};
let (metrics, bitmap) = {
let entry = self
.glyph_cache
.entry(key)
.or_insert_with(|| rasterize_glyph(font_data, ch, px).unwrap());
(entry.0, entry.1.clone())
};
let w = metrics.width as i32;
let h = metrics.height as i32;
if w == 0 || h == 0 {
x_cursor += round_to_i32(metrics.advance_width);
continue;
}
let mut argb = vec![0u8; (w * h * 4) as usize];
for y in 0..h {
for x in 0..w {
let alpha = bitmap[(y) as usize * metrics.width + x as usize];
let idx = ((y * w + x) * 4) as usize;
argb[idx] = (color.0 as u16 * alpha as u16 / 255) as u8;
argb[idx + 1] = (color.1 as u16 * alpha as u16 / 255) as u8;
argb[idx + 2] = (color.2 as u16 * alpha as u16 / 255) as u8;
argb[idx + 3] = alpha;
}
}
let src = Surface::new(
argb.as_mut_slice(),
(w * 4) as usize,
PixelFmt::Argb8888,
w as u32,
h as u32,
);
let dst_pos = (
x_cursor + metrics.xmin,
baseline - ascent - metrics.ymin - (h - 1),
);
self.blitter.blend(
&src,
Rect {
x: 0,
y: 0,
w: w as u32,
h: h as u32,
},
&mut self.surface,
dst_pos,
);
self.planner.add(Rect {
x: dst_pos.0,
y: dst_pos.1,
w: w as u32,
h: h as u32,
});
x_cursor += round_to_i32(metrics.advance_width);
}
}
#[cfg(not(feature = "fontdue"))]
/// Stub text renderer when fontdue is disabled.
pub fn draw_text(
&mut self,
position: (i32, i32),
text: &str,
color: Color,
_font_data: &[u8],
_px: f32,
) {
let _ = (position, text, color);
}
}
impl<B: Blitter, const N: usize> Renderer for BlitterRenderer<'_, B, N> {
fn blend_rect(&mut self, rect: WidgetRect, color: Color) {
let alpha = color.3 as u16;
if alpha == 0 {
return;
}
if alpha == 255 {
self.fill_rect(rect, color);
return;
}
// Inline source-over blending for ARGB8888 surfaces.
if self.surface.format == PixelFmt::Argb8888 {
let sw = self.surface.width as i32;
let sh = self.surface.height as i32;
let stride = self.surface.stride;
let inv = 255 - alpha;
let x0 = rect.x.max(0);
let y0 = rect.y.max(0);
let x1 = (rect.x + rect.width).min(sw);
let y1 = (rect.y + rect.height).min(sh);
for y in y0..y1 {
for x in x0..x1 {
let off = y as usize * stride + x as usize * 4;
let bg_b = self.surface.buf[off] as u16;
let bg_g = self.surface.buf[off + 1] as u16;
let bg_r = self.surface.buf[off + 2] as u16;
self.surface.buf[off] = ((color.2 as u16 * alpha + bg_b * inv) / 255) as u8;
self.surface.buf[off + 1] = ((color.1 as u16 * alpha + bg_g * inv) / 255) as u8;
self.surface.buf[off + 2] = ((color.0 as u16 * alpha + bg_r * inv) / 255) as u8;
self.surface.buf[off + 3] = 0xff;
}
}
self.planner.add(Rect {
x: rect.x,
y: rect.y,
w: rect.width as u32,
h: rect.height as u32,
});
} else {
// Fallback for non-ARGB8888 surfaces: just overwrite.
self.fill_rect(rect, color);
}
}
fn fill_rect(&mut self, rect: WidgetRect, color: Color) {
let r = Rect {
x: rect.x,
y: rect.y,
w: rect.width as u32,
h: rect.height as u32,
};
self.planner.add(r);
self.blitter.fill(&mut self.surface, r, color.to_argb8888());
}
fn draw_text(&mut self, position: (i32, i32), text: &str, color: Color) {
#[cfg(feature = "fontdue")]
{
const PX: f32 = 16.0;
BlitterRenderer::draw_text(self, position, text, color, FONT_DATA, PX);
}
#[cfg(not(feature = "fontdue"))]
{
let _ = (position, text, color);
}
}
fn draw_pixels(&mut self, position: (i32, i32), pixels: &[Color], width: u32, height: u32) {
// Fast path: write ARGB8888 pixels directly into the surface buffer,
// then record the dirty rectangle. Avoids per-pixel fill_rect overhead.
if self.surface.format == PixelFmt::Argb8888 {
let sw = self.surface.width as i32;
let sh = self.surface.height as i32;
let stride = self.surface.stride;
for y in 0..height as i32 {
let dy = position.1 + y;
if dy < 0 || dy >= sh {
continue;
}
for x in 0..width as i32 {
let dx = position.0 + x;
if dx < 0 || dx >= sw {
continue;
}
let src_idx = (y as u32 * width + x as u32) as usize;
if let Some(&c) = pixels.get(src_idx) {
let off = dy as usize * stride + dx as usize * 4;
self.surface.buf[off..off + 4]
.copy_from_slice(&c.to_argb8888().to_le_bytes());
}
}
}
self.planner.add(Rect {
x: position.0,
y: position.1,
w: width,
h: height,
});
} else {
// Fallback: per-pixel fill_rect for non-ARGB8888 surfaces
for y in 0..height as i32 {
for x in 0..width as i32 {
let idx = (y as u32 * width + x as u32) as usize;
if let Some(&c) = pixels.get(idx) {
self.fill_rect(
WidgetRect {
x: position.0 + x,
y: position.1 + y,
width: 1,
height: 1,
},
c,
);
}
}
}
}
}
fn blend_row(&mut self, x: i32, y: i32, color: Color, coverage: &[u8]) {
// AA inner-loop primitive. Direct ARGB8888 source-over with per-pixel
// alpha = (color.alpha * coverage[i]) / 255. One planner.add per row
// keeps DMA2D refresh granularity efficient versus per-pixel adds.
if color.3 == 0 || coverage.is_empty() {
return;
}
if self.surface.format != PixelFmt::Argb8888 {
// Non-ARGB8888 surfaces: fall back through the trait default
// (per-pixel blend_rect). This branch is rare on disco.
for (i, &cov) in coverage.iter().enumerate() {
if cov == 0 {
continue;
}
let alpha = ((color.3 as u16 * cov as u16) / 255) as u8;
if alpha == 0 {
continue;
}
self.blend_rect(
WidgetRect {
x: x + i as i32,
y,
width: 1,
height: 1,
},
Color(color.0, color.1, color.2, alpha),
);
}
return;
}
let sw = self.surface.width as i32;
let sh = self.surface.height as i32;
if y < 0 || y >= sh {
return;
}
let stride = self.surface.stride;
let src_a = color.3 as u16;
let row_off = y as usize * stride;
let mut written_x0 = i32::MAX;
let mut written_x1 = i32::MIN;
for (i, &cov) in coverage.iter().enumerate() {
if cov == 0 {
continue;
}
let px = x + i as i32;
if px < 0 || px >= sw {
continue;
}
let alpha = (src_a * cov as u16) / 255;
if alpha == 0 {
continue;
}
let inv = 255 - alpha;
let off = row_off + (px as usize) * 4;
let bg_b = self.surface.buf[off] as u16;
let bg_g = self.surface.buf[off + 1] as u16;
let bg_r = self.surface.buf[off + 2] as u16;
self.surface.buf[off] = ((color.2 as u16 * alpha + bg_b * inv) / 255) as u8;
self.surface.buf[off + 1] = ((color.1 as u16 * alpha + bg_g * inv) / 255) as u8;
self.surface.buf[off + 2] = ((color.0 as u16 * alpha + bg_r * inv) / 255) as u8;
self.surface.buf[off + 3] = 0xff;
if px < written_x0 {
written_x0 = px;
}
if px > written_x1 {
written_x1 = px;
}
}
if written_x0 <= written_x1 {
self.planner.add(Rect {
x: written_x0,
y,
w: (written_x1 - written_x0 + 1) as u32,
h: 1,
});
}
}
fn submit(&mut self, list: &CommandList) {
submit_with_occlusion(self, list);
}
}
/// `CommandSink` impl with occlusion pre-pass.
///
/// Backend-specialized submit path: walks the [`CommandList`] and, for
/// each cmd, checks whether any *later* opaque [`Cmd::FillRect`] fully
/// covers its AABB. If so, the cmd is skipped entirely — it would be
/// overwritten anyway. Survivors are dispatched via the normal
/// [`Renderer`] trait methods on `self` (existing
/// [`BlitterRenderer::blend_row`] override applies, so AA cmds get the
/// hardware-blend fast path).
///
/// The check is O(n²) but cmd counts are small (a typical clock frame
/// is 50–100 cmds). Only `FillRect` with `alpha == 255` qualifies as an
/// occluder — geometric primitives (OBB, disc, arc, line) don't fully
/// cover their AABBs and are never occluders even at full alpha.
///
/// Two-pass dispatch:
///
/// 1. **Occlusion pre-pass.** For each cmd, scan forward looking for a
/// later opaque [`Cmd::FillRect`] whose AABB fully covers it; if
/// found, drop the cmd. Markers (`Barrier`, `SetClip`) terminate
/// the search range — a `Barrier` declares ordering that must be
/// preserved (compositor sync, swap hold), and a `SetClip` change
/// means later cmds render under a different clip and can't be
/// trusted as occluders of earlier pixels.
///
/// 2. **Adjacent-FillRect coalescing.** Survivor cmds are dispatched
/// one at a time, but consecutive [`Cmd::FillRect`]s with identical
/// `color` + `blend` and edge-adjacent rectangles are merged into a
/// single wider FillRect. Cuts down on the number of DMA2D fill
/// ops and reduces dirty-rect tracking pressure when widgets
/// happen to emit sequential strips of the same fill (toolbars,
/// background bands, table cells).
///
/// The coalescing is conservative — only horizontal or vertical edge
/// adjacency is detected (no L-shapes, no overlap-into-union). For
/// the common case of a row of cells fixed-width and same-color, this
/// reduces N rects to 1.
fn submit_with_occlusion<B: Blitter, const N: usize>(
r: &mut BlitterRenderer<'_, B, N>,
list: &CommandList,
) {
let mut pending: Option<(WidgetRect, Color, BlendMode)> = None;
for (i, cmd) in list.iter().enumerate() {
// Occlusion pre-pass.
let occluded = match cmd.aabb() {
None => false,
Some(bb_i) => {
let mut hit = false;
for later in list.iter().skip(i + 1) {
if matches!(later, Cmd::Barrier | Cmd::SetClip { .. }) {
break;
}
if !is_opaque_filler(later) {
continue;
}
let Some(bb_j) = later.aabb() else { continue };
if rect_contains(bb_j, bb_i) {
hit = true;
break;
}
}
hit
}
};
if occluded {
// Skip the cmd entirely. Don't flush pending — the next cmd
// may still coalesce with what's pending across this gap.
continue;
}
// Coalescing dispatch.
if let Cmd::FillRect { rect, color, blend } = cmd {
if let Some((prect, pcolor, pblend)) = pending.as_ref() {
if pcolor == color
&& pblend == blend
&& let Some(merged) = merge_rects_axis_aligned(*prect, *rect)
{
pending = Some((merged, *color, *blend));
continue;
}
// Can't merge — flush pending and start a new pending.
flush_pending(r, pending.take());
}
pending = Some((*rect, *color, *blend));
} else {
// Markers and non-FillRect cmds break the coalescing run.
flush_pending(r, pending.take());
cmd.dispatch_to(r);
}
}
flush_pending(r, pending.take());
}
#[inline]
fn flush_pending<B: Blitter, const N: usize>(
r: &mut BlitterRenderer<'_, B, N>,
pending: Option<(WidgetRect, Color, BlendMode)>,
) {
if let Some((rect, color, blend)) = pending {
Cmd::FillRect { rect, color, blend }.dispatch_to(r);
}
}
/// Try to merge two rectangles into a single rectangle representing
/// their union. Returns `Some(union)` only when one of the four
/// edge-adjacent cases applies; returns `None` for overlap, gap, or
/// L-shapes (which would require a multi-rect representation).
#[inline]
fn merge_rects_axis_aligned(a: WidgetRect, b: WidgetRect) -> Option<WidgetRect> {
if a.y == b.y && a.height == b.height {
if a.x + a.width == b.x {
return Some(WidgetRect {
x: a.x,
y: a.y,
width: a.width + b.width,
height: a.height,
});
}
if b.x + b.width == a.x {
return Some(WidgetRect {
x: b.x,
y: b.y,
width: a.width + b.width,
height: a.height,
});
}
}
if a.x == b.x && a.width == b.width {
if a.y + a.height == b.y {
return Some(WidgetRect {
x: a.x,
y: a.y,
width: a.width,
height: a.height + b.height,
});
}
if b.y + b.height == a.y {
return Some(WidgetRect {
x: b.x,
y: b.y,
width: a.width,
height: a.height + b.height,
});
}
}
None
}
#[inline]
fn is_opaque_filler(cmd: &Cmd) -> bool {
if let Cmd::FillRect { color, .. } = cmd {
color.3 == 255
} else {
false
}
}
#[inline]
fn rect_contains(outer: WidgetRect, inner: WidgetRect) -> bool {
outer.x <= inner.x
&& outer.y <= inner.y
&& outer.x + outer.width >= inner.x + inner.width
&& outer.y + outer.height >= inner.y + inner.height
}
/// Renderer wrapper that applies 90° CCW rotation for platforms where the
/// physical display is landscape but the framebuffer is portrait.
///
/// Maps logical coordinates (800×480 landscape) to framebuffer coordinates
/// (480×800 portrait):
/// fb_x = fb_width - logical_y - logical_height
/// fb_y = logical_x
/// fb_w = logical_height
/// fb_h = logical_width
pub struct RotatedRenderer<'a> {
inner: &'a mut dyn Renderer,
/// Portrait framebuffer width (the short dimension, e.g. 480).
fb_width: i32,
}
impl<'a> RotatedRenderer<'a> {
/// Create a rotated renderer wrapping `inner`.
///
/// `fb_width` is the portrait framebuffer width (480 on STM32H747I-DISCO).
pub fn new(inner: &'a mut dyn Renderer, fb_width: u32) -> Self {
Self {
inner,
fb_width: fb_width as i32,
}
}
/// FONT-04 §8.B: rotate a glyph's A8 coverage once into a bounded scratch
/// buffer and emit it as physical (portrait) rows through
/// `inner.blend_row`, instead of dispatching every coverage pixel through
/// the rotation as a 1×1 `blend_rect`.
///
/// `extent` is the glyph's tight bitmap rect in *landscape* coordinates.
/// The rotation mirrors [`Self::draw_pixels`] / the DMA2D
/// `draw_glyph_rotated` reference: landscape `(col,row)` →
/// `scratch[col*h + (h-1-row)]`, physical size `h` wide × `w` tall, placed
/// at `(fb_width - extent.y - h, extent.x)`. Because `inner.blend_row`
/// performs the same per-pixel source-over (`alpha = color.a·cov/255`) the
/// per-pixel path would, the rendered pixels are identical — this is a
/// throughput change only (§8.A).
///
/// Returns `false` when `font` has no coverage for `ch` (the caller falls
/// back to an extent rect), matching the core `draw_glyph` contract.
fn blit_glyph_coverage_rotated(
&mut self,
font: &dyn FontMetrics,
ch: char,
extent: WidgetRect,
color: Color,
) -> bool {
let w = extent.width;
let h = extent.height;
if w <= 0 || h <= 0 {
return true; // zero-area glyph (e.g. space) — nothing to draw
}
let (wu, hu) = (w as usize, h as usize);
// Bounded scratch (§8.C): no per-glyph heap in the render loop.
const BOUND: usize = 64 * 64;
if wu <= 64 && hu <= 64 && wu * hu <= BOUND {
// 2026-06-15 (FONT-04): A8 coverage scratch, sibling to the Color
// SCRATCH in `draw_pixels`. Same `.rlvgl_blit_scratch` placement so
// consumers' linker scripts keep it off the MSP stack-growth path
// (see the draw_pixels SCRATCH comment + disco ERRATA-005).
#[cfg_attr(target_os = "none", unsafe(link_section = ".rlvgl_blit_scratch"))]
static mut SCRATCH_COV: [u8; BOUND] = [0u8; BOUND]; // rlvgl-discipline: allow(static_mut)
// SAFETY: single-core, single-threaded — `RotatedRenderer` is used
// only from the main render loop, never an ISR. The scratch is
// unique to this call site, not borrowed across calls; we fully
// write the `[..wu*hu]` prefix before reading it back below.
let scratch = unsafe { &mut SCRATCH_COV[..wu * hu] };
// Gather each landscape coverage row and scatter it into the
// rotated (portrait) layout in one pass.
let mut row_buf = [0u8; 64];
for row in 0..hu {
let cov_row = &mut row_buf[..wu];
if !font.glyph_coverage_row(ch, row as u16, 0, cov_row) {
return false;
}
for (col, &cov) in cov_row.iter().enumerate() {
scratch[col * hu + (hu - 1 - row)] = cov;
}
}
// Physical placement mirrors `fill_rect`/`draw_pixels`.
let fb_x = self.fb_width - extent.y - h;
let fb_y = extent.x;
// Emit `w` physical rows of `h` coverage bytes each; inner clips x
// and blends source-over (preserving cov-0 holes).
for py in 0..wu {
let run = &scratch[py * hu..py * hu + hu];
self.inner.blend_row(fb_x, fb_y + py as i32, color, run);
}
true
} else {
// Oversize fallback: the correct per-pixel rotated path
// (`self.blend_row` default → rotated 1×1 `blend_rect`). Rare — the
// disco widget path draws no glyphs this large.
let mut chunk = [0u8; 64];
for row in 0..hu {
let mut x_off = 0usize;
while x_off < wu {
let n = (wu - x_off).min(chunk.len());
let part = &mut chunk[..n];
if !font.glyph_coverage_row(ch, row as u16, x_off as u16, part) {
return false;
}
self.blend_row(extent.x + x_off as i32, extent.y + row as i32, color, part);
x_off += n;
}
}
true
}
}
}
impl Renderer for RotatedRenderer<'_> {
fn fill_rect(&mut self, rect: WidgetRect, color: Color) {
let mut fb_x = self.fb_width - rect.y - rect.height;
let fb_y = rect.x;
let mut fb_w = rect.height;
let fb_h = rect.width;
if fb_w <= 0 || fb_h <= 0 {
return;
}
// Clamp left edge: rect extends off-screen left
if fb_x < 0 {
fb_w += fb_x; // shrink width by the overshoot
fb_x = 0;
}
// Clamp right edge
if fb_x + fb_w > self.fb_width {
fb_w = self.fb_width - fb_x;
}
if fb_w <= 0 {
return;
}
self.inner.fill_rect(
WidgetRect {
x: fb_x,
y: fb_y,
width: fb_w,
height: fb_h,
},
color,
);
}
fn blend_rect(&mut self, rect: WidgetRect, color: Color) {
let mut fb_x = self.fb_width - rect.y - rect.height;
let fb_y = rect.x;
let mut fb_w = rect.height;
let fb_h = rect.width;
if fb_w <= 0 || fb_h <= 0 {
return;
}
if fb_x < 0 {
fb_w += fb_x;
fb_x = 0;
}
if fb_x + fb_w > self.fb_width {
fb_w = self.fb_width - fb_x;
}
if fb_w <= 0 {
return;
}
self.inner.blend_rect(
WidgetRect {
x: fb_x,
y: fb_y,
width: fb_w,
height: fb_h,
},
color,
);
}
fn draw_text(&mut self, position: (i32, i32), text: &str, color: Color) {
let fx = self.fb_width - 1 - position.1;
if fx >= 0 {
self.inner.draw_text((fx, position.0), text, color);
}
}
fn draw_glyph(&mut self, font: &dyn FontMetrics, ch: char, origin: (i32, i32), color: Color) {
// FONT-04 §8.B: rotate the glyph's coverage once and blit rows through
// `inner.blend_row`, rather than the per-pixel `blend_rect` the
// trait-default `draw_glyph` → `blend_row` would dispatch on this
// rotated wrapper. `origin` is the baseline pen position (same anchor
// as the core default); derive the landscape extent from the metrics.
let Some(info) = font.glyph_metrics(ch) else {
return;
};
let extent = WidgetRect {
x: origin.0 + info.bearing_x as i32,
y: origin.1 - info.bearing_y as i32,
width: info.width as i32,
height: info.height as i32,
};
if extent.width <= 0 || extent.height <= 0 {
return;
}
if !self.blit_glyph_coverage_rotated(font, ch, extent, color) {
// No coverage for this glyph: deterministic extent rect (rotated),
// matching the core `draw_glyph` fallback.
self.blend_rect(extent, color);
}
}
fn draw_text_shaped(&mut self, shaped: &ShapedText<'_>, origin: (i32, i32), color: Color) {
// Mirror the core default's per-glyph structure, but route coverage
// through the rotate-then-blit helper (FONT-04 §8.B). Reached by
// callers that draw onto the rotated renderer without an intervening
// clip wrapper; clip-wrapped widgets (e.g. `Label`) still funnel
// through `blend_row` and are unaffected.
let font = shaped.font;
for glyph in &shaped.glyphs {
let mut extent = glyph.extent();
extent.x += origin.0;
extent.y += origin.1;
if extent.width <= 0 || extent.height <= 0 {
continue;
}
let drawn = match font {
Some(font) => self.blit_glyph_coverage_rotated(font, glyph.ch, extent, color),
None => false,
};
if !drawn {
self.blend_rect(extent, color);
}
}
}
fn draw_pixels(&mut self, position: (i32, i32), pixels: &[Color], width: u32, height: u32) {
// 2026-05-17: replace the per-pixel `fill_rect` slow path with a
// rotate-then-delegate pattern. The previous implementation made
// W*H calls to self.fill_rect (each a 1×1 logical rect) through
// the full rotation + clip + blitter pipeline. For a 60×60 icon
// that's 3600 single-pixel fill_rects per draw, and IconStrip
// draws 3 icons per frame — pinning CM7 inside the blitter for
// seconds at a time and making poll_joystick effectively
// unreachable (probe-rs halt evidence: 3 sequential halts ~1s
// apart all landed at byte-identical PC/LR/SP inside
// CpuBlitter::fill's row loop, called from this site).
//
// The inner `BlitterRenderer::draw_pixels` (line 617) already has
// an Argb8888 fast path that writes pixels directly into the
// surface buffer + adds one dirty rect — H+W work per call, no
// per-pixel fill_rect dispatch. Rotating the source buffer once
// (W*H copies) and calling inner.draw_pixels once collapses
// 3 × 60 × 60 = 10,800 fill_rect dispatches down to 3 fast blits.
if width == 0 || height == 0 {
return;
}
// 90° rotation mapping (mirrors `fill_rect` above):
// physical (fb_x, fb_y) = (fb_width - rect.y - rect.height, rect.x)
// physical (width, height) = (rect.height, rect.width)
let fb_x = self.fb_width - position.1 - height as i32;
let fb_y = position.0;
let phys_w = height; // physical width = logical height
let phys_h = width; // physical height = logical width
// Re-lay-out the pixel buffer in physical orientation.
// For each logical (lx, ly), the rotated buffer index is
// (lx * phys_w) + (height - 1 - ly).
//
// 2026-05-17 (second pass): use a static scratch buffer instead
// of allocating a Vec per call. The bench-9-snapshot setup
// draws ~10-14 icons per render through this path
// (IconStrip + Wing + spectrum overlay); at 9 Hz that was
// ~200 KiB/sec of alloc/free through the 64 KiB linked-list
// heap. After a few seconds of operation the heap fragments
// and a subsequent alloc panics — observed as a "lock up after
// navigating into the wing menu, recover via reset button"
// pattern.
//
// The scratch buffer is sized for the worst case we draw in
// practice (icons up to 64×64). If a caller requests a larger
// pixels rect, we fall back to allocating one Vec for that
// specific call — large icons are rare and the alloc still
// makes progress.
const SCRATCH_PIXELS: usize = 64 * 64;
// 2026-05-25 — Place SCRATCH in a named link section so consumers
// can map it to RAM that is NOT adjacent to MSP stack growth.
//
// Why this matters: on Cortex-M with cortex-m-rt's default link.x,
// MSP starts at `ORIGIN(RAM) + LENGTH(RAM)` and grows DOWN through
// `.bss`. This 16 KiB array (= `[Color; 64*64]` = 16384 bytes) in
// `.bss` ends up near MSP's growth path on boards with modest RAM.
// On STM32H747I-DISCO (DTCM = 128 KiB), the first render frame's
// call chain consumes ~14.5 KiB of MSP via the widget-tree walk,
// putting SP INSIDE this array. Inner-loop writes to `scratch[N]`
// for large enough N then overwrite the function's own stack
// frame — including the slice's fat pointer — leading to seemingly
// random hard faults at addresses that look unrelated to the bug.
//
// Consumers MUST add a SECTIONS block mapping `.rlvgl_blit_scratch`
// to a non-stack-adjacent RAM region in their linker script.
// Example for STM32H747 (place in D1 AXI SRAM):
//
// SECTIONS {
// .rlvgl_blit_scratch (NOLOAD) : ALIGN(4) {
// *(.rlvgl_blit_scratch .rlvgl_blit_scratch.*)
// } > D1_CM7
// } INSERT AFTER .uninit;
//
// Diagnosed in disco-analyzer ERRATA-005 bench-45 (2026-05-25):
// SCRATCH lived at DTCM 0x2001_A459..0x2001_E459; SP at fault was
// 0x2001_C5F8 (= inside the array); the slice's fat pointer slot
// at sp+176 = scratch[2196] was overwritten by an icon pixel and
// the next iteration's load of scratch.data_ptr returned the
// trampled bytes (0xFFFFFF59) — a precise data-bus error in the
// PPB region followed. Per-iteration capture of scratch.as_ptr()
// confirmed the corruption point matched the icon pixel pattern
// byte-for-byte.
// CRATES-CI-01: the ELF-style section name is only meaningful for
// the firmware linker script above; on Mach-O hosts (macOS dev
// boxes consuming rlvgl-platform from crates.io) it is rejected at
// LLVM codegen ("mach-o section specifier requires a segment").
// Gate the attribute to bare-metal targets so host builds place
// SCRATCH in .bss as usual.
#[cfg_attr(target_os = "none", unsafe(link_section = ".rlvgl_blit_scratch"))]
static mut SCRATCH: [Color; SCRATCH_PIXELS] = [Color(0, 0, 0, 0); SCRATCH_PIXELS]; // rlvgl-discipline: allow(static_mut)
let len = (width * height) as usize;
if len <= SCRATCH_PIXELS {
// SAFETY: single-core, single-threaded — `draw_pixels` is
// called only from the main render loop and not from any
// ISR. The scratch buffer is unique to this call site and
// not borrowed across calls.
let scratch = unsafe { &mut SCRATCH[..len] };
// Clear only the prefix we'll actually fill; pixels that
// aren't written (the `pixels.get(src_idx)` None branch)
// retain their prior value, but we touch every index in
// the inner loop so that's safe.
for ly in 0..height as i32 {
for lx in 0..width as i32 {
let src_idx = (ly as u32 * width + lx as u32) as usize;
let dst_idx = (lx as u32 * phys_w + (height as i32 - 1 - ly) as u32) as usize;
scratch[dst_idx] = pixels.get(src_idx).copied().unwrap_or(Color(0, 0, 0, 0));
}
}
self.inner
.draw_pixels((fb_x, fb_y), scratch, phys_w, phys_h);
} else {
// Oversize fallback: allocate once for this call. Rare.
let mut rotated: alloc::vec::Vec<Color> = alloc::vec::Vec::with_capacity(len);
rotated.resize(len, Color(0, 0, 0, 0));
for ly in 0..height as i32 {
for lx in 0..width as i32 {
let src_idx = (ly as u32 * width + lx as u32) as usize;
let dst_idx = (lx as u32 * phys_w + (height as i32 - 1 - ly) as u32) as usize;
if let Some(&c) = pixels.get(src_idx) {
rotated[dst_idx] = c;
}
}
}
self.inner
.draw_pixels((fb_x, fb_y), &rotated, phys_w, phys_h);
}
}
fn submit(&mut self, list: &CommandList) {
// Delegate to inner — preserves any backend-specific
// optimizations (e.g. BlitterRenderer's occlusion pre-pass)
// through the rotation wrapper.
self.inner.submit(list);
}
}
#[cfg(test)]
mod scratch_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
#[test]
fn blit_colors_reuses_scratch_buffer() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let pixels = [Color(0, 0, 0, 0)];
renderer.blit_colors((0, 0), &pixels, 1, 1);
let first_ptr = renderer.scratch.as_ref().unwrap().as_ptr();
renderer.blit_colors((1, 1), &pixels, 1, 1);
let second_ptr = renderer.scratch.as_ref().unwrap().as_ptr();
assert_eq!(first_ptr, second_ptr);
}
}
#[cfg(all(test, feature = "fontdue"))]
mod text_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
#[test]
fn blitter_draws_text() {
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
Renderer::draw_text(&mut renderer, (0, 32), "A", Color(255, 255, 255, 255));
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn cache_accounts_for_size() {
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_text((0, 32), "Hi", Color(255, 255, 255, 255), FONT_DATA, 16.0);
let len_after_small = renderer.glyph_cache.len();
renderer.draw_text((0, 32), "Hi", Color(255, 255, 255, 255), FONT_DATA, 16.0);
assert_eq!(len_after_small, renderer.glyph_cache.len());
renderer.draw_text((0, 32), "Hi", Color(255, 255, 255, 255), FONT_DATA, 24.0);
assert!(renderer.glyph_cache.len() > len_after_small);
}
}
#[cfg(all(test, feature = "png", not(target_os = "none")))]
mod png_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use base64::Engine;
use rlvgl_core::png::DecodingError;
const RED_DOT_PNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
#[test]
fn blitter_draws_png() {
let data = base64::engine::general_purpose::STANDARD
.decode(RED_DOT_PNG)
.unwrap();
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_png((0, 0), &data).unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_rejects_invalid_png() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let err = renderer.draw_png((0, 0), b"not a png").unwrap_err();
assert!(matches!(err, DecodingError::Format(_)));
}
}
#[cfg(all(test, feature = "jpeg", not(target_os = "none")))]
mod jpeg_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use base64::Engine;
use rlvgl_core::jpeg::Error as JpegError;
const RED_DOT_JPEG: &str = "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDi6KKK+ZP3E//Z";
#[test]
fn blitter_draws_jpeg() {
let data = base64::engine::general_purpose::STANDARD
.decode(RED_DOT_JPEG)
.unwrap();
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_jpeg((0, 0), &data).unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_rejects_invalid_jpeg() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let err = renderer.draw_jpeg((0, 0), b"not a jpeg").unwrap_err();
assert!(matches!(err, JpegError::Format(_)));
}
}
#[cfg(all(test, feature = "gif"))]
mod gif_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use base64::Engine;
use rlvgl_core::gif::DecodingError as GifDecodingError;
const RED_DOT_GIF: &str = "R0lGODdhAQABAPAAAP8AAP///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==";
#[test]
fn blitter_draws_gif() {
let data = base64::engine::general_purpose::STANDARD
.decode(RED_DOT_GIF)
.unwrap();
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_gif_frame((0, 0), &data, 0).unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_rejects_invalid_gif() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let err = renderer
.draw_gif_frame((0, 0), b"not a gif", 0)
.unwrap_err();
assert!(matches!(err, GifDecodingError::Format(_)));
}
}
#[cfg(all(test, feature = "apng"))]
mod apng_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use base64::Engine;
const RED_DOT_APNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACGFjVEwAAAABAAAAALQt6aAAAAAaZmNUTAAAAAAAAAABAAAAAQAAAAAAAAAAAGQD6AEAqmVSjAAAAA1JREFUeJxj+M/A8B8ABQAB/4mZPR0AAAAASUVORK5CYII=";
#[test]
fn blitter_draws_apng() {
let data = base64::engine::general_purpose::STANDARD
.decode(RED_DOT_APNG)
.unwrap();
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_apng_frame((0, 0), &data, 0).unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
}
#[cfg(all(test, feature = "canvas"))]
mod canvas_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use embedded_graphics::prelude::Point;
use rlvgl_core::canvas::Canvas;
#[test]
fn blitter_draws_canvas() {
let mut canvas = Canvas::new(1, 1);
canvas.draw_pixel(Point::new(0, 0), Color(255, 0, 0, 255));
let mut buf = [0u8; 4];
let surface = Surface::new(&mut buf, 4, PixelFmt::Argb8888, 1, 1);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_canvas((0, 0), &canvas);
assert!(buf.iter().any(|&p| p != 0));
}
}
#[cfg(all(test, feature = "qrcode", not(target_os = "none")))]
mod qrcode_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use rlvgl_core::qrcode::QrError;
#[test]
fn blitter_draws_qr() {
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_qr((0, 0), b"hi").unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_rejects_invalid_qr_data() {
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let data = vec![0u8; 3000];
let err = renderer.draw_qr((0, 0), &data).unwrap_err();
assert!(matches!(err, QrError::DataTooLong));
}
}
#[cfg(all(test, feature = "lottie"))]
mod lottie_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
const SIMPLE_JSON: &str =
"{\"v\":\"5.7\",\"fr\":30,\"ip\":0,\"op\":0,\"w\":1,\"h\":1,\"layers\":[]}";
#[test]
fn blitter_draws_lottie() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer
.draw_lottie_frame((0, 0), SIMPLE_JSON, 0, 1, 1)
.unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_rejects_invalid_lottie() {
let mut buf = [0u8; 4 * 4 * 4];
let surface = Surface::new(&mut buf, 4 * 4, PixelFmt::Argb8888, 4, 4);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
assert!(
renderer
.draw_lottie_frame((0, 0), "not json", 0, 1, 1)
.is_err()
);
}
}
#[cfg(all(test, feature = "pinyin", feature = "fontdue"))]
mod pinyin_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use rlvgl_core::pinyin::PinyinInputMethod;
#[test]
fn blitter_draws_pinyin() {
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let ime = PinyinInputMethod;
assert!(renderer.draw_pinyin_candidates((0, 0), &ime, "zhong", Color(255, 255, 255, 255)));
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn pinyin_candidates_clipped_to_surface() {
let mut buf = [0u8; 32 * 16 * 4];
let surface = Surface::new(&mut buf, 32 * 4, PixelFmt::Argb8888, 32, 16);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
let ime = PinyinInputMethod;
assert!(renderer.draw_pinyin_candidates((0, 0), &ime, "zhong", Color(255, 255, 255, 255)));
let mut expected = [0u8; 32 * 16 * 4];
let surface_e = Surface::new(&mut expected, 32 * 4, PixelFmt::Argb8888, 32, 16);
let mut blit_e = CpuBlitter;
let mut renderer_e: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit_e, surface_e);
let chars = ime.candidates("zhong").unwrap();
let text: alloc::string::String = chars.into_iter().collect();
let clipped: alloc::string::String = text.chars().take(2).collect();
Renderer::draw_text(&mut renderer_e, (0, 0), &clipped, Color(255, 255, 255, 255));
assert_eq!(buf[..], expected[..]);
}
}
#[cfg(all(test, feature = "fatfs", feature = "fontdue"))]
mod fatfs_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
use fatfs::{FileSystem, FormatVolumeOptions, FsOptions};
use fscommon::BufStream;
use std::io::{Cursor, Seek, SeekFrom, Write};
#[test]
fn blitter_draws_fatfs_listing() {
let mut img = Cursor::new(vec![0u8; 1024 * 512]);
fatfs::format_volume(&mut img, FormatVolumeOptions::new()).unwrap();
img.seek(SeekFrom::Start(0)).unwrap();
{
let buf_stream = BufStream::new(&mut img);
let fs = FileSystem::new(buf_stream, FsOptions::new()).unwrap();
fs.root_dir()
.create_file("foo.txt")
.unwrap()
.write_all(b"hi")
.unwrap();
}
img.seek(SeekFrom::Start(0)).unwrap();
let mut buf = [0u8; 64 * 64 * 4];
let surface = Surface::new(&mut buf, 64 * 4, PixelFmt::Argb8888, 64, 64);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer
.draw_fatfs_dir((0, 0), &mut img, "/", Color(255, 255, 255, 255))
.unwrap();
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn fatfs_listing_clipped_to_surface() {
let mut img = Cursor::new(vec![0u8; 1024 * 512]);
fatfs::format_volume(&mut img, FormatVolumeOptions::new()).unwrap();
img.seek(SeekFrom::Start(0)).unwrap();
{
let buf_stream = BufStream::new(&mut img);
let fs = FileSystem::new(buf_stream, FsOptions::new()).unwrap();
fs.root_dir().create_file("first_long_name.txt").unwrap();
fs.root_dir().create_file("second_long_name.txt").unwrap();
fs.root_dir().create_file("third_long_name.txt").unwrap();
}
img.seek(SeekFrom::Start(0)).unwrap();
let image_vec = img.get_ref().clone();
let mut img_expected = Cursor::new(image_vec.clone());
let mut img_actual = Cursor::new(image_vec);
let mut buf = [0u8; 32 * 32 * 4];
let surface = Surface::new(&mut buf, 32 * 4, PixelFmt::Argb8888, 32, 32);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer
.draw_fatfs_dir((0, 0), &mut img_actual, "/", Color(255, 255, 255, 255))
.unwrap();
let names = rlvgl_core::fatfs::list_dir(&mut img_expected, "/").unwrap();
let mut expected = [0u8; 32 * 32 * 4];
let surface_e = Surface::new(&mut expected, 32 * 4, PixelFmt::Argb8888, 32, 32);
let mut blit_e = CpuBlitter;
let mut renderer_e: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit_e, surface_e);
for (i, name) in names.iter().take(2).enumerate() {
let clipped: alloc::string::String = name.chars().take(2).collect();
Renderer::draw_text(
&mut renderer_e,
(0, (i as i32) * 16),
&clipped,
Color(255, 255, 255, 255),
);
}
assert_eq!(buf[..], expected[..]);
}
}
#[cfg(all(test, feature = "nes"))]
mod nes_tests {
use super::*;
use crate::cpu_blitter::CpuBlitter;
#[test]
fn blitter_draws_nes_frame() {
let pixels = [Color(255, 0, 0, 255)];
let mut buf = [0u8; 4];
let surface = Surface::new(&mut buf, 4, PixelFmt::Argb8888, 1, 1);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_nes_frame((0, 0), &pixels, 1, 1);
assert!(buf.iter().any(|&p| p != 0));
}
#[test]
fn blitter_draws_full_nes_frame() {
let mut pixels = [Color(0, 0, 0, 255); 256 * 240];
for y in 0..240 {
for x in 0..256 {
pixels[y * 256 + x] = Color(x as u8, y as u8, 0, 255);
}
}
let mut buf = [0u8; 256 * 240 * 4];
let surface = Surface::new(&mut buf, 256 * 4, PixelFmt::Argb8888, 256, 240);
let mut blit = CpuBlitter;
let mut renderer: BlitterRenderer<'_, CpuBlitter, 4> =
BlitterRenderer::new(&mut blit, surface);
renderer.draw_nes_frame((0, 0), &pixels, 256, 240);
let x = 128usize;
let y = 120usize;
let idx = (y * 256 + x) * 4;
let actual = u32::from_le_bytes(buf[idx..idx + 4].try_into().unwrap());
let expected = Color(x as u8, y as u8, 0, 255).to_argb8888();
assert_eq!(actual, expected);
}
}