xbintsc 0.5.32 → 0.5.36

package/runtime/ext_gui/gui.cpp

@@ -19,6 +19,7 @@
 #include "paint.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 namespace guidev {
@@ -98,11 +99,32 @@ static void xt_gui_gc_scan_roots(void) {
 
 /* -- initialisation ------------------------------------------------------- */
 
-static int ensure_init(void) {  if (g_sdl_initialized) return 1;
-  xt_gc_register_root_provider(xt_gui_gc_scan_roots);
+/**
+ * Exit status for "this host cannot run a GUI program": no video driver, or no
+ * GPU device the SDL_GPU backends accept. It is deliberately distinct from a
+ * failed program so a CI script (or a user) can skip the run instead of
+ * reporting a crash. 77 is the autotools "skip" convention; `ci.yml` treats it
+ * that way for the provisional macOS job.
+ */
+const int kGuiUnavailableExit = 77;
+
+/** Report a window that could not be created as a JavaScript `Error`. Returning
+ * `undefined` used to surface one line later as `Cannot read properties of
+ * undefined (reading 'on')`, which hid the real diagnostic. */
+static void throw_gui_error(const char *message) {
+  xt_value text = xt_string_from_cstr(message);
+  xt_throw(xt_error_ctor_by_name(xt_string_from_cstr("Error"), 1, &text));
+}
+
+static void ensure_init(void) {
+  if (g_sdl_initialized) return;
   if (!SDL_Init(SDL_INIT_VIDEO)) {
     fprintf(stderr, "xt_gui: SDL_Init failed: %s\n", SDL_GetError());
-    return 0;
+    fprintf(stderr,
+            "xt_gui: the GUI extension needs a display (or a virtual one such as Xvfb); "
+            "exiting with status %d.\n",
+            kGuiUnavailableExit);
+    exit(kGuiUnavailableExit);
   }
   /* Accept every shader format so the same code runs on Metal, Vulkan and
    * D3D12; the backend only needs the one it supports. The engine ships MSL,
@@ -113,11 +135,17 @@ static int ensure_init(void) {  if (g_sdl_initialized) return 1;
   g_device = SDL_CreateGPUDevice(formats, false, NULL);
   if (g_device == NULL) {
     fprintf(stderr, "xt_gui: SDL_CreateGPUDevice failed: %s\n", SDL_GetError());
+    fprintf(stderr,
+            "xt_gui: the GUI extension needs a Metal (macOS), Vulkan or D3D12 device; "
+            "this host does not provide a usable one. Exiting with status %d.\n",
+            kGuiUnavailableExit);
     SDL_Quit();
-    return 0;
+    exit(kGuiUnavailableExit);
   }
+  /* Registered only once a window can exist: a failed init has nothing to
+   * mark, and a caller that cannot retry never needs a second provider. */
+  xt_gc_register_root_provider(xt_gui_gc_scan_roots);
   g_sdl_initialized = 1;
-  return 1;
 }
 
 /* -- window lookup -------------------------------------------------------- */
@@ -254,15 +282,18 @@ xt_value xt_gui_ensure_window(void) {
   for (int i = g_window_count - 1; i >= 0; i--) {
     if (g_windows[i].open) return g_windows[i].object;
   }
-  if (!ensure_init()) return XT_UNDEFINED;
+  ensure_init();
   XtGuiWindow *record = create_window_record("xbintsc gui", 800, 600, true);
-  if (record == NULL) return XT_UNDEFINED;
+  if (record == NULL) {
+    throw_gui_error("xbintsc gui: could not open the implicit window (see the diagnostic above)");
+    return XT_UNDEFINED;
+  }
   g_implicit_window = 1;
   return record->object;
 }
 
 extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
-  if (!ensure_init()) return XT_UNDEFINED;
+  ensure_init();
 
   const char *title = "xbintsc gui";
   int width = 800;
@@ -304,7 +335,11 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
   }
 
   XtGuiWindow *record = create_window_record(title, width, height, high_density);
-  return record != NULL ? record->object : XT_UNDEFINED;
+  if (record == NULL) {
+    throw_gui_error("xbintsc gui: could not open a window (see the diagnostic above)");
+    return XT_UNDEFINED;
+  }
+  return record->object;
 }
 
 /* -- run() / quit() ------------------------------------------------------- */

package/runtime/ext_gui/gui_engine.h

@@ -45,6 +45,9 @@ xt_value xt_browser_local_storage(int32_t argc, xt_value *argv);
 xt_value xt_browser_missing(int32_t argc, xt_value *argv);
 /** A DOM type name (`Image`, `HTMLCanvasElement`, …) as a constructor value. */
 xt_value xt_browser_type(int32_t argc, xt_value *argv);
