texel 0.1.0

data/ext/texel/texel_native.c

@@ -0,0 +1,415 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "shim.h"
+
+#define TX_GVL_PIXEL_THRESHOLD 1000000
+/* Larger than the embedded String capacity of every supported Ruby. */
+#define TX_GVL_OUTPUT_THRESHOLD 128
+
+typedef struct {
+    const void *input;
+    int input_length;
+    int requested_channels;
+    int dtype;
+    int width;
+    int height;
+    int source_channels;
+    void *pixels;
+    const char *error;
+} tx_decode_args;
+
+typedef struct {
+    unsigned char *data;
+    size_t length;
+    size_t capacity;
+    int failed;
+} tx_buffer;
+
+typedef struct {
+    int format;
+    tx_buffer *buffer;
+    int width;
+    int height;
+    int channels;
+    const void *pixels;
+    int quality_or_stride;
+    int result;
+} tx_encode_args;
+
+typedef struct {
+    int dtype;
+    int srgb;
+    const void *source;
+    int source_width;
+    int source_height;
+    void *destination;
+    int width;
+    int height;
+    int channels;
+    int filter;
+    int edge;
+    int premultiplied;
+    int result;
+} tx_resize_args;
+
+typedef struct {
+    const void *source;
+    uint16_t *destination;
+    size_t count;
+} tx_f16_args;
+
+static size_t
+tx_checked_image_size(int width, int height, int channels, size_t component_size)
+{
+    size_t value;
+    if (width <= 0 || height <= 0 || channels <= 0 || channels > 4) {
+        rb_raise(rb_eArgError, "invalid image dimensions or channel count");
+    }
+    value = (size_t)width;
+    if (value > SIZE_MAX / (size_t)height) {
+        rb_raise(rb_eArgError, "image dimensions are too large");
+    }
+    value *= (size_t)height;
+    if (value > SIZE_MAX / (size_t)channels) {
+        rb_raise(rb_eArgError, "image dimensions are too large");
+    }
+    value *= (size_t)channels;
+    if (value > SIZE_MAX / component_size || value * component_size > LONG_MAX) {
+        rb_raise(rb_eArgError, "image data is too large");
+    }
+    return value * component_size;
+}
+
+static size_t
+tx_component_size(int dtype)
+{
+    switch (dtype) {
+        case 0:
+            return 1;
+        case 1:
+            return 2;
+        case 2:
+            return 4;
+        default:
+            rb_raise(rb_eArgError, "invalid pixel dtype");
+    }
+}
+
+static void *
+tx_decode_without_gvl(void *pointer)
+{
+    tx_decode_args *args = (tx_decode_args *)pointer;
+    switch (args->dtype) {
+        case 0:
+            args->pixels = tx_load_u8(args->input, args->input_length, &args->width, &args->height,
+                                      &args->source_channels, args->requested_channels, &args->error);
+            break;
+        case 1:
+            args->pixels = tx_load_u16(args->input, args->input_length, &args->width, &args->height,
+                                       &args->source_channels, args->requested_channels, &args->error);
+            break;
+        case 2:
+            args->pixels = tx_load_f32(args->input, args->input_length, &args->width, &args->height,
+                                       &args->source_channels, args->requested_channels, &args->error);
+            break;
+    }
+    return NULL;
+}
+
+static VALUE
+tx_rb_metadata(VALUE self, VALUE input)
+{
+    int width = 0;
+    int height = 0;
+    int channels = 0;
+    long length;
+    VALUE result;
+    (void)self;
+
+    Check_Type(input, T_STRING);
+    length = RSTRING_LEN(input);
+    if (length > INT_MAX) {
+        rb_raise(rb_eArgError, "encoded image is too large");
+    }
+    if (!tx_info(RSTRING_PTR(input), (int)length, &width, &height, &channels)) {
+        rb_raise(rb_eRuntimeError, "unsupported or corrupt image header");
+    }
+
+    result = rb_ary_new_capa(5);
+    rb_ary_push(result, INT2NUM(width));
+    rb_ary_push(result, INT2NUM(height));
+    rb_ary_push(result, INT2NUM(channels));
+    rb_ary_push(result, tx_is_16_bit(RSTRING_PTR(input), (int)length) ? Qtrue : Qfalse);
+    rb_ary_push(result, tx_is_hdr(RSTRING_PTR(input), (int)length) ? Qtrue : Qfalse);
+    return result;
+}
+
+static VALUE
+tx_rb_decode(VALUE self, VALUE input, VALUE requested_channels_value, VALUE dtype_value)
+{
+    tx_decode_args args;
+    int info_width = 0;
+    int info_height = 0;
+    int info_channels = 0;
+    int output_channels;
+    long input_length;
+    size_t output_length;
+    VALUE output;
+    (void)self;
+
+    Check_Type(input, T_STRING);
+    input_length = RSTRING_LEN(input);
+    if (input_length > INT_MAX) {
+        rb_raise(rb_eArgError, "encoded image is too large");
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.input = RSTRING_PTR(input);
+    args.input_length = (int)input_length;
+    args.requested_channels = NUM2INT(requested_channels_value);
+    args.dtype = NUM2INT(dtype_value);
+    (void)tx_component_size(args.dtype);
+    if (args.requested_channels < 0 || args.requested_channels > 4) {
+        rb_raise(rb_eArgError, "requested channels must be between 0 and 4");
+    }
+
+    if (tx_info(args.input, args.input_length, &info_width, &info_height, &info_channels) &&
+        (size_t)info_width * (size_t)info_height >= TX_GVL_PIXEL_THRESHOLD) {
+        rb_thread_call_without_gvl(tx_decode_without_gvl, &args, NULL, NULL);
+    } else {
+        tx_decode_without_gvl(&args);
+    }
+    if (args.pixels == NULL) {
+        rb_raise(rb_eRuntimeError, "%s", args.error != NULL ? args.error : "image decode failed");
+    }
+
+    output_channels = args.requested_channels == 0 ? args.source_channels : args.requested_channels;
+    output_length = tx_checked_image_size(args.width, args.height, output_channels,
+                                          tx_component_size(args.dtype));
+    /* stb owns this allocation, so copy it once into Ruby-managed storage. */
+    output = rb_str_new((const char *)args.pixels, (long)output_length);
+    tx_free(args.pixels);
+    rb_enc_associate_index(output, rb_ascii8bit_encindex());
+    rb_obj_freeze(output);
+    RB_GC_GUARD(input);
+    return output;
+}
+
+static void
+tx_append_bytes(void *user_data, void *data, int size)
+{
+    tx_buffer *buffer = (tx_buffer *)user_data;
+    size_t required;
+    size_t capacity;
+    unsigned char *replacement;
+    if (buffer->failed || size < 0) {
+        buffer->failed = 1;
+        return;
+    }
+    required = buffer->length + (size_t)size;
+    if (required < buffer->length) {
+        buffer->failed = 1;
+        return;
+    }
+    if (required > buffer->capacity) {
+        capacity = buffer->capacity == 0 ? 4096 : buffer->capacity;
+        while (capacity < required) {
+            if (capacity > SIZE_MAX / 2) {
+                capacity = required;
+                break;
+            }
+            capacity *= 2;
+        }
+        replacement = (unsigned char *)realloc(buffer->data, capacity);
+        if (replacement == NULL) {
+            buffer->failed = 1;
+            return;
+        }
+        buffer->data = replacement;
+        buffer->capacity = capacity;
+    }
+    memcpy(buffer->data + buffer->length, data, (size_t)size);
+    buffer->length = required;
+}
+
+static void *
+tx_encode_without_gvl(void *pointer)
+{
+    tx_encode_args *args = (tx_encode_args *)pointer;
+    args->result = tx_write(args->format, tx_append_bytes, args->buffer, args->width, args->height,
+                            args->channels, args->pixels, args->quality_or_stride);
+    return NULL;
+}
+
+static VALUE
+tx_rb_encode(VALUE self, VALUE input, VALUE format_value, VALUE width_value, VALUE height_value,
+             VALUE channels_value, VALUE dtype_value, VALUE quality_value)
+{
+    tx_buffer buffer = {0};
+    tx_encode_args args;
+    int dtype;
+    size_t expected_length;
+    VALUE output;
+    (void)self;
+
+    Check_Type(input, T_STRING);
+    memset(&args, 0, sizeof(args));
+    dtype = NUM2INT(dtype_value);
+    args.format = NUM2INT(format_value);
+    args.buffer = &buffer;
+    args.width = NUM2INT(width_value);
+    args.height = NUM2INT(height_value);
+    args.channels = NUM2INT(channels_value);
+    args.pixels = RSTRING_PTR(input);
+    args.quality_or_stride = NUM2INT(quality_value);
+    expected_length = tx_checked_image_size(args.width, args.height, args.channels,
+                                            tx_component_size(dtype));
+    if ((size_t)RSTRING_LEN(input) != expected_length) {
+        rb_raise(rb_eArgError, "pixel data length does not match image dimensions");
+    }
+    if ((args.format == 4 && dtype != 2) || (args.format != 4 && dtype != 0)) {
+        rb_raise(rb_eArgError, "pixel dtype is incompatible with output format");
+    }
+
+    if ((size_t)args.width * (size_t)args.height >= TX_GVL_PIXEL_THRESHOLD) {
+        rb_thread_call_without_gvl(tx_encode_without_gvl, &args, NULL, NULL);
+    } else {
+        tx_encode_without_gvl(&args);
+    }
+    if (!args.result || buffer.failed) {
+        free(buffer.data);
+        rb_raise(rb_eRuntimeError, "image encode failed");
+    }
+    if (buffer.length > LONG_MAX) {
+        free(buffer.data);
+        rb_raise(rb_eRuntimeError, "encoded image is too large");
+    }
+    output = rb_str_new((const char *)buffer.data, (long)buffer.length);
+    free(buffer.data);
+    rb_enc_associate_index(output, rb_ascii8bit_encindex());
+    rb_obj_freeze(output);
+    RB_GC_GUARD(input);
+    return output;
+}
+
+static void *
+tx_resize_without_gvl(void *pointer)
+{
+    tx_resize_args *args = (tx_resize_args *)pointer;
+    args->result = tx_resize(args->dtype, args->srgb, args->source,
+                             args->source_width, args->source_height,
+                             args->destination, args->width, args->height,
+                             args->channels, args->filter, args->edge,
+                             args->premultiplied);
+    return NULL;
+}
+
+static VALUE
+tx_rb_resize(VALUE self, VALUE input, VALUE source_width_value, VALUE source_height_value,
+             VALUE width_value, VALUE height_value, VALUE channels_value, VALUE dtype_value,
+             VALUE srgb_value, VALUE filter_value, VALUE edge_value, VALUE premultiplied_value)
+{
+    tx_resize_args args;
+    size_t input_length;
+    size_t output_length;
+    VALUE output;
+    (void)self;
+
+    Check_Type(input, T_STRING);
+    memset(&args, 0, sizeof(args));
+    args.dtype = NUM2INT(dtype_value);
+    args.srgb = RTEST(srgb_value);
+    args.source = RSTRING_PTR(input);
+    args.source_width = NUM2INT(source_width_value);
+    args.source_height = NUM2INT(source_height_value);
+    args.width = NUM2INT(width_value);
+    args.height = NUM2INT(height_value);
+    args.channels = NUM2INT(channels_value);
+    args.filter = NUM2INT(filter_value);
+    args.edge = NUM2INT(edge_value);
+    args.premultiplied = RTEST(premultiplied_value);
+
+    input_length = tx_checked_image_size(args.source_width, args.source_height, args.channels,
+                                         tx_component_size(args.dtype));
+    output_length = tx_checked_image_size(args.width, args.height, args.channels,
+                                          tx_component_size(args.dtype));
+    if ((size_t)RSTRING_LEN(input) != input_length) {
+        rb_raise(rb_eArgError, "pixel data length does not match image dimensions");
+    }
+    output = rb_str_new(NULL, (long)output_length);
+    args.destination = RSTRING_PTR(output);
+
+    if ((size_t)args.source_width * (size_t)args.source_height >= TX_GVL_PIXEL_THRESHOLD &&
+        output_length >= TX_GVL_OUTPUT_THRESHOLD) {
+        rb_thread_call_without_gvl(tx_resize_without_gvl, &args, NULL, NULL);
+    } else {
+        tx_resize_without_gvl(&args);
+    }
+    if (!args.result) {
+        rb_raise(rb_eRuntimeError, "pixel resize failed");
+    }
+    rb_enc_associate_index(output, rb_ascii8bit_encindex());
+    rb_obj_freeze(output);
+    RB_GC_GUARD(input);
+    RB_GC_GUARD(output);
+    return output;
+}
+
+static void *
+tx_f16_without_gvl(void *pointer)
+{
+    tx_f16_args *args = (tx_f16_args *)pointer;
+    tx_f32_to_f16(args->source, args->destination, args->count);
+    return NULL;
+}
+
+static VALUE
+tx_rb_pack_f16(VALUE self, VALUE input)
+{
+    tx_f16_args args;
+    long input_length;
+    size_t output_length;
+    VALUE output;
+    (void)self;
+
+    Check_Type(input, T_STRING);
+    input_length = RSTRING_LEN(input);
+    if (input_length % (long)sizeof(float) != 0) {
+        rb_raise(rb_eArgError, "f32 data length must be a multiple of 4");
+    }
+    args.source = RSTRING_PTR(input);
+    args.count = (size_t)input_length / sizeof(float);
+    output_length = args.count * sizeof(uint16_t);
+    output = rb_str_new(NULL, (long)output_length);
+    args.destination = (uint16_t *)RSTRING_PTR(output);
+
+    if (args.count >= TX_GVL_PIXEL_THRESHOLD) {
+        rb_thread_call_without_gvl(tx_f16_without_gvl, &args, NULL, NULL);
+    } else {
+        tx_f16_without_gvl(&args);
+    }
+    rb_enc_associate_index(output, rb_ascii8bit_encindex());
+    rb_obj_freeze(output);
+    RB_GC_GUARD(input);
+    RB_GC_GUARD(output);
+    return output;
+}
+
+void
+Init_texel_native(void)
+{
+    VALUE texel = rb_define_module("Texel");
+    VALUE bridge = rb_define_module_under(texel, "NativeBridge");
+    rb_define_singleton_method(bridge, "metadata", tx_rb_metadata, 1);
+    rb_define_singleton_method(bridge, "decode", tx_rb_decode, 3);
+    rb_define_singleton_method(bridge, "encode", tx_rb_encode, 7);
+    rb_define_singleton_method(bridge, "resize", tx_rb_resize, 11);
+    rb_define_singleton_method(bridge, "pack_f16", tx_rb_pack_f16, 1);
+}

data/ext/texel/vendor/README.md

@@ -0,0 +1,11 @@
+# Vendored stb headers
+
+These headers are vendored from the public `nothings/stb` repository:
+
+- `stb_image.h`
+- `stb_image_write.h`
+- `stb_image_resize2.h`
+
+Each header includes its upstream Public Domain/MIT dual-license notice. Keeping
+the headers in the gem makes the native extension build independent of system
+packages.