xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/dom_api_webgl_compressed.cpp

@@ -0,0 +1,167 @@
+/*
+ * xbintsc GUI engine — compressed-texture WebGL bindings.
+ *
+ * `getExtension` publishes the S3TC/ASTC enum objects only when the device can
+ * sample the format, and `compressedTexImage2D` / `compressedTexSubImage2D`
+ * hand the tightly packed blocks to `webgl_compressed.cpp`.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "webgl.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+namespace {
+
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
+
+uint32_t texture_argument(xt_value value) { return webgl_object_id(value, "__xt_gl_texture"); }
+
+std::vector<uint8_t> compressed_bytes(int32_t argc, xt_value *argv, int32_t data_index,
+                                      int32_t offset_index, int32_t length_index) {
+  std::vector<uint8_t> bytes = webgl_bytes(xt_arg(argc, argv, data_index));
+  const uint32_t offset = (uint32_t)webgl_number(argc, argv, offset_index, 0.0);
+  uint32_t length = (uint32_t)webgl_number(argc, argv, length_index, (double)bytes.size());
+  if (offset > bytes.size()) return std::vector<uint8_t>();
+  if (length > bytes.size() - offset) length = (uint32_t)bytes.size() - offset;
+  return std::vector<uint8_t>(bytes.begin() + offset, bytes.begin() + offset + length);
+}
+
+void add_constant(xt_value object, const char *name, int value) {
+  xt_object_set(object, xt_string_from_cstr(name), xt_number((double)value));
+}
+
+}  // namespace
+
+METHOD(webgl_compressed_tex_image_2d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const uint32_t texture = context->bound_texture(0);
+  if (texture == 0) return XT_UNDEFINED;
+  const int level = webgl_int(argc, argv, 1, 0);
+  if (level != 0) return XT_UNDEFINED;
+  const int internalformat = webgl_int(argc, argv, 2, 0);
+  const SDL_GPUTextureFormat format = xtgui::webgl_compressed_format(internalformat);
+  if (format == SDL_GPU_TEXTUREFORMAT_INVALID) {
+    context->set_error(GL_INVALID_ENUM);
+    return XT_UNDEFINED;
+  }
+  const int width = webgl_int(argc, argv, 3, 0);
+  const int height = webgl_int(argc, argv, 4, 0);
+  const std::vector<uint8_t> data = compressed_bytes(argc, argv, 6, 7, 8);
+  context->tex_image_compressed(texture, width, height, format, 0, 0, width, height,
+                                data.empty() ? nullptr : data.data(), (uint32_t)data.size());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_compressed_tex_sub_image_2d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const uint32_t texture = context->bound_texture(0);
+  if (texture == 0) return XT_UNDEFINED;
+  const int internalformat = webgl_int(argc, argv, 6, 0);
+  const SDL_GPUTextureFormat format = xtgui::webgl_compressed_format(internalformat);
+  if (format == SDL_GPU_TEXTUREFORMAT_INVALID) {
+    context->set_error(GL_INVALID_ENUM);
+    return XT_UNDEFINED;
+  }
+  const int x = webgl_int(argc, argv, 2, 0);
+  const int y = webgl_int(argc, argv, 3, 0);
+  const int width = webgl_int(argc, argv, 4, 0);
+  const int height = webgl_int(argc, argv, 5, 0);
+  const std::vector<uint8_t> data = compressed_bytes(argc, argv, 7, 8, 9);
+  context->tex_image_compressed(texture, context->texture_width(texture),
+                                context->texture_height(texture), format, x, y, width, height,
+                                data.empty() ? nullptr : data.data(), (uint32_t)data.size());
+  return XT_UNDEFINED;
+}
+
+/** `getExtension` for the compressed-texture families; returns null when the
+ * device cannot sample the representative format, and undefined when `name` is
+ * not a compressed-texture extension. */
+xt_value webgl_compressed_extension(const std::string &name, xtgui::WebGLContext *context) {
+  struct CompressedConstant {
+    const char *name;
+    int value;
+  };
+  static const CompressedConstant kS3tc[] = {
+      {"COMPRESSED_RGB_S3TC_DXT1_EXT", 0x83F0},
+      {"COMPRESSED_RGBA_S3TC_DXT1_EXT", 0x83F1},
+      {"COMPRESSED_RGBA_S3TC_DXT3_EXT", 0x83F2},
+      {"COMPRESSED_RGBA_S3TC_DXT5_EXT", 0x83F3},
+  };
+  static const CompressedConstant kS3tcSrgb[] = {
+      {"COMPRESSED_SRGB_S3TC_DXT1_EXT", 0x8C4C},
+      {"COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT", 0x8C4D},
+      {"COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT", 0x8C4E},
+      {"COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT", 0x8C4F},
+  };
+  static const CompressedConstant kAstc[] = {
+      {"COMPRESSED_RGBA_ASTC_4x4_KHR", 0x93B0},
+      {"COMPRESSED_RGBA_ASTC_5x4_KHR", 0x93B1},
+      {"COMPRESSED_RGBA_ASTC_5x5_KHR", 0x93B2},
+      {"COMPRESSED_RGBA_ASTC_6x5_KHR", 0x93B3},
+      {"COMPRESSED_RGBA_ASTC_6x6_KHR", 0x93B4},
+      {"COMPRESSED_RGBA_ASTC_8x5_KHR", 0x93B5},
+      {"COMPRESSED_RGBA_ASTC_8x6_KHR", 0x93B6},
+      {"COMPRESSED_RGBA_ASTC_8x8_KHR", 0x93B7},
+      {"COMPRESSED_RGBA_ASTC_10x5_KHR", 0x93B8},
+      {"COMPRESSED_RGBA_ASTC_10x6_KHR", 0x93B9},
+      {"COMPRESSED_RGBA_ASTC_10x8_KHR", 0x93BA},
+      {"COMPRESSED_RGBA_ASTC_10x10_KHR", 0x93BB},
+      {"COMPRESSED_RGBA_ASTC_12x10_KHR", 0x93BC},
+      {"COMPRESSED_RGBA_ASTC_12x12_KHR", 0x93BD},
+  };
+  static const CompressedConstant kAstcSrgb[] = {
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", 0x93D0},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", 0x93D1},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", 0x93D2},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", 0x93D3},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", 0x93D4},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", 0x93D5},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", 0x93D6},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", 0x93D7},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", 0x93D8},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", 0x93D9},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", 0x93DA},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", 0x93DB},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", 0x93DC},
+      {"COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", 0x93DD},
+  };
+  if (context == nullptr) return XT_NULL;
+  xt_value object = xt_object_new();
+  int representative = 0;
+  const CompressedConstant *table = kS3tc;
+  size_t count = sizeof(kS3tc) / sizeof(kS3tc[0]);
+  if (name == "WEBGL_compressed_texture_s3tc") {
+    representative = 0x83F1;
+  } else if (name == "WEBGL_compressed_texture_s3tc_srgb") {
+    table = kS3tcSrgb;
+    count = sizeof(kS3tcSrgb) / sizeof(kS3tcSrgb[0]);
+    representative = 0x8C4D;
+  } else if (name == "WEBGL_compressed_texture_astc") {
+    table = kAstc;
+    count = sizeof(kAstc) / sizeof(kAstc[0]);
+    representative = 0x93B0;
+  } else {
+    return XT_UNDEFINED;
+  }
+  if (!context->supports_texture_format(representative)) return XT_NULL;
+  for (size_t i = 0; i < count; i++) add_constant(object, table[i].name, table[i].value);
+  if (name == "WEBGL_compressed_texture_astc") {
+    /* The ASTC extension publishes both LDR and sRGB enums. */
+    for (size_t i = 0; i < sizeof(kAstcSrgb) / sizeof(kAstcSrgb[0]); i++) {
+      add_constant(object, kAstcSrgb[i].name, kAstcSrgb[i].value);
+    }
+  }
+  return object;
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_webgl_framebuffer.cpp