+/** `createImageBitmap(source)`, exposed as a global *value*: returns the
+ * closure the compiler stores for the bare identifier. */
+xt_value xt_browser_create_image_bitmap(int32_t argc, xt_value *argv);
 xt_value xt_browser_request_animation_frame(int32_t argc, xt_value *argv);
 xt_value xt_browser_cancel_animation_frame(int32_t argc, xt_value *argv);
 xt_value xt_browser_match_media(int32_t argc, xt_value *argv);
@@ -63,11 +66,13 @@ void xt_browser_schedule_frame(void);
 /** Whether `run()` currently owns the frame loop (the pump then stays idle). */
 int xt_gui_run_active(void);
 
-/* Web Audio objects (`audio.cpp`). */
-/** `AudioContext.prototype` — also the `instanceof AudioContext` target. */
+/* Web Audio objects (`audio.cpp`).
+ * `AudioContext.prototype` — also the `instanceof AudioContext` target. */
 xt_value xt_gui_audio_proto(void);
-/** `new AudioContext(...)`: it has no mixer backend yet, so the graph records
- * its shape and parameters but nothing is rendered to the sound device. */
+/** `new AudioContext(...)`: builds a real graph (mixer in `audio_mixer.cpp`)
+ * and decodes through `audio_decode.cpp` + the optional media backend. The
+ * device opens on the first `start()`/`resume()`; a headless host stays silent
+ * while the graph still renders. */
 xt_value xt_gui_audio_create(int32_t argc, xt_value *argv);
 
 #ifdef __cplusplus

package/runtime/ext_gui/image_bitmap.cpp

