xbintsc 0.3.69 → 0.3.79

package/runtime/ext_gui/gui_media.cpp

@@ -0,0 +1,193 @@
+/*
+ * xbintsc GUI engine — `<video>` / `<audio>` lifecycle.
+ *
+ * This unit bridges three pieces:
+ *   - the DOM (`Node`) and the per-window media table on `XtGuiWindow`;
+ *   - the decoders (`media.cpp`, backed by FFmpeg + SDL audio);
+ *   - the renderer (`renderer_image.cpp`), which owns the GPU textures.
+ *
+ * The frame loop calls `xt_gui_media_sync` (open/close decoders so the next
+ * layout sees the current sources and intrinsic sizes) and `xt_gui_media_tick`
+ * (decode for the elapsed wall clock and fire the resulting DOM events) once
+ * per frame. No `xt_value` is stored here, so there is nothing for the
+ * collector to trace.
+ */
+
+#include "gui_internal.h"
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace {
+
+bool isMediaElement(const xtgui::Node *node) {
+  return node != nullptr && node->isElement() && (node->isTag("video") || node->isTag("audio"));
+}
+
+/** The element's `src`, or the `src` of its first child `<source>` (which is
+ * how a `<video>` with fallback formats is written). */
+std::string sourceOf(const xtgui::Node *node) {
+  if (!isMediaElement(node)) return "";
+  const std::string *src = node->attr("src");
+  if (src != nullptr && !src->empty()) return *src;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    if (child->isElement() && child->isTag("source")) {
+      const std::string *child_src = child->attr("src");
+      if (child_src != nullptr && !child_src->empty()) return *child_src;
+    }
+  }
+  return "";
+}
+
+bool booleanAttr(const xtgui::Node *node, const char *name) {
+  return node->attr(name) != nullptr;
+}
+
+void collectMedia(const xtgui::Node *node, std::vector<const xtgui::Node *> *out) {
+  if (node == nullptr) return;
+  if (isMediaElement(node)) {
+    out->push_back(node);
+    return;  // a media element's children are `<source>`/`<track>`, not media
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) collectMedia(child.get(), out);
+}
+
+void releasePlayerTexture(const xtgui::MediaPlayer *player) {
+  if (player != nullptr && guidev::g_device != nullptr) {
+    xt_gui_media_texture_release(guidev::g_device, player->id());
+  }
+}
+
+/** Open a decoder for `node`/`src`, apply its boolean attributes, record it and
+ * return it (or NULL, after firing `error`). */
+xtgui::MediaPlayer *openEntry(XtGuiWindow *win, const xtgui::Node *node, const std::string &src) {
+  XtGuiMediaEntry entry;
+  entry.src = src;
+  std::string error;
+  entry.player = xtgui::MediaPlayer::open(src, &error);
+  if (!entry.player) {
+    entry.failed = true;
+    win->media_players[node] = std::move(entry);
+    xt_gui_dispatch_to_node(win, node, "error");
+    return nullptr;
+  }
+  entry.player->set_loop(booleanAttr(node, "loop"));
+  entry.player->set_muted(booleanAttr(node, "muted"));
+  entry.player->set_autoplay(booleanAttr(node, "autoplay"));
+  xtgui::MediaPlayer *raw = entry.player.get();
+  win->media_players[node] = std::move(entry);
+  return raw;
+}
+
+void emitMediaEvents(XtGuiWindow *win, const xtgui::Node *node, unsigned events) {
+  if (events == 0) return;
+  if (events & xtgui::kMediaEventLoadedMetadata) {
+    xt_gui_dispatch_to_node(win, node, "loadedmetadata");
+  }
+  if (events & xtgui::kMediaEventPlay) xt_gui_dispatch_to_node(win, node, "play");
+  if (events & xtgui::kMediaEventPause) xt_gui_dispatch_to_node(win, node, "pause");
+  if (events & xtgui::kMediaEventEnded) xt_gui_dispatch_to_node(win, node, "ended");
+  if (events & xtgui::kMediaEventTimeUpdate) xt_gui_dispatch_to_node(win, node, "timeupdate");
+  if (events & xtgui::kMediaEventError) xt_gui_dispatch_to_node(win, node, "error");
+}
+
+}  // namespace
+
+xtgui::MediaPlayer *xt_gui_media_player(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || !isMediaElement(node)) return nullptr;
+  auto found = win->media_players.find(node);
+  if (found != win->media_players.end()) return found->second.player.get();
+  std::string src = sourceOf(node);
+  if (src.empty()) return nullptr;
+  return openEntry(win, node, src);
+}
+
+void xt_gui_media_forget(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr) return;
+  auto found = win->media_players.find(node);
+  if (found == win->media_players.end()) return;
+  releasePlayerTexture(found->second.player.get());
+  win->media_players.erase(found);
+}
+
+void xt_gui_media_sync(XtGuiWindow *win) {
+  if (win == nullptr || win->document == nullptr) return;
+  std::vector<const xtgui::Node *> nodes;
+  collectMedia(win->document->root(), &nodes);
+  std::unordered_set<const xtgui::Node *> live(nodes.begin(), nodes.end());
+
+  /* Drop decoders whose element left the tree. Comparing pointers only (never
+   * dereferencing) is safe for a node that was already destroyed. */
+  for (auto it = win->media_players.begin(); it != win->media_players.end();) {
+    if (live.count(it->first) == 0) {
+      releasePlayerTexture(it->second.player.get());
+      it = win->media_players.erase(it);
+    } else {
+      ++it;
+    }
+  }
+
+  /* Open decoders for new sources and reopen when an element's `src` changes. */
+  for (const xtgui::Node *node : nodes) {
+    const std::string src = sourceOf(node);
+    auto found = win->media_players.find(node);
+    if (src.empty()) {
+      if (found != win->media_players.end()) {
+        releasePlayerTexture(found->second.player.get());
+        win->media_players.erase(found);
+      }
+      continue;
+    }
+    if (found != win->media_players.end() && found->second.src == src) continue;
+    if (found != win->media_players.end()) {
+      releasePlayerTexture(found->second.player.get());
+      win->media_players.erase(found);
+    }
+    openEntry(win, node, src);
+  }
+
+  /* Publish the intrinsic size of every `<video>` so layout can use it. */
+  for (const xtgui::Node *node : nodes) {
+    if (!node->isTag("video")) continue;
+    auto found = win->media_players.find(node);
+    xtgui::MediaPlayer *player = found == win->media_players.end() ? nullptr : found->second.player.get();
+    float width = 0.0f;
+    float height = 0.0f;
+    uint64_t id = 0;
+    if (player != nullptr) {
+      width = (float)player->frame_width();
+      height = (float)player->frame_height();
+      id = player->id();
+    }
+    win->document->setMediaSize(node, width, height, id);
+  }
+}
+
+void xt_gui_media_tick(XtGuiWindow *win, double now_ms) {
+  if (win == nullptr) return;
+  /* Snapshot the keys: a handler may change an element's `src`, which erases and
+   * reinserts into the table while we iterate. */
+  std::vector<const xtgui::Node *> nodes;
+  nodes.reserve(win->media_players.size());
+  for (const auto &entry : win->media_players) nodes.push_back(entry.first);
+  for (const xtgui::Node *node : nodes) {
+    auto found = win->media_players.find(node);
+    if (found == win->media_players.end() || !found->second.player) continue;
+    unsigned events = found->second.player->tick(now_ms);
+    /* A freshly decoded frame must reach the image upload. The geometry pass
+     * rebuilds the image batches, so mark it dirty once per new generation. */
+    if (found->second.player->has_video() &&
+        found->second.player->frame_generation() != found->second.rendered_generation) {
+      found->second.rendered_generation = found->second.player->frame_generation();
+      win->geometry.dirty = 1;
+    }
+    emitMediaEvents(win, node, events);
+  }
+}
+
+void xt_gui_media_shutdown(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  for (auto &entry : win->media_players) releasePlayerTexture(entry.second.player.get());
+  win->media_players.clear();
+}

