tiny.simd.Image

1pub fn Image(comptime T: type) type {2    validateComponent(T);3    return struct {4        xsize_value: u32,5        ysize_value: u32,6        bytes_per_row_value: usize,7        storage: []u8,8        owned: bool,910        const Self = @This();1112        pub fn empty() Self {13            return zeroDimensions(0, 0);14        }1516        fn zeroDimensions(width: usize, height: usize) Self {17            return .{18                .xsize_value = @intCast(width),19                .ysize_value = @intCast(height),20                .bytes_per_row_value = 0,21                .storage = &.{},22                .owned = false,23            };24        }2526        pub fn init(allocator: std.mem.Allocator, width: usize, height: usize) Error!Self {27            try validateDimensions(width, height);28            if (width == 0 or height == 0) return zeroDimensions(width, height);29            const stride = try bytesPerRowFor(width, @sizeOf(T), vector_size);30            const allocation_size = std.math.mul(usize, stride, height) catch31                return error.AllocationSizeOverflow;32            const storage = try allocator.alignedAlloc(33                u8,34                .fromByteUnits(storage_alignment),35                allocation_size,36            );37            var result = Self{38                .xsize_value = @intCast(width),39                .ysize_value = @intCast(height),40                .bytes_per_row_value = stride,41                .storage = storage,42                .owned = true,43            };44            result.initializePadding(.round_up) catch |err| {45                allocator.free(storage);46                return err;47            };48            return result;49        }5051        pub fn initBorrowed(52            width: usize,53            height: usize,54            stride: usize,55            storage: []u8,56        ) GeometryError!Self {57            try validateDimensions(width, height);58            if (width == 0 or height == 0) {59                if (stride != 0) return error.InvalidStride;60                return zeroDimensions(width, height);61            }62            if (stride % vector_size != 0 or stride % @alignOf(T) != 0) {63                return error.InvalidStride;64            }65            const valid_bytes = std.math.mul(usize, width, @sizeOf(T)) catch66                return error.RowSizeOverflow;67            if (stride < valid_bytes) return error.InvalidStride;68            const required = std.math.mul(usize, stride, height) catch69                return error.AllocationSizeOverflow;70            if (storage.len < required) return error.BufferTooSmall;71            if (@intFromPtr(storage.ptr) % @max(vector_size, @alignOf(T)) != 0) {72                return error.MisalignedStorage;73            }74            return .{75                .xsize_value = @intCast(width),76                .ysize_value = @intCast(height),77                .bytes_per_row_value = stride,78                .storage = storage[0..required],79                .owned = false,80            };81        }8283        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {84            if (self.owned) {85                std.debug.assert(self.storage.len != 0);86                const aligned: []align(storage_alignment) u8 = @alignCast(self.storage);87                allocator.free(aligned);88            }89            self.* = empty();90        }9192        pub fn swap(self: *Self, other: *Self) void {93            std.mem.swap(Self, self, other);94        }9596        pub fn shrinkTo(self: *Self, width: usize, height: usize) GeometryError!void {97            if (width > self.xsize_value or height > self.ysize_value) {98                return error.InvalidShrink;99            }100            self.xsize_value = @intCast(width);101            self.ysize_value = @intCast(height);102        }103104        pub fn initializePaddingForUnalignedAccesses(self: *Self) GeometryError!void {105            try self.initializePadding(.unaligned);106        }107108        pub fn xsize(self: *const Self) usize {109            return self.xsize_value;110        }111112        pub fn ysize(self: *const Self) usize {113            return self.ysize_value;114        }115116        pub fn bytesPerRow(self: *const Self) usize {117            return self.bytes_per_row_value;118        }119120        pub fn pixelsPerRow(self: *const Self) usize {121            return self.bytes_per_row_value / @sizeOf(T);122        }123124        pub fn bytes(self: *Self) []u8 {125            return self.storage;126        }127128        pub fn constBytes(self: *const Self) []const u8 {129            return self.storage;130        }131132        pub fn constRow(self: *const Self, y: usize) []const T {133            std.debug.assert(y < self.ysize_value);134            if (self.bytes_per_row_value == 0) return &.{};135            const begin = y * self.bytes_per_row_value;136            const row = self.storage[begin..][0..self.bytes_per_row_value];137            const ptr: [*]const T = @ptrCast(@alignCast(row.ptr));138            return ptr[0..self.pixelsPerRow()];139        }140141        pub fn mutableRow(self: *const Self, y: usize) []T {142            std.debug.assert(y < self.ysize_value);143            if (self.bytes_per_row_value == 0) return &.{};144            const begin = y * self.bytes_per_row_value;145            const row = self.storage[begin..][0..self.bytes_per_row_value];146            const ptr: [*]T = @ptrCast(@alignCast(row.ptr));147            return ptr[0..self.pixelsPerRow()];148        }149150        fn initializePadding(self: *Self, mode: Padding) GeometryError!void {151            if (self.xsize_value == 0 or self.ysize_value == 0 or vector_size == 1) return;152            const valid_bytes = std.math.mul(153                usize,154                self.xsize_value,155                @sizeOf(T),156            ) catch return error.RowSizeOverflow;157            const initialize_size = switch (mode) {158                .round_up => try roundUp(valid_bytes, vector_size),159                .unaligned => std.math.add(160                    usize,161                    valid_bytes,162                    vector_size - @sizeOf(T),163                ) catch return error.RowSizeOverflow,164            };165            if (initialize_size > self.bytes_per_row_value) {166                return error.InsufficientRowPadding;167            }168            for (0..self.ysize_value) |y| {169                const begin = y * self.bytes_per_row_value + valid_bytes;170                @memset(self.storage[begin..][0 .. initialize_size - valid_bytes], 0);171            }172        }173    };174}

1pub const Image = image.Image;