@@ -0,0 +1,28 @@
+/*
+ * xbintsc GUI engine — `ImageBitmap` pixel storage.
+ */
+
+#include "image_bitmap.h"
+
+#include <unordered_map>
+
+namespace xtgui {
+namespace {
+
+std::unordered_map<uint64_t, Image> g_bitmaps;
+uint64_t g_next_bitmap = 1;
+
+}  // namespace
+
+uint64_t xt_image_bitmap_add(const Image &image) {
+  const uint64_t id = g_next_bitmap++;
+  g_bitmaps[id] = image;
+  return id;
+}
+
+const Image *xt_image_bitmap_get(uint64_t id) {
+  auto found = g_bitmaps.find(id);
+  return found == g_bitmaps.end() ? nullptr : &found->second;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/image_bitmap.h

@@ -0,0 +1,26 @@
+/*
+ * xbintsc GUI engine — `ImageBitmap` storage.
+ *
+ * `createImageBitmap(source)` returns a settled promise of an immutable
+ * bitmap. The pixels stay in C++ so `texImage2D` can consume them without
+ * materialising a JavaScript array; the handle object carries the numeric id
+ * under `__xt_bitmap`.
+ */
+#ifndef XT_GUI_IMAGE_BITMAP_H
+#define XT_GUI_IMAGE_BITMAP_H
+
+#include <cstdint>
+
+#include "image.h"
+
+namespace xtgui {
+
+/** Store a decoded bitmap and return its process-wide id. */
+uint64_t xt_image_bitmap_add(const Image &image);
+
+/** Look up a bitmap; null when the id is unknown. */
+const Image *xt_image_bitmap_get(uint64_t id);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_IMAGE_BITMAP_H */

package/runtime/ext_gui/image_bitmap_browser.cpp

@@ -0,0 +1,136 @@
+/*
+ * xbintsc GUI engine — `createImageBitmap`.
+ *
+ * The browser entry point returns a promise (as it does on the web), so code
+ * that writes `const bitmap = await createImageBitmap(canvas)` works unchanged.
+ * The pixels are kept in `image_bitmap.cpp`; `texImage2D` reads the same
+ * registry through the bitmap's `__xt_bitmap` id.
+ */
+
+#include "gui_engine.h"
+#include "dom_api_internal.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "image_bitmap.h"
+#include "webgl.h"
+
+namespace {
+
+void flip_rows(std::vector<unsigned char> *pixels, int width, int height) {
+  const size_t stride = (size_t)width * 4;
+  std::vector<unsigned char> row(stride);
+  for (int y = 0; y < height / 2; y++) {
+    unsigned char *top = pixels->data() + (size_t)y * stride;
+    unsigned char *bottom = pixels->data() + (size_t)(height - 1 - y) * stride;
+    memcpy(row.data(), top, stride);
+    memcpy(top, bottom, stride);
+    memcpy(bottom, row.data(), stride);
+  }
+}
+
+bool source_pixels(xt_value source, xtgui::Image *out) {
+  /* ImageData / another bitmap-like object: width, height, data. */
+  xt_value width_value = xt_object_get_cstr(source, "width");
+  xt_value height_value = xt_object_get_cstr(source, "height");
+  xt_value data = xt_object_get_cstr(source, "data");
+  if (XT_IS_OBJECT(data) && XT_IS_NUMBER(width_value) && XT_IS_NUMBER(height_value)) {
+    const int width = (int)xt_to_number(width_value);
+    const int height = (int)xt_to_number(height_value);
+    const std::vector<uint8_t> bytes = domapi::webgl_bytes(data);
+    if (width <= 0 || height <= 0 || bytes.size() < (size_t)width * height * 4) return false;
+    out->width = width;
+    out->height = height;
+    out->pixels.assign(bytes.begin(), bytes.begin() + (size_t)width * height * 4);
+    return true;
+  }
+
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = domapi::resolve_node(source, &win);
+  if (node == nullptr || !node->isElement()) return false;
+  if (node->isTag("img")) {
+    const std::string *src = node->attr("src");
+    const xtgui::Image *image = src != nullptr ? xtgui::xt_image_load(*src) : nullptr;
+    if (image == nullptr) return false;
+    *out = *image;
+    return true;
+  }
+  if (node->isTag("canvas")) {
+    if (xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node)) {
+      *out = canvas->image();
+      return true;
+    }
+    if (xtgui::WebGLContext *context = xt_gui_webgl_find(win, node)) {
+      out->width = context->width();
+      out->height = context->height();
+      out->pixels.resize((size_t)out->width * out->height * 4);
+      if (!context->read_pixels(0, 0, out->width, out->height, out->pixels.data())) {
+        return false;
+      }
+      /* readPixels is GL-ordered (bottom-up); bitmaps are stored top-down. */
+      flip_rows(&out->pixels, out->width, out->height);
+      return true;
+    }
+    return false;
+  }
+  if (node->isTag("video")) {
+    xtgui::MediaPlayer *player = xt_gui_media_player(win, node);
+    const xtgui::Image *frame = player != nullptr ? player->frame() : nullptr;
+    if (frame == nullptr || frame->width <= 0 || frame->height <= 0) return false;
+    *out = *frame;
+    return true;
+  }
+  return false;
+}
+
+xt_value bitmap_object(const xtgui::Image &image) {
+  const uint64_t id = xtgui::xt_image_bitmap_add(image);
+  xt_value name = xt_string_from_cstr("ImageBitmap");
+  xt_value constructor = xt_browser_type(1, &name);
+  xt_value prototype = xt_object_get_cstr(constructor, "prototype");
+  xt_value bitmap = XT_IS_OBJECT(prototype) ? xt_object_new_with_proto(prototype)
+                                            : xt_object_new();
+  xt_object_set(bitmap, xt_string_from_cstr("width"), xt_number(image.width));
+  xt_object_set(bitmap, xt_string_from_cstr("height"), xt_number(image.height));
+  xt_object_set(bitmap, xt_string_from_cstr("__xt_bitmap"), xt_number((double)id));
+  return bitmap;
+}
+
+}  // namespace
+
+namespace {
+
+xt_value create_bitmap(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_reject(xt_string_from_cstr("TypeError"));
+  xtgui::Image image;
+  if (!source_pixels(xt_arg(argc, argv, 0), &image)) {
+    return xt_promise_reject(xt_string_from_cstr("InvalidStateError"));
+  }
+  return xt_promise_resolve(bitmap_object(image));
+}
+
+/** The closure ABI the runtime calls for a first-class function value. */
+xt_value create_bitmap_call(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)self;
+  (void)env;
+  return create_bitmap(argc, argv);
+}
+
+xt_value g_create_bitmap = XT_UNDEFINED;
+
+}  // namespace
+
+/* `createImageBitmap` is a *global value*: the compiler calls this getter once
+ * and stores the returned closure, which is then called like any function. */
+xt_value xt_browser_create_image_bitmap(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  if (!XT_IS_OBJECT(g_create_bitmap)) {
+    g_create_bitmap = xt_closure_new((void *)create_bitmap_call, 0, nullptr);
+    xt_gc_add_root(&g_create_bitmap);
+  }
+  return g_create_bitmap;
+}
+

package/runtime/ext_gui/media.cpp

@@ -55,6 +55,38 @@ void xt_media_shutdown() {
   if (g_api != nullptr && g_api->shutdown != nullptr) g_api->shutdown();
 }
 
+bool xt_media_decode_audio(const uint8_t* data, size_t size, DecodedAudio* out,
+                           std::string* error) {
+  if (g_api == nullptr || g_api->decode_audio == nullptr) {
+    if (error) {
+      *error = "cannot decode this audio format; enable the 'media' extension (pass --ext media)";
+    }
+    return false;
+  }
+  XtMediaAudioBuffer decoded = {0, 0, 0, nullptr};
+  char message[kErrorSize] = {0};
+  if (g_api->decode_audio(data, size, &decoded, message, sizeof(message)) == 0 ||
+      decoded.samples == nullptr) {
+    if (decoded.samples != nullptr && g_api->free_audio != nullptr) {
+      g_api->free_audio(decoded.samples);
+    }
+    if (error) *error = message[0] != '\0' ? message : "cannot decode audio data";
+    return false;
+  }
+  if (decoded.channels <= 0 || decoded.frames < 0 || decoded.sample_rate <= 0) {
+    if (g_api->free_audio != nullptr) g_api->free_audio(decoded.samples);
+    if (error) *error = "decoder produced an empty audio buffer";
+    return false;
+  }
+  out->channels = decoded.channels;
+  out->sample_rate = decoded.sample_rate;
+  out->frames = static_cast<uint32_t>(decoded.frames);
+  size_t count = static_cast<size_t>(decoded.frames) * static_cast<size_t>(decoded.channels);
+  out->interleaved.assign(decoded.samples, decoded.samples + count);
+  if (g_api->free_audio != nullptr) g_api->free_audio(decoded.samples);
+  return true;
+}
+
 }  // namespace xtgui
 
 extern "C" void xt_media_install(const XtMediaApi* api) { g_api = api; }