package/runtime/ext_gui/image.cpp

@@ -13,8 +13,11 @@
 #include "stb_image.h"
 
 #include <cctype>
+#include <string>
 #include <unordered_map>
 
+#include "svg.h"
+
 namespace xtgui {
 namespace {
 
@@ -63,31 +66,44 @@ std::string normalizePath(const std::string &input) {
 
 }  // namespace
 
-const Image *xt_image_load(const std::string &raw_path) {
+const Image *xt_image_load(const std::string &raw_path, int target_width, int target_height) {
   std::string path = normalizePath(raw_path);
+  bool svg = xt_svg_is_svg(path);
+  /* Raster formats always decode at their intrinsic resolution, so their cache
+   * key is the path. SVG is rasterised at the drawn pixel size, which is part
+   * of its identity. */
+  std::string key = path;
+  if (svg && (target_width > 0 || target_height > 0)) {
+    key += "#" + std::to_string(target_width) + "x" + std::to_string(target_height);
+  }
   auto &cache = imageCache();
-  auto found = cache.find(path);
+  auto found = cache.find(key);
   if (found != cache.end()) {
     return found->second.width > 0 ? &found->second : nullptr;
   }
 
   Image image;
-  int width = 0;
-  int height = 0;
-  int channels = 0;
-  unsigned char *data = stbi_load(path.c_str(), &width, &height, &channels, 4);
-  if (data != nullptr) {
-    image.width = width;
-    image.height = height;
-    image.pixels.assign(data, data + (size_t)width * (size_t)height * 4);
-    stbi_image_free(data);
+  if (svg) {
+    xt_svg_render(path, target_width, target_height, &image);
+  } else {
+    int width = 0;
+    int height = 0;
+    int channels = 0;
+    unsigned char *data = stbi_load(path.c_str(), &width, &height, &channels, 4);
+    if (data != nullptr) {
+      image.width = width;
+      image.height = height;
+      image.pixels.assign(data, data + (size_t)width * (size_t)height * 4);
+      stbi_image_free(data);
+    }
   }
-  auto inserted = cache.emplace(path, std::move(image));
+  auto inserted = cache.emplace(key, std::move(image));
   return inserted.first->second.width > 0 ? &inserted.first->second : nullptr;
 }
 
 bool xt_image_size(const std::string &raw_path, int *width, int *height) {
   std::string path = normalizePath(raw_path);
+  if (xt_svg_is_svg(path)) return xt_svg_size(path, width, height);
   auto &cache = sizeCache();
   auto found = cache.find(path);
   if (found == cache.end()) {
@@ -117,9 +133,12 @@ bool xt_image_decode(const unsigned char *data, size_t size, Image *out) {
   return true;
 }
 
+bool xt_image_is_vector(const std::string &path) { return xt_svg_is_svg(normalizePath(path)); }
+
 void xt_image_shutdown() {
   imageCache().clear();
   sizeCache().clear();
+  xt_svg_shutdown();
 }
 
 }  // namespace xtgui

package/runtime/ext_gui/image.h

@@ -23,18 +23,31 @@ struct Image {
   std::vector<unsigned char> pixels;
 };
 
-/** Decode an image file (PNG/JPEG/BMP/GIF/TGA) to RGBA8. Returns nullptr on
- * failure. Results (including failures) are cached by path. A `file://` prefix
- * and URL percent-encoding are handled. */
-const Image *xt_image_load(const std::string &path);
-
-/** Read just the intrinsic size from the file header, without decoding.
- * Returns false when the file cannot be read/parsed. Cached. */
+/** Decode an image file (PNG/JPEG/BMP/GIF/TGA or SVG) to RGBA8. Returns
+ * nullptr on failure. Results (including failures) are cached by path. A
+ * `file://` prefix and URL percent-encoding are handled.
+ *
+ * `target_width`/`target_height` are the pixel size the image will be drawn at.
+ * Raster formats ignore them (they decode at their intrinsic resolution), but
+ * SVG is a vector format and is rasterised at (approximately) that size —
+ * preserving its aspect ratio — so a scaled `<img src="logo.svg">` stays crisp
+ * instead of being a magnified bitmap. Pass `<= 0` (the default) to use the intrinsic size. The cache is keyed by the
+ * resulting pixel size for SVG and by path for raster formats. */
+const Image *xt_image_load(const std::string &path, int target_width = 0, int target_height = 0);
+
+/** Read just the intrinsic size from the file header, without decoding. For an
+ * SVG this parses the document (the size comes from width/height or the
+ * viewBox). Returns false when the file cannot be read/parsed. Cached. */
 bool xt_image_size(const std::string &path, int *width, int *height);
 
 /** Decode an in-memory buffer to RGBA8 (e.g. a future `data:` URI). */
 bool xt_image_decode(const unsigned char *data, size_t size, Image *out);
 
+/** True when `path` is a vector source (SVG) that is rasterised on demand
+ * rather than decoded as a bitmap. The renderer uses this to key vector
+ * textures by pixel size. */
+bool xt_image_is_vector(const std::string &path);
+
 void xt_image_shutdown();
 
 }  // namespace xtgui

package/runtime/ext_gui/layout.cpp

@@ -25,7 +25,8 @@ namespace {
 
 std::unique_ptr<LayoutBox> buildBoxTree(const Node *node,
                                         const std::unordered_map<const Node *, XtStyle> &styles,
-                                        const XtStyle *inherited) {
+                                        const XtStyle *inherited, const MediaSizeMap *media,
+                                        const CanvasInfoMap *canvases) {
   if (node->isText()) {
     auto box = std::make_unique<LayoutBox>();
     box->node = node;
@@ -55,9 +56,53 @@ std::unique_ptr<LayoutBox> buildBoxTree(const Node *node,
         box->intrinsic_height = (float)height;
       }
     }
+  } else if (node->isElement() && node->isTag("video")) {
+    /* Default the video box to the HTML 300x150 until the decoder reports the
+     * real pixel size (fetched as soon as the element is associated with a
+     * player, before the next layout pass). */
+    box->is_image = true;
+    box->is_media = true;
+    box->intrinsic_width = 300;
+    box->intrinsic_height = 150;
+    if (media != nullptr) {
+      auto found = media->find(node);
+      if (found != media->end()) {
+        box->media_id = found->second.id;
+        if (found->second.width > 0 && found->second.height > 0) {
+          box->intrinsic_width = found->second.width;
+          box->intrinsic_height = found->second.height;
+        }
+      }
+    }
+  } else if (node->isElement() && node->isTag("canvas")) {
+    /* A replaced inline-block whose pixels are a script-owned bitmap. The
+     * intrinsic size is the HTML 300x150 default, overridden by the
+     * `width`/`height` attributes (or a script assignment to `canvas.width`),
+     * published by the window as `CanvasInfo`. */
+    box->is_canvas = true;
+    box->intrinsic_width = 300;
+    box->intrinsic_height = 150;
+    float parsed = 0.0f;
+    const std::string *attr_width = node->attr("width");
+    const std::string *attr_height = node->attr("height");
+    if (attr_width != nullptr && xt_css_parse_number(*attr_width, &parsed) && parsed > 0.0f)
+      box->intrinsic_width = parsed;
+    if (attr_height != nullptr && xt_css_parse_number(*attr_height, &parsed) && parsed > 0.0f)
+      box->intrinsic_height = parsed;
+    if (canvases != nullptr) {
+      auto found = canvases->find(node);
+      if (found != canvases->end()) {
+        box->canvas_id = found->second.id;
+        if (found->second.width > 0 && found->second.height > 0) {
+          box->intrinsic_width = found->second.width;
+          box->intrinsic_height = found->second.height;
+        }
+      }
+    }
   }
   for (const std::unique_ptr<Node> &child : node->children) {
-    std::unique_ptr<LayoutBox> childBox = buildBoxTree(child.get(), styles, style);
+    std::unique_ptr<LayoutBox> childBox =
+        buildBoxTree(child.get(), styles, style, media, canvases);
     if (childBox != nullptr) {
       childBox->parent = box.get();
       box->children.push_back(std::move(childBox));
@@ -86,7 +131,8 @@ std::string dumpBox(const LayoutBox *box, int depth) {
 }  // namespace
 
 void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *, XtStyle> &styles,
-                         float viewportWidth, float viewportHeight) {
+                         float viewportWidth, float viewportHeight, const MediaSizeMap *media,
+                         const CanvasInfoMap *canvases) {
   root_.reset();
   index_.clear();
   root_style_ = xt_style_initial();
@@ -105,14 +151,15 @@ void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *
   if (root != nullptr) {
     if (root->type == NodeType::Document) {
       for (const std::unique_ptr<Node> &child : root->children) {
-        std::unique_ptr<LayoutBox> box = buildBoxTree(child.get(), styles, &root_style_);
+        std::unique_ptr<LayoutBox> box =
+            buildBoxTree(child.get(), styles, &root_style_, media, canvases);
         if (box != nullptr) {
           box->parent = root_.get();
           root_->children.push_back(std::move(box));
         }
       }
     } else {
-      std::unique_ptr<LayoutBox> box = buildBoxTree(root, styles, &root_style_);
+      std::unique_ptr<LayoutBox> box = buildBoxTree(root, styles, &root_style_, media, canvases);
       if (box != nullptr) {
         box->parent = root_.get();
         root_->children.push_back(std::move(box));

package/runtime/ext_gui/layout.h

@@ -13,6 +13,7 @@
 #ifndef XT_GUI_LAYOUT_H
 #define XT_GUI_LAYOUT_H
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -23,6 +24,25 @@
 
 namespace xtgui {
 
+/** Intrinsic size and decoder id of one `<video>` element, resolved by the
+ * engine and keyed by node. `width`/`height` are the decoded pixel size, or
+ * the 300x150 default before metadata is available. */
+struct MediaSize {
+  float width = 0;
+  float height = 0;
+  uint64_t id = 0;
+};
+using MediaSizeMap = std::unordered_map<const Node *, MediaSize>;
+
+/** Intrinsic size and render id of one `<canvas>` element, resolved by the
+ * engine and keyed by node. `width`/`height` are the bitmap's pixel size. */
+struct CanvasInfo {
+  float width = 0;
+  float height = 0;
+  uint64_t id = 0;
+};
+using CanvasInfoMap = std::unordered_map<const Node *, CanvasInfo>;
+
 /** A positioned text fragment (a wrapped text box can span several lines).
  * `text` holds the run this fragment covers (a word or a run of spaces). */
 struct TextFragment {
@@ -47,6 +67,17 @@ struct LayoutBox {
   float intrinsic_width = 0;
   float intrinsic_height = 0;
 
+  /* `<video>`: a replaced element whose pixels come from a live decoder
+   * (`media_id`) instead of a file. `is_image` is set too so the
+   * replaced-element sizing in `layout_flow.cpp` applies unchanged. */
+  bool is_media = false;
+  uint64_t media_id = 0;
+
+  /* `<canvas>`: a replaced element whose pixels are a script-owned `Canvas2D`
+   * (`canvas_id`). `is_image`-style intrinsic sizing applies. */
+  bool is_canvas = false;
+  uint64_t canvas_id = 0;
+
   Display display = Display::Inline;
 
   /* Resolved (px) box edges. */
@@ -70,7 +101,8 @@ struct LayoutBox {
 class LayoutTree {
  public:
   void compute(const Node *root, const std::unordered_map<const Node *, XtStyle> &styles,
-               float viewportWidth, float viewportHeight);
+               float viewportWidth, float viewportHeight, const MediaSizeMap *media = nullptr,
+               const CanvasInfoMap *canvases = nullptr);
   void clear() {
     root_.reset();
     index_.clear();