@@ -0,0 +1,160 @@
+/*
+ * xbintsc GUI engine — WebGL framebuffer, renderbuffer and readback bindings.
+ *
+ * Textures live in `dom_api_webgl_texture.cpp`; this unit owns the objects that
+ * render into them, plus `readPixels`.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "dom_api_webgl_rt.h"
+#include "webgl.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+namespace {
+
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
+
+uint32_t texture_argument(xt_value value) { return webgl_object_id(value, "__xt_gl_texture"); }
+
+}  // namespace
+
+/* -- framebuffers and renderbuffers -------------------------------------- */
+
+METHOD(webgl_create_framebuffer) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_framebuffer", context->create_framebuffer(),
+                           "framebuffer");
+}
+
+METHOD(webgl_delete_framebuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->delete_framebuffer(webgl_object_id(xt_arg(argc, argv, 0), "__xt_gl_framebuffer"));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_bind_framebuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->bind_framebuffer(webgl_int(argc, argv, 0, GL_FRAMEBUFFER),
+                              webgl_object_id(xt_arg(argc, argv, 1), "__xt_gl_framebuffer"));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_framebuffer_texture_2d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    /* WebGL's first argument is the target (`FRAMEBUFFER`), not the object:
+     * the texture attaches to the currently bound framebuffer. */
+    context->framebuffer_texture(context->bound_framebuffer_id(),
+                                 texture_argument(xt_arg(argc, argv, 3)),
+                                 webgl_int(argc, argv, 1, GL_COLOR_ATTACHMENT0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_check_framebuffer_status) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return xt_number(GL_FRAMEBUFFER_COMPLETE);
+  const uint32_t framebuffer = context->bound_framebuffer_id();
+  if (framebuffer == 0) return xt_number(GL_FRAMEBUFFER_COMPLETE);
+  return xt_number(context->framebuffer_status(framebuffer) ? GL_FRAMEBUFFER_COMPLETE
+                                                            : GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
+}
+
+METHOD(webgl_create_renderbuffer) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_renderbuffer", context->create_renderbuffer(),
+                           "renderbuffer");
+}
+
+METHOD(webgl_delete_renderbuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->delete_renderbuffer(webgl_object_id(xt_arg(argc, argv, 0), "__xt_gl_renderbuffer"));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_bind_renderbuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->bind_renderbuffer(webgl_object_id(xt_arg(argc, argv, 1), "__xt_gl_renderbuffer"));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_renderbuffer_storage) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->renderbuffer_storage(context->bound_renderbuffer_id(), webgl_int(argc, argv, 3, 0),
+                                  webgl_int(argc, argv, 4, 0), false);
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_framebuffer_renderbuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->framebuffer_renderbuffer(
+        context->bound_framebuffer_id(),
+        webgl_object_id(xt_arg(argc, argv, 3), "__xt_gl_renderbuffer"));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl_get_renderbuffer_parameter) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return xt_number(0);
+  xtgui::WebGLRenderbuffer *renderbuffer = context->renderbuffer(context->bound_renderbuffer_id());
+  if (renderbuffer == nullptr) return xt_number(0);
+  const int pname = webgl_int(argc, argv, 1, 0);
+  if (pname == GL_RENDERBUFFER_WIDTH) return xt_number(renderbuffer->width);
+  if (pname == GL_RENDERBUFFER_HEIGHT) return xt_number(renderbuffer->height);
+  return xt_number(0);
+}
+
+METHOD(webgl_read_pixels) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const int x = webgl_int(argc, argv, 0, 0);
+  const int y = webgl_int(argc, argv, 1, 0);
+  const int width = webgl_int(argc, argv, 2, 0);
+  const int height = webgl_int(argc, argv, 3, 0);
+  const int format = webgl_int(argc, argv, 4, GL_RGBA);
+  const int type = webgl_int(argc, argv, 5, GL_UNSIGNED_BYTE);
+  if (format != GL_RGBA || type != GL_UNSIGNED_BYTE) return XT_UNDEFINED;
+  std::vector<uint8_t> pixels((size_t)width * height * 4);
+  if (!context->read_pixels(x, y, width, height, pixels.data())) return XT_UNDEFINED;
+  webgl_write_bytes(xt_arg(argc, argv, 6), pixels.data(), pixels.size());
+  return XT_UNDEFINED;
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_webgl_shader.cpp