package/runtime/ext_gui/media.h

@@ -35,11 +35,24 @@
 #include <memory>
 #include <string>
 
+#include "audio_decode.h"
 #include "image.h"
 #include "media_api.h"
 
 namespace xtgui {
 
+/**
+ * Decode an in-memory audio file (`decodeAudioData`).
+ *
+ * The engine has its own WAV decoder (`audio_decode.cpp`); this entry point is
+ * the fallback for compressed containers and codecs, which only the optional
+ * `media` extension can decode. Without that extension it fails with a message
+ * naming the extension. Implemented in `media.cpp`, which forwards to the
+ * backend table installed by the media bridge.
+ */
+bool xt_media_decode_audio(const uint8_t* data, size_t size, DecodedAudio* out,
+                           std::string* error);
+
 /** DOM events a media element may fire after `tick()`. */
 enum MediaEvent {
   kMediaEventLoadedMetadata = 1 << 0,

package/runtime/ext_gui/media_api.h

@@ -40,10 +40,30 @@ typedef XtMediaPlayerHandle (*XtMediaByIdFn)(uint64_t id);
 /** Tear down every decoder and process-wide media state. */
 typedef void (*XtMediaShutdownFn)(void);
 
+/** Interleaved float PCM returned by the memory decoder.
+ *
+ * `samples` is allocated by the backend and must be released with the table's
+ * `free_audio` entry point (both archives use the same static CRT). */
+typedef struct XtMediaAudioBuffer {
+  int channels;
+  int sample_rate;
+  int frames;
+  float *samples;
+} XtMediaAudioBuffer;
+
+/** Decode an in-memory audio file (`decodeAudioData`). Returns 1 on success and
+ * fills `out`; on failure returns 0 and copies a message into `error`. */
+typedef int (*XtMediaDecodeAudioFn)(const unsigned char *data, size_t size,
+                                    XtMediaAudioBuffer *out, char *error, size_t error_size);
+/** Release the `samples` a successful `decode_audio` allocated. */
+typedef void (*XtMediaFreeAudioFn)(void *samples);
+
 typedef struct XtMediaApi {
   XtMediaOpenFn open;
   XtMediaByIdFn by_id;
   XtMediaShutdownFn shutdown;
+  XtMediaDecodeAudioFn decode_audio;
+  XtMediaFreeAudioFn free_audio;
 } XtMediaApi;
 
 /** Install a decoder table. Implemented by the GUI engine; called once by the
@@ -57,6 +77,9 @@ XtMediaPlayerHandle xt_media_backend_open(const char *path, char *error,
                                           size_t error_size, void *audio_sink);
 XtMediaPlayerHandle xt_media_backend_by_id(uint64_t id);
 void xt_media_backend_shutdown(void);
+int xt_media_backend_decode_audio(const unsigned char *data, size_t size,
+                                  XtMediaAudioBuffer *out, char *error, size_t error_size);
+void xt_media_backend_free_audio(void *samples);
 
 #ifdef __cplusplus
 }