xbintsc 0.3.69 → 0.3.81

package/runtime/ext_gui/dom_api_media.cpp

@@ -0,0 +1,274 @@
+/*
+ * xbintsc GUI engine — `<video>` / `<audio>` object API.
+ *
+ * These methods live on the shared node prototype (`g_node_proto`), so they are
+ * callable on any element; a non-media element simply resolves no decoder and
+ * the methods no-op / return the media defaults. The decoders themselves live
+ * on the owning window (`gui_media.cpp`); this unit is the thin bridge from a
+ * node handle to its `MediaPlayer`.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+
+namespace domapi {
+
+/** The decoder already open for `node`, without opening one (getters must not
+ * have the side effect of starting playback). */
+static xtgui::MediaPlayer *openPlayer(XtGuiWindow *win, xtgui::Node *node) {
+  if (win == nullptr || node == nullptr) return nullptr;
+  auto found = win->media_players.find(node);
+  return found == win->media_players.end() ? nullptr : found->second.player.get();
+}
+
+/** Set/clear a boolean attribute (`loop`, `muted`, `autoplay`) so the value
+ * survives a later (re)open in `gui_media.cpp`. */
+static void setBooleanAttribute(XtGuiWindow *win, xtgui::Node *node, const char *name, bool value) {
+  if (value) {
+    set_attribute_raw(node, name, "");
+  } else {
+    remove_attribute_raw(node, name);
+  }
+  mark_dirty(win);
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(node_play) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  xtgui::MediaPlayer *player = xt_gui_media_player(win, node);
+  if (player != nullptr) player->play();
+  return XT_UNDEFINED;
+}
+
+METHOD(node_pause) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->pause();
+  return XT_UNDEFINED;
+}
+
+METHOD(node_load) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  /* Re-open from the current source, discarding any existing decoder. */
+  xt_gui_media_forget(win, node);
+  xt_gui_media_player(win, node);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_paused_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return (player == nullptr || player->paused()) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_ended_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return (player != nullptr && player->ended()) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_current_time_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return xt_number(player != nullptr ? player->current_time() : 0.0);
+}
+
+METHOD(node_current_time_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->seek(argc >= 1 ? xt_to_number(xt_arg(argc, argv, 0)) : 0.0);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_duration_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return xt_number(player != nullptr ? player->duration() : 0.0);
+}
+
+METHOD(node_volume_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return xt_number(player != nullptr ? player->volume() : 1.0);
+}
+
+METHOD(node_volume_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  double value = argc >= 1 ? xt_to_number(xt_arg(argc, argv, 0)) : 1.0;
+  if (value < 0.0) value = 0.0;
+  if (value > 1.0) value = 1.0;
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->set_volume(value);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_muted_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return (player != nullptr && player->muted()) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_muted_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  bool value = argc >= 1 && value_truthy(xt_arg(argc, argv, 0));
+  setBooleanAttribute(win, node, "muted", value);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->set_muted(value);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_loop_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return (player != nullptr && player->loop()) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_loop_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  bool value = argc >= 1 && value_truthy(xt_arg(argc, argv, 0));
+  setBooleanAttribute(win, node, "loop", value);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->set_loop(value);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_autoplay_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return (player != nullptr && player->autoplay()) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_autoplay_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  bool value = argc >= 1 && value_truthy(xt_arg(argc, argv, 0));
+  setBooleanAttribute(win, node, "autoplay", value);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  if (player != nullptr) player->set_autoplay(value);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_video_width_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return xt_number(player != nullptr ? player->frame_width() : 0);
+}
+
+METHOD(node_video_height_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  return xt_number(player != nullptr ? player->frame_height() : 0);
+}
+
+METHOD(node_ready_state_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xtgui::MediaPlayer *player = openPlayer(win, node);
+  /* HAVE_ENOUGH_DATA (4) once a player exists, HAVE_NOTHING (0) otherwise. */
+  return xt_number(player != nullptr ? 4 : 0);
+}
+
+METHOD(node_media_src_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement()) return xt_string_from_cstr("");
+  const std::string *src = node->attr("src");
+  return xt_string_from_cstr(src != nullptr ? src->c_str() : "");
+}
+
+METHOD(node_media_src_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  std::string value = argc >= 1 ? to_string_value(xt_arg(argc, argv, 0)) : "";
+  /* Changing the source discards the decoder; the frame loop reopens it. */
+  xt_gui_media_forget(win, node);
+  if (value.empty()) {
+    remove_attribute_raw(node, "src");
+    mark_dirty(win);
+  } else {
+    set_attribute(win, node, "src", value);
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_node.cpp

@@ -217,11 +217,13 @@ METHOD(node_get_bounding_rect) {
   if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
   const xtgui::LayoutBox *box = win->document->boxOf(node);
   if (box == nullptr) return XT_UNDEFINED;
+  /* Like the DOM: the rectangle of the *transformed* border box. */
+  xtgui::LayoutRect rect = xtgui::xt_layout_transformed_bounds(box);
   xt_value object = xt_object_new();
-  xt_object_set(object, xt_string_from_cstr("x"), xt_number(box->x));
-  xt_object_set(object, xt_string_from_cstr("y"), xt_number(box->y));
-  xt_object_set(object, xt_string_from_cstr("width"), xt_number(box->width));
-  xt_object_set(object, xt_string_from_cstr("height"), xt_number(box->height));
+  xt_object_set(object, xt_string_from_cstr("x"), xt_number(rect.x));
+  xt_object_set(object, xt_string_from_cstr("y"), xt_number(rect.y));
+  xt_object_set(object, xt_string_from_cstr("width"), xt_number(rect.width));
+  xt_object_set(object, xt_string_from_cstr("height"), xt_number(rect.height));
   return object;
 }
 

package/runtime/ext_gui/dom_api_proto.cpp

@@ -46,12 +46,37 @@ xt_value node_proto() {
   define_getter(proto, "style", (void *)node_style_get);
   define_getter(proto, "offsetWidth", (void *)node_offset_width_get);
   define_getter(proto, "offsetHeight", (void *)node_offset_height_get);
+  /* Media element properties (`<video>`/`<audio>`; harmless on any element). */
+  define_getter(proto, "paused", (void *)node_paused_get);
+  define_getter(proto, "ended", (void *)node_ended_get);
+  define_getter(proto, "duration", (void *)node_duration_get);
+  define_getter(proto, "currentTime", (void *)node_current_time_get);
+  define_getter(proto, "volume", (void *)node_volume_get);
+  define_getter(proto, "muted", (void *)node_muted_get);
+  define_getter(proto, "loop", (void *)node_loop_get);
+  define_getter(proto, "autoplay", (void *)node_autoplay_get);
+  define_getter(proto, "videoWidth", (void *)node_video_width_get);
+  define_getter(proto, "videoHeight", (void *)node_video_height_get);
+  define_getter(proto, "readyState", (void *)node_ready_state_get);
+  define_getter(proto, "src", (void *)node_media_src_get);
+  /* `<canvas>` element properties (`width`/`height` also address the attribute
+   * on other elements). */
+  define_getter(proto, "width", (void *)node_width_get);
+  define_getter(proto, "height", (void *)node_height_get);
   /* Setters. */
   define_setter(proto, "id", (void *)node_id_set);
   define_setter(proto, "className", (void *)node_class_name_set);
   define_setter(proto, "textContent", (void *)node_text_content_set);
   define_setter(proto, "innerText", (void *)node_text_content_set);
   define_setter(proto, "innerHTML", (void *)node_inner_html_set);
+  define_setter(proto, "currentTime", (void *)node_current_time_set);
+  define_setter(proto, "volume", (void *)node_volume_set);
+  define_setter(proto, "muted", (void *)node_muted_set);
+  define_setter(proto, "loop", (void *)node_loop_set);
+  define_setter(proto, "autoplay", (void *)node_autoplay_set);
+  define_setter(proto, "src", (void *)node_media_src_set);
+  define_setter(proto, "width", (void *)node_width_set);
+  define_setter(proto, "height", (void *)node_height_set);
   /* Methods. */
   define_method(proto, "getAttribute", (void *)node_get_attribute);
   define_method(proto, "setAttribute", (void *)node_set_attribute);
@@ -74,6 +99,10 @@ xt_value node_proto() {
   define_method(proto, "addEventListener", (void *)node_add_event_listener);
   define_method(proto, "removeEventListener", (void *)node_remove_event_listener);
   define_method(proto, "dispatchEvent", (void *)node_dispatch_event);
+  define_method(proto, "play", (void *)node_play);
+  define_method(proto, "pause", (void *)node_pause);
+  define_method(proto, "load", (void *)node_load);
+  define_method(proto, "getContext", (void *)node_get_context);
   g_node_proto = proto;
   return proto;
 }
@@ -132,4 +161,55 @@ xt_value style_proto() {
   return proto;
 }
 
+xt_value canvas_proto() {
+  xt_gc_add_root(&g_canvas_proto);
+  if (XT_IS_OBJECT(g_canvas_proto)) return g_canvas_proto;
+  xt_value proto = xt_object_new();
+  /* Properties. */
+  define_getter(proto, "canvas", (void *)canvas_get_canvas);
+  define_getter(proto, "fillStyle", (void *)canvas_fill_style_get);
+  define_setter(proto, "fillStyle", (void *)canvas_fill_style_set);
+  define_getter(proto, "strokeStyle", (void *)canvas_stroke_style_get);
+  define_setter(proto, "strokeStyle", (void *)canvas_stroke_style_set);
+  define_getter(proto, "lineWidth", (void *)canvas_line_width_get);
+  define_setter(proto, "lineWidth", (void *)canvas_line_width_set);
+  define_getter(proto, "globalAlpha", (void *)canvas_global_alpha_get);
+  define_setter(proto, "globalAlpha", (void *)canvas_global_alpha_set);
+  define_getter(proto, "font", (void *)canvas_font_get);
+  define_setter(proto, "font", (void *)canvas_font_set);
+  define_getter(proto, "textAlign", (void *)canvas_text_align_get);
+  define_setter(proto, "textAlign", (void *)canvas_text_align_set);
+  define_getter(proto, "textBaseline", (void *)canvas_text_baseline_get);
+  define_setter(proto, "textBaseline", (void *)canvas_text_baseline_set);
+  /* Methods. */
+  define_method(proto, "save", (void *)canvas_save);
+  define_method(proto, "restore", (void *)canvas_restore);
+  define_method(proto, "translate", (void *)canvas_translate);
+  define_method(proto, "rotate", (void *)canvas_rotate);
+  define_method(proto, "scale", (void *)canvas_scale);
+  define_method(proto, "transform", (void *)canvas_transform);
+  define_method(proto, "setTransform", (void *)canvas_set_transform);
+  define_method(proto, "resetTransform", (void *)canvas_reset_transform);
+  define_method(proto, "beginPath", (void *)canvas_begin_path);
+  define_method(proto, "closePath", (void *)canvas_close_path);
+  define_method(proto, "moveTo", (void *)canvas_move_to);
+  define_method(proto, "lineTo", (void *)canvas_line_to);
+  define_method(proto, "rect", (void *)canvas_rect);
+  define_method(proto, "arc", (void *)canvas_arc);
+  define_method(proto, "quadraticCurveTo", (void *)canvas_quadratic_curve_to);
+  define_method(proto, "bezierCurveTo", (void *)canvas_bezier_curve_to);
+  define_method(proto, "fill", (void *)canvas_fill);
+  define_method(proto, "stroke", (void *)canvas_stroke);
+  define_method(proto, "clearRect", (void *)canvas_clear_rect);
+  define_method(proto, "fillRect", (void *)canvas_fill_rect);
+  define_method(proto, "strokeRect", (void *)canvas_stroke_rect);
+  define_method(proto, "measureText", (void *)canvas_measure_text);
+  define_method(proto, "fillText", (void *)canvas_fill_text);
+  define_method(proto, "strokeText", (void *)canvas_stroke_text);
+  define_method(proto, "drawImage", (void *)canvas_draw_image);
+  define_method(proto, "getImageData", (void *)canvas_get_image_data);
+  g_canvas_proto = proto;
+  return proto;
+}
+
 }  // namespace domapi

package/runtime/ext_gui/gui.cpp

@@ -143,6 +143,8 @@ void xt_gui_quit_window(XtGuiWindow *win) {
   win->open = 0;
   xt_gui_emit(win, "close");
   win->animation_frames.clear();
+  xt_gui_media_shutdown(win);
+  xt_gui_canvas_shutdown(win);
   xt_gui_handles_reset(win);
   win->document_object = XT_UNDEFINED;
   win->document.reset();
@@ -227,6 +229,7 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
   record->image_geometry = XtGuiGeometry();
   record->last_frame_ms = 0.0;
   record->animation_frames.clear();
+  record->media_players.clear();
   record->next_animation_frame_id = 1;
   record->background[0] = 0.08f;
   record->background[1] = 0.09f;
@@ -300,6 +303,9 @@ extern "C" xt_value xt_gui_run(int32_t argc, xt_value *argv) {
     SDL_Quit();
     g_sdl_initialized = 0;
   }
+  /* Drop the decoded-image caches (including parsed SVG documents) now that
+   * the GPU textures that referenced them are gone. */
+  xtgui::xt_image_shutdown();
   g_window_count = 0;
   return XT_UNDEFINED;
 }

package/runtime/ext_gui/gui_canvas.cpp

@@ -0,0 +1,95 @@
+/*
+ * xbintsc GUI engine — `<canvas>` lifetime.
+ *
+ * A canvas bitmap is owned by the window, keyed by its DOM element (the same
+ * shape as the `<video>` decoder table). This unit reconciles that table with
+ * the live document, publishes each canvas's pixel size to the document so
+ * layout can give the element its intrinsic box, and releases the matching GPU
+ * texture when a canvas goes away.
+ */
+
+#include <memory>
+#include <vector>
+
+#include "canvas.h"
+#include "document.h"
+#include "gui_engine.h"
+#include "gui_internal.h"
+
+namespace {
+
+bool isCanvasElement(const xtgui::Node *node) {
+  return node != nullptr && node->isElement() && node->isTag("canvas");
+}
+
+/** Canvas children are fallback content, so a canvas element ends the walk. */
+void collectCanvases(const xtgui::Node *node, std::vector<const xtgui::Node *> *out) {
+  if (node == nullptr) return;
+  if (isCanvasElement(node)) {
+    out->push_back(node);
+    return;
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    collectCanvases(child.get(), out);
+  }
+}
+
+int canvasAttributeSize(const xtgui::Node *node, const char *name, int fallback) {
+  const std::string *attr = node->attr(name);
+  if (attr == nullptr) return fallback;
+  float value = 0.0f;
+  if (!xtgui::xt_css_parse_number(*attr, &value) || value <= 0.0f) return fallback;
+  return (int)(value + 0.5f);
+}
+
+void releaseCanvasTexture(xtgui::Canvas2D *canvas) {
+  if (canvas != nullptr && guidev::g_device != nullptr) {
+    xt_gui_canvas_texture_release(guidev::g_device, canvas->id());
+  }
+}
+
+}  // namespace
+
+xtgui::Canvas2D *xt_gui_canvas_find(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || node == nullptr) return nullptr;
+  auto found = win->canvases.find(node);
+  return found == win->canvases.end() ? nullptr : found->second.get();
+}
+
+xtgui::Canvas2D *xt_gui_canvas_get(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || !isCanvasElement(node)) return nullptr;
+  auto found = win->canvases.find(node);
+  if (found != win->canvases.end()) return found->second.get();
+  int width = canvasAttributeSize(node, "width", 300);
+  int height = canvasAttributeSize(node, "height", 150);
+  auto canvas = std::make_unique<xtgui::Canvas2D>(width, height);
+  xtgui::Canvas2D *raw = canvas.get();
+  win->canvases[node] = std::move(canvas);
+  return raw;
+}
+
+void xt_gui_canvas_forget(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || node == nullptr) return;
+  auto found = win->canvases.find(node);
+  if (found == win->canvases.end()) return;
+  releaseCanvasTexture(found->second.get());
+  win->canvases.erase(found);
+}
+
+void xt_gui_canvas_sync(XtGuiWindow *win) {
+  if (win == nullptr || win->document == nullptr) return;
+  std::vector<const xtgui::Node *> nodes;
+  collectCanvases(win->document->root(), &nodes);
+  for (const xtgui::Node *node : nodes) {
+    xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
+    if (canvas == nullptr) continue;
+    win->document->setCanvasInfo(node, (float)canvas->width(), (float)canvas->height(),
+                                 canvas->id());
+  }
+}
+
+void xt_gui_canvas_shutdown(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  for (auto &entry : win->canvases) releaseCanvasTexture(entry.second.get());
+  win->canvases.clear();
+}