@@ -14,7 +14,7 @@
 namespace domapi {
 namespace {
 
-xtgui::WebGLContext *context_of(xt_value self) { return webgl_from_context(self); }
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
 
 xt_value shader_argument(xt_value value) {
   return webgl_object_id(value, "__xt_gl_shader");
@@ -295,7 +295,7 @@ METHOD(webgl_get_uniform) {
 namespace {
 
 void uniform_scalars(xt_value self, int32_t argc, xt_value *argv, int components, bool integer) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   uint32_t program = 0;
   int location = 0;
@@ -312,7 +312,7 @@ void uniform_scalars(xt_value self, int32_t argc, xt_value *argv, int components
 }
 
 void uniform_vectors(xt_value self, int32_t argc, xt_value *argv, int components, bool integer) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   uint32_t program = 0;
   int location = 0;
@@ -400,7 +400,7 @@ METHOD(webgl_uniform4iv) {
 namespace {
 
 void uniform_matrix(xt_value self, int32_t argc, xt_value *argv, int dimensions) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   uint32_t program = 0;
   int location = 0;

package/runtime/ext_gui/dom_api_webgl_source.cpp

@@ -0,0 +1,161 @@
+/*
+ * xbintsc GUI engine — WebGL pixel sources.
+ *
+ * Decodes the things `texImage2D` accepts (`<img>`, `<canvas>`, `<video>`,
+ * `ImageData` and `ImageBitmap`) into tightly packed RGBA8, and converts the
+ * RGBA/RGB/LUMINANCE families to that layout.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "dom_api_webgl_rt.h"
+#include "image.h"
+#include "image_bitmap.h"
+#include "webgl.h"
+
+namespace domapi {
+namespace {
+
+void flip_rows(std::vector<uint8_t> *pixels, int width, int height) {
+  const size_t stride = (size_t)width * 4;
+  std::vector<uint8_t> row(stride);
+  for (int y = 0; y < height / 2; y++) {
+    uint8_t *top = pixels->data() + (size_t)y * stride;
+    uint8_t *bottom = pixels->data() + (size_t)(height - 1 - y) * stride;
+    memcpy(row.data(), top, stride);
+    memcpy(top, bottom, stride);
+    memcpy(bottom, row.data(), stride);
+  }
+}
+
+}  // namespace
+
+void webgl_convert_pixels(const uint8_t *source, int count, int format, bool premultiply,
+                    std::vector<uint8_t> *out) {
+  out->assign((size_t)count * 4, 255);
+  for (int i = 0; i < count; i++) {
+    uint8_t r = 0;
+    uint8_t g = 0;
+    uint8_t b = 0;
+    uint8_t a = 255;
+    switch (format) {
+      case GL_RGBA:
+        r = source[i * 4 + 0];
+        g = source[i * 4 + 1];
+        b = source[i * 4 + 2];
+        a = source[i * 4 + 3];
+        break;
+      case GL_RGB:
+        r = source[i * 3 + 0];
+        g = source[i * 3 + 1];
+        b = source[i * 3 + 2];
+        break;
+      case GL_LUMINANCE_ALPHA:
+        r = g = b = source[i * 2 + 0];
+        a = source[i * 2 + 1];
+        break;
+      case GL_ALPHA:
+        a = source[i];
+        r = g = b = 0;
+        break;
+      case GL_LUMINANCE:
+      default:
+        r = g = b = source[i];
+        break;
+    }
+    if (premultiply) {
+      r = (uint8_t)((r * a + 127) / 255);
+      g = (uint8_t)((g * a + 127) / 255);
+      b = (uint8_t)((b * a + 127) / 255);
+    }
+    (*out)[(size_t)i * 4 + 0] = r;
+    (*out)[(size_t)i * 4 + 1] = g;
+    (*out)[(size_t)i * 4 + 2] = b;
+    (*out)[(size_t)i * 4 + 3] = a;
+  }
+}
+
+
+/** Decode a DOM source into top-down RGBA8. */
+bool webgl_read_source(xt_value source, int *width, int *height, std::vector<uint8_t> *rgba,
+                 bool premultiply) {
+  if (XT_IS_OBJECT(source)) {
+    xt_value bitmap_id = xt_object_get_cstr(source, "__xt_bitmap");
+    if (XT_IS_NUMBER(bitmap_id)) {
+      const xtgui::Image *bitmap =
+          xtgui::xt_image_bitmap_get((uint64_t)xt_to_number(bitmap_id));
+      if (bitmap == nullptr || bitmap->width <= 0 || bitmap->height <= 0) return false;
+      *width = bitmap->width;
+      *height = bitmap->height;
+      if (premultiply) {
+        webgl_convert_pixels(bitmap->pixels.data(), bitmap->width * bitmap->height, GL_RGBA, true,
+                       rgba);
+      } else {
+        *rgba = bitmap->pixels;
+      }
+      return true;
+    }
+  }
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(source, &win);
+  const xtgui::Image *image = nullptr;
+  std::vector<uint8_t> owned;
+  if (node != nullptr && node->isElement() && node->isTag("img")) {
+    const std::string *src = node->attr("src");
+    if (src != nullptr) image = xtgui::xt_image_load(*src);
+  } else if (node != nullptr && node->isElement() && node->isTag("video")) {
+    xtgui::MediaPlayer *player = xt_gui_media_player(win, node);
+    if (player != nullptr) image = player->frame();
+  } else if (node != nullptr && node->isElement() && node->isTag("canvas")) {
+    if (xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node)) {
+      image = &canvas->image();
+    } else if (xtgui::WebGLContext *context = xt_gui_webgl_find(win, node)) {
+      owned.resize((size_t)context->width() * context->height() * 4);
+      if (!context->read_pixels(0, 0, context->width(), context->height(), owned.data())) {
+        return false;
+      }
+      /* `readPixels` is GL-ordered (bottom-up); textures are stored top-down. */
+      flip_rows(&owned, context->width(), context->height());
+      *width = context->width();
+      *height = context->height();
+      rgba->swap(owned);
+      return true;
+    }
+  } else if (XT_IS_OBJECT(source) && !xt_is_array_buffer(source)) {
+    xt_value data = xt_object_get_cstr(source, "data");
+    xt_value width_value = xt_object_get_cstr(source, "width");
+    xt_value height_value = xt_object_get_cstr(source, "height");
+    if (XT_IS_OBJECT(data) && XT_IS_NUMBER(width_value) && XT_IS_NUMBER(height_value)) {
+      const int w = (int)xt_to_number(width_value);
+      const int h = (int)xt_to_number(height_value);
+      const std::vector<uint8_t> bytes = webgl_bytes(data);
+      if (w <= 0 || h <= 0 || bytes.size() < (size_t)w * h * 4) return false;
+      webgl_convert_pixels(bytes.data(), w * h, GL_RGBA, premultiply, rgba);
+      *width = w;
+      *height = h;
+      return true;
+    }
+    /* `new Image()` is a plain object with a `src`. */
+    xt_value src = xt_object_get_cstr(source, "src");
+    if (XT_IS_STRING(src)) {
+      const char *path = xt_string_data(xt_to_string(src));
+      if (path != nullptr && path[0] != '\0') image = xtgui::xt_image_load(path);
+    }
+  }
+  if (image == nullptr || image->width <= 0 || image->height <= 0) return false;
+  *width = image->width;
+  *height = image->height;
+  if (premultiply) {
+    webgl_convert_pixels(image->pixels.data(), image->width * image->height, GL_RGBA, true, rgba);
+  } else {
+    *rgba = image->pixels;
+  }
+  return true;
+}
+
+
+}  // namespace domapi