github/esphome
2
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2026-10-06 02:51:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

[snapshot][SDL] Display headless mode and snapshots (#17917)

Browse Source 
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
This commit is contained in:
Clyde Stubbs
2026-09-03 09:39:32 +12:00
committed by GitHub
co-authored by Claude Opus 5 Jesse Hills
parent 567f7f9196
commit f0e2eb96bd
29 changed files with 1874 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files
esphome/components/sdl/__init__.py
+253
View File
@@ -1 +1,254 @@
import esphome.codegen as cg
CODEOWNERS = ["@clydebarrow"]
SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
SDL_KEYS = (
"SDLK_UNKNOWN",
"SDLK_RETURN",
"SDLK_ESCAPE",
"SDLK_BACKSPACE",
"SDLK_TAB",
"SDLK_SPACE",
"SDLK_EXCLAIM",
"SDLK_QUOTEDBL",
"SDLK_HASH",
"SDLK_PERCENT",
"SDLK_DOLLAR",
"SDLK_AMPERSAND",
"SDLK_QUOTE",
"SDLK_LEFTPAREN",
"SDLK_RIGHTPAREN",
"SDLK_ASTERISK",
"SDLK_PLUS",
"SDLK_COMMA",
"SDLK_MINUS",
"SDLK_PERIOD",
"SDLK_SLASH",
"SDLK_0",
"SDLK_1",
"SDLK_2",
"SDLK_3",
"SDLK_4",
"SDLK_5",
"SDLK_6",
"SDLK_7",
"SDLK_8",
"SDLK_9",
"SDLK_COLON",
"SDLK_SEMICOLON",
"SDLK_LESS",
"SDLK_EQUALS",
"SDLK_GREATER",
"SDLK_QUESTION",
"SDLK_AT",
"SDLK_LEFTBRACKET",
"SDLK_BACKSLASH",
"SDLK_RIGHTBRACKET",
"SDLK_CARET",
"SDLK_UNDERSCORE",
"SDLK_BACKQUOTE",
"SDLK_a",
"SDLK_b",
"SDLK_c",
"SDLK_d",
"SDLK_e",
"SDLK_f",
"SDLK_g",
"SDLK_h",
"SDLK_i",
"SDLK_j",
"SDLK_k",
"SDLK_l",
"SDLK_m",
"SDLK_n",
"SDLK_o",
"SDLK_p",
"SDLK_q",
"SDLK_r",
"SDLK_s",
"SDLK_t",
"SDLK_u",
"SDLK_v",
"SDLK_w",
"SDLK_x",
"SDLK_y",
"SDLK_z",
"SDLK_CAPSLOCK",
"SDLK_F1",
"SDLK_F2",
"SDLK_F3",
"SDLK_F4",
"SDLK_F5",
"SDLK_F6",
"SDLK_F7",
"SDLK_F8",
"SDLK_F9",
"SDLK_F10",
"SDLK_F11",
"SDLK_F12",
"SDLK_PRINTSCREEN",
"SDLK_SCROLLLOCK",
"SDLK_PAUSE",
"SDLK_INSERT",
"SDLK_HOME",
"SDLK_PAGEUP",
"SDLK_DELETE",
"SDLK_END",
"SDLK_PAGEDOWN",
"SDLK_RIGHT",
"SDLK_LEFT",
"SDLK_DOWN",
"SDLK_UP",
"SDLK_NUMLOCKCLEAR",
"SDLK_KP_DIVIDE",
"SDLK_KP_MULTIPLY",
"SDLK_KP_MINUS",
"SDLK_KP_PLUS",
"SDLK_KP_ENTER",
"SDLK_KP_1",
"SDLK_KP_2",
"SDLK_KP_3",
"SDLK_KP_4",
"SDLK_KP_5",
"SDLK_KP_6",
"SDLK_KP_7",
"SDLK_KP_8",
"SDLK_KP_9",
"SDLK_KP_0",
"SDLK_KP_PERIOD",
"SDLK_APPLICATION",
"SDLK_POWER",
"SDLK_KP_EQUALS",
"SDLK_F13",
"SDLK_F14",
"SDLK_F15",
"SDLK_F16",
"SDLK_F17",
"SDLK_F18",
"SDLK_F19",
"SDLK_F20",
"SDLK_F21",
"SDLK_F22",
"SDLK_F23",
"SDLK_F24",
"SDLK_EXECUTE",
"SDLK_HELP",
"SDLK_MENU",
"SDLK_SELECT",
"SDLK_STOP",
"SDLK_AGAIN",
"SDLK_UNDO",
"SDLK_CUT",
"SDLK_COPY",
"SDLK_PASTE",
"SDLK_FIND",
"SDLK_MUTE",
"SDLK_VOLUMEUP",
"SDLK_VOLUMEDOWN",
"SDLK_KP_COMMA",
"SDLK_KP_EQUALSAS400",
"SDLK_ALTERASE",
"SDLK_SYSREQ",
"SDLK_CANCEL",
"SDLK_CLEAR",
"SDLK_PRIOR",
"SDLK_RETURN2",
"SDLK_SEPARATOR",
"SDLK_OUT",
"SDLK_OPER",
"SDLK_CLEARAGAIN",
"SDLK_CRSEL",
"SDLK_EXSEL",
"SDLK_KP_00",
"SDLK_KP_000",
"SDLK_THOUSANDSSEPARATOR",
"SDLK_DECIMALSEPARATOR",
"SDLK_CURRENCYUNIT",
"SDLK_CURRENCYSUBUNIT",
"SDLK_KP_LEFTPAREN",
"SDLK_KP_RIGHTPAREN",
"SDLK_KP_LEFTBRACE",
"SDLK_KP_RIGHTBRACE",
"SDLK_KP_TAB",
"SDLK_KP_BACKSPACE",
"SDLK_KP_A",
"SDLK_KP_B",
"SDLK_KP_C",
"SDLK_KP_D",
"SDLK_KP_E",
"SDLK_KP_F",
"SDLK_KP_XOR",
"SDLK_KP_POWER",
"SDLK_KP_PERCENT",
"SDLK_KP_LESS",
"SDLK_KP_GREATER",
"SDLK_KP_AMPERSAND",
"SDLK_KP_DBLAMPERSAND",
"SDLK_KP_VERTICALBAR",
"SDLK_KP_DBLVERTICALBAR",
"SDLK_KP_COLON",
"SDLK_KP_HASH",
"SDLK_KP_SPACE",
"SDLK_KP_AT",
"SDLK_KP_EXCLAM",
"SDLK_KP_MEMSTORE",
"SDLK_KP_MEMRECALL",
"SDLK_KP_MEMCLEAR",
"SDLK_KP_MEMADD",
"SDLK_KP_MEMSUBTRACT",
"SDLK_KP_MEMMULTIPLY",
"SDLK_KP_MEMDIVIDE",
"SDLK_KP_PLUSMINUS",
"SDLK_KP_CLEAR",
"SDLK_KP_CLEARENTRY",
"SDLK_KP_BINARY",
"SDLK_KP_OCTAL",
"SDLK_KP_DECIMAL",
"SDLK_KP_HEXADECIMAL",
"SDLK_LCTRL",
"SDLK_LSHIFT",
"SDLK_LALT",
"SDLK_LGUI",
"SDLK_RCTRL",
"SDLK_RSHIFT",
"SDLK_RALT",
"SDLK_RGUI",
"SDLK_MODE",
"SDLK_AUDIONEXT",
"SDLK_AUDIOPREV",
"SDLK_AUDIOSTOP",
"SDLK_AUDIOPLAY",
"SDLK_AUDIOMUTE",
"SDLK_MEDIASELECT",
"SDLK_WWW",
"SDLK_MAIL",
"SDLK_CALCULATOR",
"SDLK_COMPUTER",
"SDLK_AC_SEARCH",
"SDLK_AC_HOME",
"SDLK_AC_BACK",
"SDLK_AC_FORWARD",
"SDLK_AC_STOP",
"SDLK_AC_REFRESH",
"SDLK_AC_BOOKMARKS",
"SDLK_BRIGHTNESSDOWN",
"SDLK_BRIGHTNESSUP",
"SDLK_DISPLAYSWITCH",
"SDLK_KBDILLUMTOGGLE",
"SDLK_KBDILLUMDOWN",
"SDLK_KBDILLUMUP",
"SDLK_EJECT",
"SDLK_SLEEP",
"SDLK_APP1",
"SDLK_APP2",
"SDLK_AUDIOREWIND",
"SDLK_AUDIOFASTFORWARD",
"SDLK_SOFTLEFT",
"SDLK_SOFTRIGHT",
"SDLK_CALL",
"SDLK_ENDCALL",
)
SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
esphome/components/sdl/binary_sensor.py
+3 -250
View File
@@ -7,262 +7,15 @@ from esphome.core import Lambda
from esphome.cpp_generator import ExpressionStatement, RawExpression
from esphome.types import ConfigType
from .display import CONF_SDL_ID, Sdl
from . import SDL_KEYMAP
from .display import CONF_SDL_ID, Sdl, headless_final_validate
CODEOWNERS = ["@bdm310"]
STATE_ARG = "state"
SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
FINAL_VALIDATE_SCHEMA = headless_final_validate("binary_sensor")
SDL_KEYS = (
"SDLK_UNKNOWN",
"SDLK_RETURN",
"SDLK_ESCAPE",
"SDLK_BACKSPACE",
"SDLK_TAB",
"SDLK_SPACE",
"SDLK_EXCLAIM",
"SDLK_QUOTEDBL",
"SDLK_HASH",
"SDLK_PERCENT",
"SDLK_DOLLAR",
"SDLK_AMPERSAND",
"SDLK_QUOTE",
"SDLK_LEFTPAREN",
"SDLK_RIGHTPAREN",
"SDLK_ASTERISK",
"SDLK_PLUS",
"SDLK_COMMA",
"SDLK_MINUS",
"SDLK_PERIOD",
"SDLK_SLASH",
"SDLK_0",
"SDLK_1",
"SDLK_2",
"SDLK_3",
"SDLK_4",
"SDLK_5",
"SDLK_6",
"SDLK_7",
"SDLK_8",
"SDLK_9",
"SDLK_COLON",
"SDLK_SEMICOLON",
"SDLK_LESS",
"SDLK_EQUALS",
"SDLK_GREATER",
"SDLK_QUESTION",
"SDLK_AT",
"SDLK_LEFTBRACKET",
"SDLK_BACKSLASH",
"SDLK_RIGHTBRACKET",
"SDLK_CARET",
"SDLK_UNDERSCORE",
"SDLK_BACKQUOTE",
"SDLK_a",
"SDLK_b",
"SDLK_c",
"SDLK_d",
"SDLK_e",
"SDLK_f",
"SDLK_g",
"SDLK_h",
"SDLK_i",
"SDLK_j",
"SDLK_k",
"SDLK_l",
"SDLK_m",
"SDLK_n",
"SDLK_o",
"SDLK_p",
"SDLK_q",
"SDLK_r",
"SDLK_s",
"SDLK_t",
"SDLK_u",
"SDLK_v",
"SDLK_w",
"SDLK_x",
"SDLK_y",
"SDLK_z",
"SDLK_CAPSLOCK",
"SDLK_F1",
"SDLK_F2",
"SDLK_F3",
"SDLK_F4",
"SDLK_F5",
"SDLK_F6",
"SDLK_F7",
"SDLK_F8",
"SDLK_F9",
"SDLK_F10",
"SDLK_F11",
"SDLK_F12",
"SDLK_PRINTSCREEN",
"SDLK_SCROLLLOCK",
"SDLK_PAUSE",
"SDLK_INSERT",
"SDLK_HOME",
"SDLK_PAGEUP",
"SDLK_DELETE",
"SDLK_END",
"SDLK_PAGEDOWN",
"SDLK_RIGHT",
"SDLK_LEFT",
"SDLK_DOWN",
"SDLK_UP",
"SDLK_NUMLOCKCLEAR",
"SDLK_KP_DIVIDE",
"SDLK_KP_MULTIPLY",
"SDLK_KP_MINUS",
"SDLK_KP_PLUS",
"SDLK_KP_ENTER",
"SDLK_KP_1",
"SDLK_KP_2",
"SDLK_KP_3",
"SDLK_KP_4",
"SDLK_KP_5",
"SDLK_KP_6",
"SDLK_KP_7",
"SDLK_KP_8",
"SDLK_KP_9",
"SDLK_KP_0",
"SDLK_KP_PERIOD",
"SDLK_APPLICATION",
"SDLK_POWER",
"SDLK_KP_EQUALS",
"SDLK_F13",
"SDLK_F14",
"SDLK_F15",
"SDLK_F16",
"SDLK_F17",
"SDLK_F18",
"SDLK_F19",
"SDLK_F20",
"SDLK_F21",
"SDLK_F22",
"SDLK_F23",
"SDLK_F24",
"SDLK_EXECUTE",
"SDLK_HELP",
"SDLK_MENU",
"SDLK_SELECT",
"SDLK_STOP",
"SDLK_AGAIN",
"SDLK_UNDO",
"SDLK_CUT",
"SDLK_COPY",
"SDLK_PASTE",
"SDLK_FIND",
"SDLK_MUTE",
"SDLK_VOLUMEUP",
"SDLK_VOLUMEDOWN",
"SDLK_KP_COMMA",
"SDLK_KP_EQUALSAS400",
"SDLK_ALTERASE",
"SDLK_SYSREQ",
"SDLK_CANCEL",
"SDLK_CLEAR",
"SDLK_PRIOR",
"SDLK_RETURN2",
"SDLK_SEPARATOR",
"SDLK_OUT",
"SDLK_OPER",
"SDLK_CLEARAGAIN",
"SDLK_CRSEL",
"SDLK_EXSEL",
"SDLK_KP_00",
"SDLK_KP_000",
"SDLK_THOUSANDSSEPARATOR",
"SDLK_DECIMALSEPARATOR",
"SDLK_CURRENCYUNIT",
"SDLK_CURRENCYSUBUNIT",
"SDLK_KP_LEFTPAREN",
"SDLK_KP_RIGHTPAREN",
"SDLK_KP_LEFTBRACE",
"SDLK_KP_RIGHTBRACE",
"SDLK_KP_TAB",
"SDLK_KP_BACKSPACE",
"SDLK_KP_A",
"SDLK_KP_B",
"SDLK_KP_C",
"SDLK_KP_D",
"SDLK_KP_E",
"SDLK_KP_F",
"SDLK_KP_XOR",
"SDLK_KP_POWER",
"SDLK_KP_PERCENT",
"SDLK_KP_LESS",
"SDLK_KP_GREATER",
"SDLK_KP_AMPERSAND",
"SDLK_KP_DBLAMPERSAND",
"SDLK_KP_VERTICALBAR",
"SDLK_KP_DBLVERTICALBAR",
"SDLK_KP_COLON",
"SDLK_KP_HASH",
"SDLK_KP_SPACE",
"SDLK_KP_AT",
"SDLK_KP_EXCLAM",
"SDLK_KP_MEMSTORE",
"SDLK_KP_MEMRECALL",
"SDLK_KP_MEMCLEAR",
"SDLK_KP_MEMADD",
"SDLK_KP_MEMSUBTRACT",
"SDLK_KP_MEMMULTIPLY",
"SDLK_KP_MEMDIVIDE",
"SDLK_KP_PLUSMINUS",
"SDLK_KP_CLEAR",
"SDLK_KP_CLEARENTRY",
"SDLK_KP_BINARY",
"SDLK_KP_OCTAL",
"SDLK_KP_DECIMAL",
"SDLK_KP_HEXADECIMAL",
"SDLK_LCTRL",
"SDLK_LSHIFT",
"SDLK_LALT",
"SDLK_LGUI",
"SDLK_RCTRL",
"SDLK_RSHIFT",
"SDLK_RALT",
"SDLK_RGUI",
"SDLK_MODE",
"SDLK_AUDIONEXT",
"SDLK_AUDIOPREV",
"SDLK_AUDIOSTOP",
"SDLK_AUDIOPLAY",
"SDLK_AUDIOMUTE",
"SDLK_MEDIASELECT",
"SDLK_WWW",
"SDLK_MAIL",
"SDLK_CALCULATOR",
"SDLK_COMPUTER",
"SDLK_AC_SEARCH",
"SDLK_AC_HOME",
"SDLK_AC_BACK",
"SDLK_AC_FORWARD",
"SDLK_AC_STOP",
"SDLK_AC_REFRESH",
"SDLK_AC_BOOKMARKS",
"SDLK_BRIGHTNESSDOWN",
"SDLK_BRIGHTNESSUP",
"SDLK_DISPLAYSWITCH",
"SDLK_KBDILLUMTOGGLE",
"SDLK_KBDILLUMDOWN",
"SDLK_KBDILLUMUP",
"SDLK_EJECT",
"SDLK_SLEEP",
"SDLK_APP1",
"SDLK_APP2",
"SDLK_AUDIOREWIND",
"SDLK_AUDIOFASTFORWARD",
"SDLK_SOFTLEFT",
"SDLK_SOFTRIGHT",
"SDLK_CALL",
"SDLK_ENDCALL",
)
SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
CONFIG_SCHEMA = (
binary_sensor.binary_sensor_schema(BinarySensor)
esphome/components/sdl/display.py
+52 -1
View File
@@ -4,6 +4,7 @@ from typing import Any
import esphome.codegen as cg
from esphome.components import display
from esphome.components.snapshot import Snapshot, register_snapshot
import esphome.config_validation as cv
from esphome.const import (
CONF_DIMENSIONS,
@@ -16,14 +17,21 @@ from esphome.const import (
CONF_Y,
PLATFORM_HOST,
)
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import SDL_KEYMAP
AUTO_LOAD = ["snapshot"]
sdl_ns = cg.esphome_ns.namespace("sdl")
Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component, Snapshot)
sdl_window_flags = cg.global_ns.enum("SDL_WindowFlags")
CONF_CENTERED_ON_DISPLAY = "centered_on_display"
CONF_HEADLESS = "headless"
CONF_SNAPSHOT_KEY = "snapshot_key"
CONF_SDL_OPTIONS = "sdl_options"
CONF_SDL_ID = "sdl_id"
CONF_WINDOW_OPTIONS = "window_options"
@@ -67,12 +75,29 @@ def _validate_position(config: dict) -> dict:
raise cv.Invalid("Must specify either 'x' and 'y' or 'centered_on_display'")
def _validate_headless(config: ConfigType) -> ConfigType:
if not config[CONF_HEADLESS]:
return config
if CONF_WINDOW_OPTIONS in config:
raise cv.Invalid(
f"'{CONF_WINDOW_OPTIONS}' has no effect when '{CONF_HEADLESS}' is set - there is no window"
)
if CONF_SNAPSHOT_KEY in config:
raise cv.Invalid(
f"'{CONF_SNAPSHOT_KEY}' cannot be used when '{CONF_HEADLESS}' is set - "
f"there is no keyboard. Use the 'snapshot.take' action instead"
)
return config
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(Sdl),
cv.Optional(CONF_SDL_OPTIONS, default=""): get_sdl_options,
cv.Optional(CONF_HEADLESS, default=False): cv.boolean,
cv.Optional(CONF_SNAPSHOT_KEY): cv.enum(SDL_KEYMAP),
cv.Required(CONF_DIMENSIONS): cv.Any(
cv.dimensions,
cv.Schema(
@@ -99,16 +124,42 @@ CONFIG_SCHEMA = cv.All(
}
)
),
_validate_headless,
cv.only_on(PLATFORM_HOST),
)
def headless_final_validate(platform: str) -> cv.Schema:
"""Build a FINAL_VALIDATE_SCHEMA rejecting a platform whose sdl display is headless.
Mouse and keyboard platforms are driven by window events, so under a headless display they
would never report anything.
"""
def validate_display(display_config: ConfigType) -> ConfigType:
if display_config.get(CONF_HEADLESS):
raise cv.Invalid(
f"The sdl {platform} platform needs a window, but its display has "
f"'{CONF_HEADLESS}' set"
)
return display_config
return cv.Schema(
{cv.Required(CONF_SDL_ID): fv.id_declaration_match_schema(validate_display)},
extra=cv.ALLOW_EXTRA,
)
async def to_code(config: ConfigType) -> None:
for option in config[CONF_SDL_OPTIONS].split():
cg.add_build_flag(option)
cg.add_build_flag("-DSDL_BYTEORDER=4321")
var = cg.new_Pvariable(config[CONF_ID])
await display.register_display(var, config)
await register_snapshot(var, config)
cg.add(var.set_headless(config[CONF_HEADLESS]))
if (key := config.get(CONF_SNAPSHOT_KEY)) is not None:
cg.add(var.set_snapshot_key(key))
dimensions = config[CONF_DIMENSIONS]
if isinstance(dimensions, dict):
esphome/components/sdl/sdl_esphome.cpp
+228 -46
View File
@@ -2,8 +2,17 @@
#include "sdl_esphome.h"
#include "esphome/components/display/display_color_utils.h"
#include <cstdlib>
namespace esphome::sdl {
namespace {
// Key under which each window keeps a pointer back to its Sdl instance.
constexpr const char *const WINDOW_DATA_KEY = "esphome_sdl";
} // namespace
int Sdl::get_width() {
switch (this->rotation_) {
case display::DISPLAY_ROTATION_90_DEGREES:
@@ -28,17 +37,96 @@ int Sdl::get_height() {
}
}
void Sdl::setup() {
SDL_Init(SDL_INIT_VIDEO);
this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
this->window_options_);
this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
void Sdl::destroy_renderer_() {
// Reverse order of creation: the renderer refers to the window or surface it was made from.
if (this->shot_target_ != nullptr) {
SDL_DestroyTexture(this->shot_target_);
this->shot_target_ = nullptr;
}
if (this->texture_ != nullptr) {
SDL_DestroyTexture(this->texture_);
this->texture_ = nullptr;
}
if (this->renderer_ != nullptr) {
SDL_DestroyRenderer(this->renderer_);
this->renderer_ = nullptr;
}
if (this->window_ != nullptr) {
SDL_DestroyWindow(this->window_);
this->window_ = nullptr;
}
if (this->surface_ != nullptr) {
SDL_FreeSurface(this->surface_);
this->surface_ = nullptr;
}
}
bool Sdl::setup_failed_(const char *what) {
ESP_LOGE(TAG, "%s: %s", what, SDL_GetError());
// Give back whatever was created before the failure. Without this a half set up display leaves an
// empty window on screen for the life of the process, still registered as an event target.
this->destroy_renderer_();
return false;
}
bool Sdl::setup_renderer_() {
SDL_SetMainReady();
if (this->headless_) {
// SDL_INIT_VIDEO is deliberately not requested: a software renderer bound to a surface needs no
// video device, so this works on a machine with no display server at all.
if (SDL_Init(0) != 0)
return this->setup_failed_("SDL_Init failed");
this->surface_ = SDL_CreateRGBSurfaceWithFormat(0, this->width_, this->height_, 16, SDL_PIXELFORMAT_RGB565);
if (this->surface_ == nullptr)
return this->setup_failed_("Could not create offscreen surface");
this->renderer_ = SDL_CreateSoftwareRenderer(this->surface_);
} else {
if (SDL_Init(SDL_INIT_VIDEO) != 0)
return this->setup_failed_("SDL_Init failed");
this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
this->window_options_);
if (this->window_ == nullptr)
return this->setup_failed_("Could not create window");
// Lets loop() find the display an event belongs to, so one display does not act on another's
// input when several windows are open.
SDL_SetWindowData(this->window_, WINDOW_DATA_KEY, this);
this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
}
if (this->renderer_ == nullptr)
return this->setup_failed_("Could not create renderer");
if (SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_) != 0)
return this->setup_failed_("Could not set renderer logical size");
this->texture_ =
SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
if (this->texture_ == nullptr)
return this->setup_failed_("Could not create texture");
// The texture has no alpha channel, so blending is pointless. Headless it would also force a
// different software blit path onto the 16 bit target surface.
if (SDL_SetTextureBlendMode(this->texture_, this->headless_ ? SDL_BLENDMODE_NONE : SDL_BLENDMODE_BLEND) != 0)
return this->setup_failed_("Could not set texture blend mode");
return true;
}
void Sdl::setup() {
if (!this->setup_renderer_()) {
this->mark_failed();
return;
}
if (this->headless_) {
// Nothing generates events, so there is nothing for loop() to do.
this->disable_loop();
} else if (this->snapshot_key_ != 0) {
this->add_key_listener(this->snapshot_key_, [this](bool down) {
if (down && !this->take_snapshot(nullptr)) {
ESP_LOGW(TAG, "snapshot key did not write a file");
}
});
}
}
void Sdl::update() {
if (this->texture_ == nullptr)
return;
this->do_update_();
if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_))
return;
@@ -51,12 +139,19 @@ void Sdl::update() {
}
void Sdl::redraw_(SDL_Rect &rect) {
// Nothing to present when headless - a snapshot blits the whole texture when it needs it, so
// doing it here as well would just burn CPU. draw_pixels_at() calls this on every partial
// update, so it is worth skipping.
if (this->headless_)
return;
SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
SDL_RenderPresent(this->renderer_);
}
void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
if (this->texture_ == nullptr)
return;
SDL_Rect rect{x_start, y_start, w, h};
if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || big_endian) {
Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
@@ -69,7 +164,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
}
void Sdl::draw_pixel_at(int x, int y, Color color) {
if (!this->get_clipping().inside(x, y))
if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
return;
if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
@@ -104,61 +199,148 @@ void Sdl::process_key(uint32_t keycode, bool down) {
callback->second(down);
}
Sdl *Sdl::instance_for_window_(uint32_t window_id) {
SDL_Window *window = SDL_GetWindowFromID(window_id);
if (window == nullptr)
return nullptr;
return static_cast<Sdl *>(SDL_GetWindowData(window, WINDOW_DATA_KEY));
}
void Sdl::handle_event_(const SDL_Event &event) {
switch (event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (event.button.button == 1) {
this->mouse_x = event.button.x;
this->mouse_y = event.button.y;
this->mouse_down = event.button.state != 0;
}
break;
case SDL_MOUSEMOTION:
if (event.motion.state & 1) {
this->mouse_x = event.motion.x;
this->mouse_y = event.motion.y;
this->mouse_down = true;
} else {
this->mouse_down = false;
}
break;
case SDL_KEYDOWN:
// Ignore auto-repeat, otherwise holding a key floods the listeners.
if (event.key.repeat != 0)
break;
ESP_LOGD(TAG, "keydown %d", event.key.keysym.sym);
this->process_key(event.key.keysym.sym, true);
break;
case SDL_KEYUP:
ESP_LOGD(TAG, "keyup %d", event.key.keysym.sym);
this->process_key(event.key.keysym.sym, false);
break;
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
case SDL_WINDOWEVENT_EXPOSED:
case SDL_WINDOWEVENT_RESIZED: {
SDL_Rect rect{0, 0, this->width_, this->height_};
this->redraw_(rect);
break;
}
default:
break;
}
break;
default:
break;
}
}
void Sdl::loop() {
SDL_Event e;
if (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_QUIT:
exit(0);
// Take everything that is waiting, not one event per loop. A touch drag produces a burst of
// motion events, and consuming them one at a time lets the queue grow without bound, so the
// pointer ends up acting on input from further and further in the past. Draining collapses a
// burst to the position it ended at, which is the one the user is asking for anyway.
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT)
exit(0);
// Events carry the window they happened in, so send each one to the display that owns it.
uint32_t window_id;
switch (e.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (e.button.button == 1) {
this->mouse_x = e.button.x;
this->mouse_y = e.button.y;
this->mouse_down = e.button.state != 0;
}
window_id = e.button.windowID;
break;
case SDL_MOUSEMOTION:
if (e.motion.state & 1) {
this->mouse_x = e.button.x;
this->mouse_y = e.button.y;
this->mouse_down = true;
} else {
this->mouse_down = false;
}
window_id = e.motion.windowID;
break;
case SDL_KEYDOWN:
ESP_LOGD(TAG, "keydown %d", e.key.keysym.sym);
this->process_key(e.key.keysym.sym, true);
break;
case SDL_KEYUP:
ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
this->process_key(e.key.keysym.sym, false);
window_id = e.key.windowID;
break;
case SDL_WINDOWEVENT:
switch (e.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
case SDL_WINDOWEVENT_EXPOSED:
case SDL_WINDOWEVENT_RESIZED: {
SDL_Rect rect{0, 0, this->width_, this->height_};
this->redraw_(rect);
break;
}
default:
break;
}
window_id = e.window.windowID;
break;
default:
// Anything else, including the touch events SDL reports alongside the mouse events it
// synthesises from them, is not used here.
ESP_LOGV(TAG, "Event %d", e.type);
break;
continue;
}
Sdl *target = instance_for_window_(window_id);
if (target == nullptr) {
// Nothing to route this to: the window has gone, or it is not one of ours. Say so, otherwise
// input that stops working leaves no trace at all.
ESP_LOGV(TAG, "Event %d for unknown window %u", e.type, window_id);
continue;
}
target->handle_event_(e);
}
}
bool Sdl::capture_bgr(uint8_t *dest, size_t row_stride) {
if (this->texture_ == nullptr || this->renderer_ == nullptr) {
ESP_LOGE(TAG, "Snapshot requested but SDL is not set up");
return false;
}
if (this->shot_target_ == nullptr) {
this->shot_target_ = SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_TARGET,
this->width_, this->height_);
if (this->shot_target_ == nullptr) {
ESP_LOGE(TAG, "Could not create capture texture: %s", SDL_GetError());
return false;
}
SDL_SetTextureBlendMode(this->shot_target_, SDL_BLENDMODE_NONE);
}
// Render into an offscreen target first. SDL_RenderReadPixels works in physical output pixels and
// ignores the logical size, so reading straight off a resizable window would read more pixels than
// there is room for.
// Every step is checked: a failed clear or copy would otherwise be read back as a blank or stale
// picture, written out, and reported as a snapshot that worked.
bool ok = false;
if (SDL_SetRenderTarget(this->renderer_, this->shot_target_) == 0) {
ok = SDL_SetRenderDrawColor(this->renderer_, 0, 0, 0, SDL_ALPHA_OPAQUE) == 0 &&
SDL_RenderClear(this->renderer_) == 0 &&
SDL_RenderCopy(this->renderer_, this->texture_, nullptr, nullptr) == 0 &&
SDL_RenderReadPixels(this->renderer_, nullptr, SDL_PIXELFORMAT_BGR24, dest, static_cast<int>(row_stride)) == 0;
if (SDL_SetRenderTarget(this->renderer_, nullptr) != 0) {
// Stuck rendering into shot_target_ from here on, so there's no point continuing.
ESP_LOGE(TAG, "Could not restore the render target: %s", SDL_GetError());
this->mark_failed();
return false;
}
}
if (!ok) {
ESP_LOGE(TAG, "Could not capture the screen: %s", SDL_GetError());
}
return ok;
}
} // namespace esphome::sdl
esphome/components/sdl/sdl_esphome.h
+30 -5
View File
@@ -1,10 +1,12 @@
#pragma once
#ifdef USE_HOST
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
#include "esphome/components/display/display.h"
#include "esphome/components/snapshot/snapshot.h"
#define SDL_MAIN_HANDLED
#include "SDL.h"
#include <map>
@@ -13,7 +15,7 @@ namespace esphome::sdl {
constexpr static const char *const TAG = "sdl";
class Sdl final : public display::Display {
class Sdl final : public display::Display, public snapshot::Snapshot {
public:
display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
void update() override;
@@ -32,6 +34,9 @@ class Sdl final : public display::Display {
this->pos_x_ = pos_x;
this->pos_y_ = pos_y;
}
void set_headless(bool headless) { this->headless_ = headless; }
void set_snapshot_key(int32_t keycode) { this->snapshot_key_ = keycode; }
int get_width() override;
int get_height() override;
float get_setup_priority() const override { return setup_priority::HARDWARE; }
@@ -51,20 +56,40 @@ class Sdl final : public display::Display {
int get_width_internal() override { return this->width_; }
int get_height_internal() override { return this->height_; }
void redraw_(SDL_Rect &rect);
bool setup_renderer_();
/// Release the window, surface, renderer and textures, and forget them.
void destroy_renderer_();
/// Log an SDL failure during setup, release anything already created, and return false.
bool setup_failed_(const char *what);
int snapshot_width() override { return this->width_; }
int snapshot_height() override { return this->height_; }
bool capture_bgr(uint8_t *dest, size_t row_stride) override;
void handle_event_(const SDL_Event &event);
/// The display owning the given window, or nullptr if it is not one of ours.
static Sdl *instance_for_window_(uint32_t window_id);
SDL_Renderer *renderer_{};
SDL_Window *window_{};
SDL_Texture *texture_{};
// Offscreen render target used when headless. SDL_CreateSoftwareRenderer only borrows the
// surface, and the renderer goes back to using it as its output whenever the capture target is
// released, so it has to stay alive as long as the renderer does.
SDL_Surface *surface_{};
// Capture target, created on first snapshot.
SDL_Texture *shot_target_{};
std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
int width_{};
int height_{};
uint32_t window_options_{0};
int32_t pos_x_{SDL_WINDOWPOS_UNDEFINED};
int32_t pos_y_{SDL_WINDOWPOS_UNDEFINED};
SDL_Renderer *renderer_{};
SDL_Window *window_{};
SDL_Texture *texture_{};
int32_t snapshot_key_{0};
uint16_t x_low_{0};
uint16_t y_low_{0};
uint16_t x_high_{0};
uint16_t y_high_{0};
std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
bool headless_{false};
};
} // namespace esphome::sdl
#endif
esphome/components/sdl/touchscreen/__init__.py
+3 -1
View File
@@ -4,10 +4,12 @@ import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.types import ConfigType
from ..display import CONF_SDL_ID, Sdl, sdl_ns
from ..display import CONF_SDL_ID, Sdl, headless_final_validate, sdl_ns
SdlTouchscreen = sdl_ns.class_("SdlTouchscreen", touchscreen.Touchscreen)
FINAL_VALIDATE_SCHEMA = headless_final_validate("touchscreen")
CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
{
esphome/components/snapshot/__init__.py
+76
View File
@@ -0,0 +1,76 @@
"""Shared support for writing what a display is showing out to an image file.
The component itself has no configuration. It provides the ``snapshot.take`` action and the C++
base class behind it, so any display that can hand over its pixels - the in memory display in this
component, or an SDL window - saves files the same way, under the same directory, with the same
rules about names.
"""
from dataclasses import dataclass
from esphome import automation
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.core import CORE, ID
from esphome.cpp_generator import MockObj
from esphome.types import ConfigType, TemplateArgsType
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "snapshot"
CONF_FILENAME = "filename"
snapshot_ns = cg.esphome_ns.namespace("snapshot")
Snapshot = snapshot_ns.class_("Snapshot")
SnapshotAction = snapshot_ns.class_("SnapshotAction", automation.Action)
@automation.register_action(
"snapshot.take",
SnapshotAction,
automation.maybe_simple_id(
{
cv.GenerateID(): cv.use_id(Snapshot),
cv.Optional(CONF_FILENAME): cv.templatable(cv.string),
}
),
synchronous=True,
)
async def snapshot_take_to_code(
config: ConfigType,
action_id: ID,
template_arg: cg.TemplateArguments,
args: TemplateArgsType,
) -> MockObj:
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
if (filename := config.get(CONF_FILENAME)) is not None:
cg.add(var.set_filename(await cg.templatable(filename, args, cg.std_string)))
return var
@dataclass
class SnapshotData:
directory_defined: bool = False
def _get_data() -> SnapshotData:
if DOMAIN not in CORE.data:
CORE.data[DOMAIN] = SnapshotData()
return CORE.data[DOMAIN]
async def register_snapshot(var: MockObj, config: ConfigType) -> None:
"""Set up a component so that the snapshot action can write its picture to a file."""
data = _get_data()
# Only once, however many displays there are: two defines that say the same thing do not
# compare equal, so asking for this per display repeats the line in defines.h.
if not data.directory_defined:
data.directory_defined = True
cg.add_define(
"ESPHOME_SNAPSHOT_DIR",
(CORE.data_dir / "snapshots" / CORE.name).as_posix(),
)
cg.add(var.set_snapshot_prefix(str(config[CONF_ID])))
esphome/components/snapshot/display/__init__.py
+61
View File
@@ -0,0 +1,61 @@
import esphome.codegen as cg
from esphome.components import display
import esphome.config_validation as cv
from esphome.const import (
CONF_DIMENSIONS,
CONF_HEIGHT,
CONF_ID,
CONF_LAMBDA,
CONF_WIDTH,
PLATFORM_HOST,
)
from esphome.types import ConfigType
from .. import Snapshot, register_snapshot, snapshot_ns
# The base class and the file writing live in the parent component, which nothing else in a
# configuration using only this platform would pull in.
AUTO_LOAD = ["snapshot"]
SnapshotDisplay = snapshot_ns.class_(
"SnapshotDisplay", display.DisplayBuffer, cg.Component, Snapshot
)
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(SnapshotDisplay),
cv.Required(CONF_DIMENSIONS): cv.Any(
cv.dimensions,
cv.Schema(
{
cv.Required(CONF_WIDTH): cv.positive_not_null_int,
cv.Required(CONF_HEIGHT): cv.positive_not_null_int,
}
),
),
}
)
),
cv.only_on(PLATFORM_HOST),
)
async def to_code(config: ConfigType) -> None:
var = cg.new_Pvariable(config[CONF_ID])
await display.register_display(var, config)
await register_snapshot(var, config)
dimensions = config[CONF_DIMENSIONS]
if isinstance(dimensions, dict):
cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
else:
(width, height) = dimensions
cg.add(var.set_dimensions(width, height))
if lamb := config.get(CONF_LAMBDA):
lambda_ = await cg.process_lambda(
lamb, [(display.DisplayRef, "it")], return_type=cg.void
)
cg.add(var.set_writer(lambda_))
esphome/components/snapshot/display/snapshot_display.cpp
+80
View File
@@ -0,0 +1,80 @@
#ifdef USE_HOST
#include "snapshot_display.h"
#include "esphome/components/display/display_color_utils.h"
#include "esphome/core/log.h"
#include <cstring>
namespace esphome::snapshot {
static const char *const TAG = "snapshot.display";
namespace {
/// Spread a channel that only goes up to `max` over the whole 0 to 255 range, so that the
/// brightest value stays the brightest. This is the same arithmetic SDL uses, which is what makes
/// a picture taken here come out identical to the same picture taken from an SDL window.
constexpr uint8_t expand_channel(uint16_t value, uint16_t max) { return static_cast<uint8_t>(value * 255 / max); }
constexpr uint16_t RED_MAX = 0x1F;
constexpr uint16_t GREEN_MAX = 0x3F;
constexpr uint16_t BLUE_MAX = 0x1F;
} // namespace
void SnapshotDisplay::setup() {
this->init_internal_(static_cast<uint32_t>(this->width_) * this->height_ * 2);
if (this->buffer_ == nullptr) {
this->mark_failed(LOG_STR("Could not allocate display buffer"));
}
}
void SnapshotDisplay::dump_config() { LOG_DISPLAY("", "Snapshot", this); }
void SnapshotDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
if (this->buffer_ == nullptr || x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
return;
this->pixels_()[y * this->width_ + x] = display::ColorUtil::color_to_565(color, display::COLOR_ORDER_RGB);
}
void SnapshotDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr,
display::ColorOrder order, display::ColorBitness bitness, bool big_endian,
int x_offset, int y_offset, int x_pad) {
if (this->buffer_ == nullptr)
return;
// Anything that is not already laid out the way the buffer is, or that would reach outside it,
// goes through the base class, which turns it into one call per pixel with the bounds checked.
const bool copyable = this->rotation_ == display::DISPLAY_ROTATION_0_DEGREES &&
bitness == display::COLOR_BITNESS_565 && !big_endian && x_start >= 0 && y_start >= 0 &&
x_start + w <= this->width_ && y_start + h <= this->height_;
if (!copyable) {
DisplayBuffer::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
return;
}
const size_t stride = static_cast<size_t>(x_offset) + w + x_pad;
const uint8_t *src = ptr + (stride * y_offset + x_offset) * 2;
for (int y = 0; y != h; y++) {
memcpy(&this->pixels_()[(y_start + y) * this->width_ + x_start], src + y * stride * 2, w * 2);
}
}
bool SnapshotDisplay::capture_bgr(uint8_t *dest, size_t row_stride) {
if (this->buffer_ == nullptr) {
ESP_LOGE(TAG, "Snapshot requested but there is no buffer to read");
return false;
}
const uint16_t *src = this->pixels_();
for (int y = 0; y != this->height_; y++) {
uint8_t *out = dest + y * row_stride;
for (int x = 0; x != this->width_; x++) {
const uint16_t pixel = *src++;
*out++ = expand_channel(pixel & BLUE_MAX, BLUE_MAX);
*out++ = expand_channel((pixel >> 5) & GREEN_MAX, GREEN_MAX);
*out++ = expand_channel(pixel >> 11, RED_MAX);
}
}
return true;
}
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/display/snapshot_display.h
+48
View File
@@ -0,0 +1,48 @@
#pragma once
#ifdef USE_HOST
#include "esphome/components/display/display_buffer.h"
#include "esphome/components/snapshot/snapshot.h"
#include "esphome/core/component.h"
namespace esphome::snapshot {
/// A display with nowhere to show anything: it keeps the picture in memory, where the snapshot
/// action can pick it up. That makes it a way to see what a configuration draws on a machine with
/// no screen, and to check the result in a test.
class SnapshotDisplay final : public display::DisplayBuffer, public Snapshot {
public:
void setup() override;
void update() override { this->do_update_(); }
void dump_config() override;
float get_setup_priority() const override { return setup_priority::HARDWARE; }
display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
void set_dimensions(uint16_t width, uint16_t height) {
this->width_ = width;
this->height_ = height;
}
void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
protected:
void draw_absolute_pixel_internal(int x, int y, Color color) override;
int get_width_internal() override { return this->width_; }
int get_height_internal() override { return this->height_; }
int snapshot_width() override { return this->width_; }
int snapshot_height() override { return this->height_; }
bool capture_bgr(uint8_t *dest, size_t row_stride) override;
/// The picture, one 16 bit RGB565 value per pixel, topmost row first. Owned by DisplayBuffer as
/// a byte pointer; this is the same memory seen as what is actually stored in it.
uint16_t *pixels_() { return reinterpret_cast<uint16_t *>(this->buffer_); }
int width_{};
int height_{};
};
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/snapshot.cpp
+248
View File
@@ -0,0 +1,248 @@
#ifdef USE_HOST
#include "snapshot.h"
#include "esphome/core/log.h"
#include <fcntl.h>
#include <strings.h>
#include <unistd.h>
#include <cctype>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <filesystem>
#include <memory>
namespace esphome::snapshot {
namespace {
constexpr const char *const TAG = "snapshot";
// Longest name we will build a path from. NAME_MAX is 255 and we may append a collision suffix.
constexpr size_t MAX_NAME_LENGTH = 200;
// Give up rather than spin forever if every candidate name is taken.
constexpr unsigned MAX_NAME_ATTEMPTS = 1000;
// A BMP file header followed by a BITMAPINFOHEADER, which is where the pixels start.
constexpr size_t BMP_HEADER_SIZE = 54;
constexpr size_t BMP_INFO_HEADER_SIZE = 40;
constexpr int BMP_BITS_PER_PIXEL = 24;
/// True if the name already ends in ".bmp". The comparison ignores case, so "shot.BMP" is left
/// alone rather than turned into "shot.BMP.bmp".
bool has_bmp_suffix(const std::string &name) {
return name.size() >= 4 && strcasecmp(name.c_str() + name.size() - 4, ".bmp") == 0;
}
/// Reduce a user supplied name to a single safe path component. Everything outside the allowed set
/// is replaced, so "..", "/" and absolute paths cannot escape the snapshot directory.
/// Returns an empty string if nothing usable is left.
std::string sanitise_filename(const char *const name, bool *name_changed) {
std::string result;
bool all_dots = true;
bool changed = false;
for (const char *p = name; *p != '\0'; p++) {
if (result.size() >= MAX_NAME_LENGTH) {
changed = true;
break;
}
char c = *p;
if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')) {
c = '_';
changed = true;
}
if (c != '.')
all_dots = false;
result.push_back(c);
}
if (all_dots) {
*name_changed = true;
return "";
}
if (!has_bmp_suffix(result))
result += ".bmp";
*name_changed = changed;
return result;
}
/// Insert "-<attempt>" before the file extension, e.g. "shot.bmp" -> "shot-1.bmp".
std::string add_suffix(const std::string &name, unsigned attempt) {
char suffix[12];
snprintf(suffix, sizeof(suffix), "-%u", attempt);
auto dot = name.rfind('.');
if (dot == std::string::npos)
return name + suffix;
return name.substr(0, dot) + suffix + name.substr(dot);
}
/// Directory snapshots are written to. The environment variable lets a test redirect output
/// without rebuilding, matching how the host platform handles ESPHOME_PREFDIR.
const char *snapshot_dir() {
const char *dir = getenv("ESPHOME_SNAPSHOT_DIR"); // NOLINT(concurrency-mt-unsafe)
return dir != nullptr && dir[0] != '\0' ? dir : ESPHOME_SNAPSHOT_DIR;
}
/// Store a value in as many bytes, least significant first, and step the pointer past it.
/// BMP is a little endian format whatever the machine writing it uses.
void put_le(uint8_t *&dest, uint32_t value, size_t bytes) {
for (size_t i = 0; i != bytes; i++)
*dest++ = static_cast<uint8_t>(value >> (8 * i));
}
/// The number of bytes one row of `width` pixels takes up in the file. Rows are padded out to a
/// multiple of four bytes.
size_t bmp_row_size(int width) { return (static_cast<size_t>(width) * 3 + 3) & ~size_t{3}; }
/// Write pixels out as a 24 bit BMP. The rows given start with the topmost and are `row_stride`
/// bytes apart, which must leave room for a whole padded row; a BMP holds its rows the other way
/// up, so they go out last first.
bool write_bmp(FILE *file, const uint8_t *pixels, int width, int height, size_t row_stride) {
const size_t row_size = bmp_row_size(width);
const size_t pixel_bytes = row_size * height;
uint8_t header[BMP_HEADER_SIZE];
uint8_t *pos = header;
*pos++ = 'B';
*pos++ = 'M';
put_le(pos, static_cast<uint32_t>(BMP_HEADER_SIZE + pixel_bytes), 4);
put_le(pos, 0, 4); // reserved
put_le(pos, BMP_HEADER_SIZE, 4);
put_le(pos, BMP_INFO_HEADER_SIZE, 4);
put_le(pos, static_cast<uint32_t>(width), 4);
put_le(pos, static_cast<uint32_t>(height), 4);
put_le(pos, 1, 2); // one plane
put_le(pos, BMP_BITS_PER_PIXEL, 2);
put_le(pos, 0, 4); // not compressed
put_le(pos, static_cast<uint32_t>(pixel_bytes), 4);
put_le(pos, 0, 4); // pixels per metre across, unspecified
put_le(pos, 0, 4); // pixels per metre down, unspecified
put_le(pos, 0, 4); // no palette
put_le(pos, 0, 4); // so no palette entry matters more than another
if (fwrite(header, 1, sizeof(header), file) != sizeof(header))
return false;
for (int y = height - 1; y >= 0; y--) {
if (fwrite(pixels + static_cast<size_t>(y) * row_stride, 1, row_size, file) != row_size)
return false;
}
return true;
}
/// Reserve a name in the snapshot directory and write the picture to it.
/// With `exact` set the given name is the only one tried; otherwise a number is added on
/// collision. Returns true if a file was written.
bool write_snapshot_file(const uint8_t *pixels, int width, int height, size_t row_stride, const std::string &name,
bool exact) {
const std::string dir = snapshot_dir();
std::error_code ec;
std::filesystem::create_directories(dir, ec);
if (ec) {
ESP_LOGE(TAG, "Could not create snapshot directory %s: %s", dir.c_str(), ec.message().c_str());
return false;
}
// O_EXCL guarantees we never write over a file that is already there.
std::string path;
int fd = -1;
for (unsigned attempt = 0; attempt < MAX_NAME_ATTEMPTS; attempt++) {
path = dir + "/" + (attempt == 0 ? name : add_suffix(name, attempt));
fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0644);
if (fd >= 0)
break;
if (errno != EEXIST) {
ESP_LOGE(TAG, "Could not create %s: %s", path.c_str(), strerror(errno));
return false;
}
if (exact) {
// The caller asked for this exact name, so silently writing somewhere else would be worse
// than failing - a test asserting on the path would pick up a stale file.
ESP_LOGE(TAG, "Snapshot %s already exists, not overwriting", path.c_str());
return false;
}
}
if (fd < 0) {
ESP_LOGE(TAG, "Could not find an unused name for %s in %s", name.c_str(), dir.c_str());
return false;
}
FILE *file = fdopen(fd, "wb");
if (file == nullptr) {
ESP_LOGE(TAG, "Could not open %s: %s", path.c_str(), strerror(errno));
::close(fd);
::unlink(path.c_str());
return false;
}
bool ok = write_bmp(file, pixels, width, height, row_stride);
int saved_errno = ok ? 0 : errno;
// Closing can fail in its own right - the last of the data is still on its way out.
if (fclose(file) != 0) {
if (ok)
saved_errno = errno;
ok = false;
}
if (!ok) {
ESP_LOGE(TAG, "Could not write %s: %s", path.c_str(), strerror(saved_errno));
// Leave no truncated file behind - it would block a retry under the same name.
::unlink(path.c_str());
return false;
}
ESP_LOGI(TAG, "Snapshot written to %s", path.c_str());
return true;
}
} // namespace
// helper function since ESP_LOGW is disallowed in a header file
void Snapshot::log_action_failed() { ESP_LOGW(TAG, "snapshot.take did not write a file"); }
bool Snapshot::take_snapshot(const char *filename) {
const int width = this->snapshot_width();
const int height = this->snapshot_height();
if (width <= 0 || height <= 0) {
ESP_LOGE(TAG, "Snapshot requested but the display is %dx%d", width, height);
return false;
}
std::string name;
bool exact = false;
if (filename != nullptr) {
bool name_changed = false;
name = sanitise_filename(filename, &name_changed);
exact = !name.empty();
if (name_changed) {
ESP_LOGW(TAG, "Requested snapshot name '%s' is not an acceptable file name, using '%s' instead", filename,
name.empty() ? "a name made from the time" : name.c_str());
}
}
if (name.empty()) {
struct timespec now {};
if (clock_gettime(CLOCK_REALTIME, &now) != 0)
now = {};
struct tm tm_buf {};
if (localtime_r(&now.tv_sec, &tm_buf) == nullptr)
tm_buf = {};
char stamp[32]{};
// ::strftime to be sure of the one from <ctime>; display has an unrelated member of that name
if (::strftime(stamp, sizeof(stamp), "%Y%m%d-%H%M%S", &tm_buf) == 0)
snprintf(stamp, sizeof(stamp), "unknown-time");
char buffer[MAX_NAME_LENGTH];
int written =
snprintf(buffer, sizeof(buffer), "%s-%s-%03ld.bmp", this->snapshot_prefix_, stamp, now.tv_nsec / 1000000);
if (written < 0 || static_cast<size_t>(written) >= sizeof(buffer)) {
ESP_LOGW(TAG, "Could not build a timestamped snapshot name, using a fallback");
snprintf(buffer, sizeof(buffer), "snapshot.bmp");
}
name = buffer;
}
// Rows are padded out to a multiple of four bytes, as the file wants them, so each one can be
// written straight from the buffer. Zeroed on allocation, which is what the padding must be.
const size_t row_stride = bmp_row_size(width);
auto pixels = std::make_unique<uint8_t[]>(row_stride * height);
if (!this->capture_bgr(pixels.get(), row_stride))
return false;
return write_snapshot_file(pixels.get(), width, height, row_stride, name, exact);
}
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/snapshot.h
+72
View File
@@ -0,0 +1,72 @@
#pragma once
#ifdef USE_HOST
#include "esphome/core/automation.h"
#include <cstddef>
#include <cstdint>
#include <string>
// Directory snapshots are written to. Normally set by codegen to a folder under .esphome; the
// fallback keeps the component compiling for static analysis, where no defines.h is generated.
#ifndef ESPHOME_SNAPSHOT_DIR
#define ESPHOME_SNAPSHOT_DIR "."
#endif
namespace esphome::snapshot {
/// Base for anything that can hand over the picture it is showing so it can be written to a file.
///
/// A subclass says how big the picture is and fills in the pixels. Everything else - picking a
/// name, staying inside the snapshot directory, not writing over anything, and encoding the file -
/// is done here, so every component that can take a snapshot behaves the same way.
class Snapshot {
public:
virtual ~Snapshot() = default;
/// Set the word generated names start with. Codegen passes the component id, so with more than
/// one display in a device it is clear which one a file came from.
void set_snapshot_prefix(const char *prefix) { this->snapshot_prefix_ = prefix; }
/// Write the current picture to a BMP file in the snapshot directory.
///
/// Pass nullptr to have a name made up from the prefix and the current time. A file that is
/// already there is never written over. Returns true if a file was written.
bool take_snapshot(const char *filename);
/// Log that an action-triggered snapshot did not write a file.
static void log_action_failed();
protected:
/// Width of the picture in pixels.
virtual int snapshot_width() = 0;
/// Height of the picture in pixels.
virtual int snapshot_height() = 0;
/// Fill in the picture: three bytes per pixel in blue, green, red order, topmost row first, with
/// `row_stride` bytes from the start of one row to the start of the next. Returns false, having
/// logged why, if the picture could not be read.
virtual bool capture_bgr(uint8_t *dest, size_t row_stride) = 0;
const char *snapshot_prefix_{"snapshot"};
};
template<typename... Ts> class SnapshotAction final : public Action<Ts...>, public Parented<Snapshot> {
public:
TEMPLATABLE_VALUE(std::string, filename)
protected:
void play(const Ts &...x) override {
bool ok;
if (this->filename_.has_value()) {
ok = this->parent_->take_snapshot(this->filename_.value(x...).c_str());
} else {
ok = this->parent_->take_snapshot(nullptr);
}
if (!ok)
this->parent_->log_action_failed();
}
};
} // namespace esphome::snapshot
#endif