tiny.simd.Image3

1pub fn Image3(comptime T: type) type {2    const ImageT = Image(T);3    return struct {4        planes: [3]ImageT,5        packed_storage: []u8,6        packing: Packing,78        const Self = @This();9        pub const num_planes: usize = 3;1011        pub fn empty() Self {12            return .{13                .planes = .{ ImageT.empty(), ImageT.empty(), ImageT.empty() },14                .packed_storage = &.{},15                .packing = .none,16            };17        }1819        pub fn init(allocator: std.mem.Allocator, width: usize, height: usize) Error!Self {20            try validateDimensions(width, height);21            if (width == 0 or height == 0) {22                return .{23                    .planes = .{24                        ImageT.zeroDimensions(width, height),25                        ImageT.zeroDimensions(width, height),26                        ImageT.zeroDimensions(width, height),27                    },28                    .packed_storage = &.{},29                    .packing = .none,30                };31            }32            const stride = try bytesPerRowFor(width, @sizeOf(T), vector_size);33            const plane_size = std.math.mul(usize, stride, height) catch34                return error.AllocationSizeOverflow;35            const allocation_size = std.math.mul(usize, plane_size, num_planes) catch36                return error.AllocationSizeOverflow;37            const storage = try allocator.alignedAlloc(38                u8,39                .fromByteUnits(storage_alignment),40                allocation_size,41            );42            errdefer allocator.free(storage);43            var result = empty();44            result.packed_storage = storage;45            result.packing = .owned;46            for (&result.planes, 0..) |*current_plane, index| {47                const begin = index * plane_size;48                current_plane.* = try ImageT.initBorrowed(49                    width,50                    height,51                    stride,52                    storage[begin..][0..plane_size],53                );54                try current_plane.initializePadding(.round_up);55            }56            return result;57        }5859        pub fn initBorrowed(60            width: usize,61            height: usize,62            stride: usize,63            buffers: [num_planes][]u8,64        ) GeometryError!Self {65            var result = empty();66            for (&result.planes, buffers) |*current_plane, buffer| {67                current_plane.* = try ImageT.initBorrowed(width, height, stride, buffer);68            }69            return result;70        }7172        pub fn initPlanes(73            plane0: *ImageT,74            plane1: *ImageT,75            plane2: *ImageT,76        ) GeometryError!Self {77            if (plane0 == plane1 or plane0 == plane2 or plane1 == plane2) {78                return error.AliasedPlanes;79            }80            if (!sameSize(plane0, plane1) or !sameSize(plane0, plane2)) {81                return error.PlaneSizeMismatch;82            }83            if (plane0.bytesPerRow() != plane1.bytesPerRow() or84                plane0.bytesPerRow() != plane2.bytesPerRow())85            {86                return error.PlaneStrideMismatch;87            }88            const result = Self{89                .planes = .{ plane0.*, plane1.*, plane2.* },90                .packed_storage = &.{},91                .packing = .none,92            };93            plane0.* = ImageT.empty();94            plane1.* = ImageT.empty();95            plane2.* = ImageT.empty();96            return result;97        }9899        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {100            switch (self.packing) {101                .owned => {102                    std.debug.assert(self.packed_storage.len != 0);103                    const aligned: []align(storage_alignment) u8 = @alignCast(self.packed_storage);104                    allocator.free(aligned);105                },106                .none => for (&self.planes) |*current_plane| current_plane.deinit(allocator),107            }108            self.* = empty();109        }110111        pub fn swap(self: *Self, other: *Self) void {112            std.mem.swap(Self, self, other);113        }114115        pub fn shrinkTo(self: *Self, width: usize, height: usize) GeometryError!void {116            if (width > self.xsize() or height > self.ysize()) {117                return error.InvalidShrink;118            }119            for (&self.planes) |*current_plane| try current_plane.shrinkTo(width, height);120        }121122        pub fn xsize(self: *const Self) usize {123            return self.planes[0].xsize();124        }125126        pub fn ysize(self: *const Self) usize {127            return self.planes[0].ysize();128        }129130        pub fn bytesPerRow(self: *const Self) usize {131            return self.planes[0].bytesPerRow();132        }133134        pub fn pixelsPerRow(self: *const Self) usize {135            return self.planes[0].pixelsPerRow();136        }137138        pub fn plane(self: *const Self, index: usize) *const ImageT {139            std.debug.assert(index < num_planes);140            return &self.planes[index];141        }142143        pub fn constPlaneRow(self: *const Self, component: usize, y: usize) []const T {144            std.debug.assert(component < num_planes);145            return self.planes[component].constRow(y);146        }147148        pub fn mutablePlaneRow(self: *const Self, component: usize, y: usize) []T {149            std.debug.assert(component < num_planes);150            return self.planes[component].mutableRow(y);151        }152    };153}

1pub const Image3 = image.Image3;