package/runtime/ext_gui/gui_engine.h

@@ -38,7 +38,9 @@ const char *xt_gui_driver(void);
 #include <unordered_map>
 #include <vector>
 
+#include "canvas.h"
 #include "document.h"
+#include "media.h"
 #include "renderer.h"
 
 /** One element-level event listener registered through `addEventListener`. */
@@ -64,6 +66,18 @@ struct XtGuiNodeSlot {
   int generation = 0;
 };
 
+/** One media element's decoder slot. A failed open (bad `src`, or a build
+ * without a decoder) is remembered so the engine does not retry it every
+ * frame and fire `error` repeatedly. */
+struct XtGuiMediaEntry {
+  std::unique_ptr<xtgui::MediaPlayer> player;
+  std::string src;
+  bool failed = false;
+  /** Decoder generation already handed to the image upload, so a new video
+   * frame can mark the geometry dirty exactly once. */
+  uint64_t rendered_generation = 0;
+};
+
 /* One live window. `object` is the JavaScript-visible handle; the record is
  * addressed from it through the hidden `__xt_gui_index` property. */
 struct XtGuiWindow {
@@ -98,6 +112,14 @@ struct XtGuiWindow {
   int struct_dirty = 0;
   /** Callbacks queued for the next frame, plus the id counter. */
   std::vector<XtGuiAnimationFrame> animation_frames;
+  /** One decoder per `<video>`/`<audio>` element, keyed by the element node. The
+   * map doubles as the set of elements whose media is loaded; `gui_media.cpp`
+   * reconciles it with the live DOM every frame. */
+  std::unordered_map<const xtgui::Node *, XtGuiMediaEntry> media_players;
+  /** One `Canvas2D` per `<canvas>` element, keyed by the element node. Created
+   * lazily by `getContext("2d")` (or by `xt_gui_canvas_sync` for a live canvas),
+   * released when the node is forgotten or the document reloads. */
+  std::unordered_map<const xtgui::Node *, std::unique_ptr<xtgui::Canvas2D>> canvases;
   /** The batch currently running: its callbacks have been swapped out of
    * `animation_frames`, and a collection triggered by one of them must still
    * see the rest. Kept on the record (not a local) so the GC root provider can
@@ -156,6 +178,33 @@ void xt_gui_dispatch_wheel(XtGuiWindow *win, float x, float y, float delta_x, fl
 /** Synthesise a key event (`keydown`/`keyup`). */
 void xt_gui_dispatch_key(XtGuiWindow *win, const char *type, const char *key, const char *code);
 
+/** The decoder for one media element, opening it (and its `src`) on first use.
+ * Returns `nullptr` for a non-media element or an unreadable source. */
+xtgui::MediaPlayer *xt_gui_media_player(XtGuiWindow *win, const xtgui::Node *node);
+/** Close and drop the decoder for one element (e.g. its `src` changed). */
+void xt_gui_media_forget(XtGuiWindow *win, const xtgui::Node *node);
+/** Reconcile the player table with the live DOM: open new `<video>`/`<audio>`
+ * sources, drop players whose element is gone, and record decoded sizes so the
+ * next layout gives a `<video>` its intrinsic box. */
+void xt_gui_media_sync(XtGuiWindow *win);
+/** Advance every decoder and dispatch the resulting DOM events. */
+void xt_gui_media_tick(XtGuiWindow *win, double now_ms);
+/** Release all decoders and their GPU textures (window close / `loadHTML`). */
+void xt_gui_media_shutdown(XtGuiWindow *win);
+
+/** The 2D context of a `<canvas>` element, creating it (at the element's
+ * `width`/`height` attributes, 300x150 by default) on first use. */
+xtgui::Canvas2D *xt_gui_canvas_get(XtGuiWindow *win, const xtgui::Node *node);
+/** The existing 2D context of `node`, or null (no side effects). */
+xtgui::Canvas2D *xt_gui_canvas_find(XtGuiWindow *win, const xtgui::Node *node);
+/** Drop a node's canvas (called when its handle is forgotten). */
+void xt_gui_canvas_forget(XtGuiWindow *win, const xtgui::Node *node);
+/** Publish live canvases to the document (sizes + render ids) so layout and
+ * paint see them; creates a context for a canvas that has none yet. */
+void xt_gui_canvas_sync(XtGuiWindow *win);
+/** Release every canvas of `win` (window close / `loadHTML`). */
+void xt_gui_canvas_shutdown(XtGuiWindow *win);
+
 #endif /* __cplusplus */
 
 #endif /* XT_GUI_ENGINE_H */

package/runtime/ext_gui/gui_events.cpp

@@ -254,6 +254,14 @@ void xt_gui_render_window(XtGuiWindow *win) {
    * auto-close guard): `xt_gui_quit_window` released the document and the GPU
    * geometry, so there is nothing left to lay out or paint. */
   if (!win->open) return;
+  /* Reconcile decoders with the live DOM first, so this frame's layout sees the
+   * current sources and intrinsic sizes, then advance playback and fire the
+   * DOM media events. */
+  xt_gui_media_sync(win);
+  xt_gui_media_tick(win, now);
+  /* Publish canvas bitmaps to the document (and create contexts for a canvas
+   * that has none) before this frame's layout. */
+  xt_gui_canvas_sync(win);
   if (win->document != nullptr && win->document->advance(delta)) win->geometry.dirty = 1;
 
   /* A DOM mutation from a handler invalidates the tree: restyle/relayout
@@ -267,11 +275,18 @@ void xt_gui_render_window(XtGuiWindow *win) {
     xtgui::xt_paint_build(win->document->layout().root(), list);
     xt_gui_geometry_upload(g_device, &win->geometry, list);
     float density = SDL_GetWindowPixelDensity(win->window);
-    xt_gui_text_upload(g_device, &win->text_geometry, list, density > 0.0f ? density : 1.0f);
-    xt_gui_image_upload(g_device, &win->image_geometry, list);
+    float text_scale = density > 0.0f ? density : 1.0f;
+    xt_gui_text_upload(g_device, &win->text_geometry, list, text_scale);
+    xt_gui_image_upload(g_device, &win->image_geometry, list, text_scale);
+    xt_gui_build_runs(&win->geometry, &win->text_geometry, &win->image_geometry, list);
     win->geometry.dirty = 0;
   }
 
+  /* Upload any new video frame before the render command buffer is recorded,
+   * so the draw samples the frame that just arrived. */
+  xt_gui_media_upload_frames(g_device);
+  /* Canvases are CPU-drawn: push any new bitmap without a relayout. */
+  xt_gui_canvas_upload_frames(g_device);
   SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(g_device);
   if (cmd == NULL) return;
   SDL_GPUTexture *swapchain = NULL;
@@ -289,9 +304,10 @@ void xt_gui_render_window(XtGuiWindow *win) {
     target.store_op = SDL_GPU_STOREOP_STORE;
     SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
     if (can_paint) {
-      xt_gui_renderer_draw(cmd, pass, &win->geometry, viewport_width, viewport_height);
-      xt_gui_text_draw(cmd, pass, &win->text_geometry, viewport_width, viewport_height);
-      xt_gui_image_draw(cmd, pass, &win->image_geometry, viewport_width, viewport_height);
+      float density = SDL_GetWindowPixelDensity(win->window);
+      if (density <= 0.0f) density = 1.0f;
+      xt_gui_renderer_draw(cmd, pass, &win->geometry, &win->text_geometry, &win->image_geometry,
+                           viewport_width, viewport_height, density);
     }
     SDL_EndGPURenderPass(pass);
     firstFrame = !win->ready;