1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const c = @import("c.zig").c;
const Error = @import("error.zig").Error;
const log = std.log.scoped(.wuffs_swizzler);
pub fn gToRgba(alloc: Allocator, src: []const u8) Error![]u8 {
return swizzle(
alloc,
src,
c.WUFFS_BASE__PIXEL_FORMAT__Y,
c.WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
);
}
pub fn gaToRgba(alloc: Allocator, src: []const u8) Error![]u8 {
return swizzle(
alloc,
src,
c.WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL,
c.WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
);
}
pub fn rgbToRgba(alloc: Allocator, src: []const u8) Error![]u8 {
return swizzle(
alloc,
src,
c.WUFFS_BASE__PIXEL_FORMAT__RGB,
c.WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
);
}
pub fn bgrToRgba(alloc: Allocator, src: []const u8) Error![]u8 {
return swizzle(
alloc,
src,
c.WUFFS_BASE__PIXEL_FORMAT__BGR,
c.WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
);
}
pub fn bgraToRgba(alloc: Allocator, src: []const u8) Error![]u8 {
return swizzle(
alloc,
src,
c.WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL,
c.WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
);
}
fn swizzle(
alloc: Allocator,
src: []const u8,
comptime src_pixel_format: u32,
comptime dst_pixel_format: u32,
) Error![]u8 {
const src_slice = c.wuffs_base__make_slice_u8(
@constCast(src.ptr),
src.len,
);
const dst_fmt = c.wuffs_base__make_pixel_format(
dst_pixel_format,
);
assert(c.wuffs_base__pixel_format__is_direct(&dst_fmt));
assert(c.wuffs_base__pixel_format__is_interleaved(&dst_fmt));
assert(c.wuffs_base__pixel_format__bits_per_pixel(&dst_fmt) % 8 == 0);
const dst_size = c.wuffs_base__pixel_format__bits_per_pixel(&dst_fmt) / 8;
const src_fmt = c.wuffs_base__make_pixel_format(
src_pixel_format,
);
assert(c.wuffs_base__pixel_format__is_direct(&src_fmt));
assert(c.wuffs_base__pixel_format__is_interleaved(&src_fmt));
assert(c.wuffs_base__pixel_format__bits_per_pixel(&src_fmt) % 8 == 0);
const src_size = c.wuffs_base__pixel_format__bits_per_pixel(&src_fmt) / 8;
assert(src.len % src_size == 0);
const dst = try alloc.alloc(u8, src.len * dst_size / src_size);
errdefer alloc.free(dst);
const dst_slice = c.wuffs_base__make_slice_u8(
dst.ptr,
dst.len,
);
var swizzler: c.wuffs_base__pixel_swizzler = undefined;
{
const status = c.wuffs_base__pixel_swizzler__prepare(
&swizzler,
dst_fmt,
c.wuffs_base__empty_slice_u8(),
src_fmt,
c.wuffs_base__empty_slice_u8(),
c.WUFFS_BASE__PIXEL_BLEND__SRC,
);
if (!c.wuffs_base__status__is_ok(&status)) {
const e = c.wuffs_base__status__message(&status);
log.warn("{s}", .{e});
return error.WuffsError;
}
}
{
_ = c.wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
&swizzler,
dst_slice,
c.wuffs_base__empty_slice_u8(),
src_slice,
);
}
return dst;
}
|
