Commit ee5af3c74c27ebf366ef51486119487650f80468 | zig

author	Dominic <4678790+dweiller@users.noreply.github.com> 2023-02-10 01:33:38+11:00
committer	Dominic <4678790+dweiller@users.noreply.github.com> 2023-02-20 09:09:06+11:00
log	ee5af3c74c27ebf366ef51486119487650f80468
tree	f86094baf16f8c00df2bd19855df6af962cb07d5
parent	31cc4605aba68edc44a31f8383eaa39a906d6ec8

std.compress.zstandard: cleanup high-level api docs and error sets

5 files changed, 173 insertions(+), 69 deletions(-)

lib
- std
  - compress
    zstandard.zig
    zstandard
    RingBuffer.zig
    decode
    block.zig
    decompress.zig
    types.zig

lib/std/compress/zstandard.zig+28-12

...	...	@@ -7,7 +7,11 @@ const RingBuffer = @import("zstandard/RingBuffer.zig");
7	7	pub const decompress = @import("zstandard/decompress.zig");
8	8	pub usingnamespace @import("zstandard/types.zig");
9	9
10		pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool, comptime window_size_max: usize) type {
	10	pub fn ZstandardStream(
	11	comptime ReaderType: type,
	12	comptime verify_checksum: bool,
	13	comptime window_size_max: usize,
	14	) type {
11	15	return struct {
12	16	const Self = @This();
13	17
...	...	@@ -24,11 +28,16 @@ pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool
24	28	sequence_buffer: []u8,
25	29	checksum: if (verify_checksum) ?u32 else void,
26	30
27		pub const Error = ReaderType.Error \|\| error{ ChecksumFailure, MalformedBlock, MalformedFrame, OutOfMemory };
	31	pub const Error = ReaderType.Error \|\| error{
	32	ChecksumFailure,
	33	MalformedBlock,
	34	MalformedFrame,
	35	OutOfMemory,
	36	};
28	37
29	38	pub const Reader = std.io.Reader(*Self, Error, read);
30	39
31		pub fn init(allocator: Allocator, source: ReaderType) !Self {
	40	pub fn init(allocator: Allocator, source: ReaderType) Self {
32	41	return Self{
33	42	.allocator = allocator,
34	43	.source = std.io.countingReader(source),
...	...	@@ -146,7 +155,8 @@ pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool
146	155
147	156	const source_reader = self.source.reader();
148	157	while (self.buffer.isEmpty() and self.state != .LastBlock) {
149		const header_bytes = source_reader.readBytesNoEof(3) catch return error.MalformedFrame;
	158	const header_bytes = source_reader.readBytesNoEof(3) catch
	159	return error.MalformedFrame;
150	160	const block_header = decompress.block.decodeBlockHeader(&header_bytes);
151	161
152	162	decompress.block.decodeBlockReader(
...	...	@@ -171,10 +181,12 @@ pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool
171	181	if (block_header.last_block) {
172	182	self.state = .LastBlock;
173	183	if (self.frame_context.has_checksum) {
174		const checksum = source_reader.readIntLittle(u32) catch return error.MalformedFrame;
	184	const checksum = source_reader.readIntLittle(u32) catch
	185	return error.MalformedFrame;
175	186	if (comptime verify_checksum) {
176	187	if (self.frame_context.hasher_opt) \|*hasher\| {
177		if (checksum != decompress.computeChecksum(hasher)) return error.ChecksumFailure;
	188	if (checksum != decompress.computeChecksum(hasher))
	189	return error.ChecksumFailure;
178	190	}
179	191	}
180	192	}
...	...	@@ -182,9 +194,9 @@ pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool
182	194	}
183	195
184	196	const decoded_data_len = self.buffer.len();
185		var written_count: usize = 0;
186		while (written_count < decoded_data_len and written_count < buffer.len) : (written_count += 1) {
187		buffer[written_count] = self.buffer.read().?;
	197	var count: usize = 0;
	198	while (count < decoded_data_len and count < buffer.len) : (count += 1) {
	199	buffer[count] = self.buffer.read().?;
188	200	}
189	201	if (self.state == .LastBlock and self.buffer.len() == 0) {
190	202	self.state = .NewFrame;
...	...	@@ -195,18 +207,22 @@ pub fn ZstandardStream(comptime ReaderType: type, comptime verify_checksum: bool
195	207	self.allocator.free(self.sequence_buffer);
196	208	self.buffer.deinit(self.allocator);
197	209	}
198		return written_count;
	210	return count;
199	211	}
200	212	};
201	213	}
202	214
203		pub fn zstandardStream(allocator: Allocator, reader: anytype) !ZstandardStream(@TypeOf(reader), true, 8 * (1 << 20)) {
	215	pub fn zstandardStream(
	216	allocator: Allocator,
	217	reader: anytype,
	218	comptime window_size_max: usize,
	219	) ZstandardStream(@TypeOf(reader), true, window_size_max) {
204	220	return ZstandardStream(@TypeOf(reader), true, 8 * (1 << 20)).init(allocator, reader);
205	221	}
206	222
207	223	fn testDecompress(data: []const u8) ![]u8 {
208	224	var in_stream = std.io.fixedBufferStream(data);
209		var stream = try zstandardStream(std.testing.allocator, in_stream.reader());
	225	var stream = zstandardStream(std.testing.allocator, in_stream.reader(), 1 << 23);
210	226	defer stream.deinit();
211	227	const result = stream.reader().readAllAlloc(std.testing.allocator, std.math.maxInt(usize));
212	228	return result;

lib/std/compress/zstandard/RingBuffer.zig+6-3

...	...	@@ -13,6 +13,8 @@ data: []u8,
13	13	read_index: usize,
14	14	write_index: usize,
15	15
	16	pub const Error = error{Full};
	17
16	18	/// Allocate a new `RingBuffer`
17	19	pub fn init(allocator: Allocator, capacity: usize) Allocator.Error!RingBuffer {
18	20	const bytes = try allocator.alloc(u8, capacity);
...	...	@@ -41,7 +43,7 @@ pub fn mask2(self: RingBuffer, index: usize) usize {
41	43
42	44	/// Write `byte` into the ring buffer. Returns `error.Full` if the ring
43	45	/// buffer is full.
44		pub fn write(self: *RingBuffer, byte: u8) !void {
	46	pub fn write(self: *RingBuffer, byte: u8) Error!void {
45	47	if (self.isFull()) return error.Full;
46	48	self.writeAssumeCapacity(byte);
47	49	}
...	...	@@ -55,7 +57,7 @@ pub fn writeAssumeCapacity(self: *RingBuffer, byte: u8) void {
55	57
56	58	/// Write `bytes` into the ring bufffer. Returns `error.Full` if the ring
57	59	/// buffer does not have enough space, without writing any data.
58		pub fn writeSlice(self: *RingBuffer, bytes: []const u8) !void {
	60	pub fn writeSlice(self: *RingBuffer, bytes: []const u8) Error!void {
59	61	if (self.len() + bytes.len > self.data.len) return error.Full;
60	62	self.writeSliceAssumeCapacity(bytes);
61	63	}
...	...	@@ -87,7 +89,8 @@ pub fn isFull(self: RingBuffer) bool {
87	89
88	90	/// Returns the length
89	91	pub fn len(self: RingBuffer) usize {
90		const adjusted_write_index = self.write_index + @as(usize, @boolToInt(self.write_index < self.read_index)) * 2 * self.data.len;
	92	const wrap_offset = 2 * self.data.len * @boolToInt(self.write_index < self.read_index);
	93	const adjusted_write_index = self.write_index + wrap_offset;
91	94	return adjusted_write_index - self.read_index;
92	95	}
93	96

lib/std/compress/zstandard/decode/block.zig+3-3

...	...	@@ -413,7 +413,7 @@ pub const DecodeState = struct {
413	413
414	414	const DecodeLiteralsError = error{
415	415	MalformedLiteralsLength,
416		PrefixNotFound,
	416	NotFound,
417	417	} \|\| LiteralBitsError;
418	418
419	419	/// Decode `len` bytes of literals into `dest`.
...	...	@@ -422,8 +422,8 @@ pub const DecodeState = struct {
422	422	/// - `error.MalformedLiteralsLength` if the number of literal bytes
423	423	/// decoded by `self` plus `len` is greater than the regenerated size of
424	424	/// `literals`
425		/// - `error.UnexpectedEndOfLiteralStream` and `error.PrefixNotFound` if
426		/// there are problems decoding Huffman compressed literals
	425	/// - `error.UnexpectedEndOfLiteralStream` and `error.NotFound` if there
	426	/// are problems decoding Huffman compressed literals
427	427	pub fn decodeLiteralsSlice(
428	428	self: *DecodeState,
429	429	dest: []u8,

lib/std/compress/zstandard/decompress.zig+126-43

...	...	@@ -6,6 +6,8 @@ const types = @import("types.zig");
6	6	const frame = types.frame;
7	7	const LiteralsSection = types.compressed_block.LiteralsSection;
8	8	const SequencesSection = types.compressed_block.SequencesSection;
	9	const SkippableHeader = types.frame.Skippable.Header;
	10	const ZstandardHeader = types.frame.Zstandard.Header;
9	11	const Table = types.compressed_block.Table;
10	12
11	13	pub const block = @import("decode/block.zig");
...	...	@@ -16,15 +18,13 @@ const readers = @import("readers.zig");
16	18
17	19	const readInt = std.mem.readIntLittle;
18	20	const readIntSlice = std.mem.readIntSliceLittle;
19		fn readVarInt(comptime T: type, bytes: []const u8) T {
20		return std.mem.readVarInt(T, bytes, .Little);
21		}
22	21
	22	/// Returns `true` is `magic` is a valid magic number for a skippable frame
23	23	pub fn isSkippableMagic(magic: u32) bool {
24	24	return frame.Skippable.magic_number_min <= magic and magic <= frame.Skippable.magic_number_max;
25	25	}
26	26
27		/// Returns the kind of frame at the beginning of `src`.
	27	/// Returns the kind of frame at the beginning of `source`.
28	28	///
29	29	/// Errors returned:
30	30	/// - `error.BadMagic` if `source` begins with bytes not equal to the
...	...	@@ -50,11 +50,22 @@ pub fn frameType(magic: u32) error{BadMagic}!frame.Kind {
50	50	}
51	51
52	52	pub const FrameHeader = union(enum) {
53		zstandard: types.frame.Zstandard.Header,
54		skippable: types.frame.Skippable.Header,
	53	zstandard: ZstandardHeader,
	54	skippable: SkippableHeader,
55	55	};
56	56
57		pub fn decodeFrameHeader(source: anytype) error{ BadMagic, EndOfStream, ReservedBitSet }!FrameHeader {
	57	pub const HeaderError = error{ BadMagic, EndOfStream, ReservedBitSet };
	58
	59	/// Returns the header of the frame at the beginning of `source`.
	60	///
	61	/// Errors returned:
	62	/// - `error.BadMagic` if `source` begins with bytes not equal to the
	63	/// Zstandard frame magic number, or outside the range of magic numbers for
	64	/// skippable frames.
	65	/// - `error.EndOfStream` if `source` contains fewer than 4 bytes
	66	/// - `error.ReservedBitSet` if the frame is a Zstandard frame and any of the
	67	/// reserved bits are set
	68	pub fn decodeFrameHeader(source: anytype) HeaderError!FrameHeader {
58	69	const magic = try source.readIntLittle(u32);
59	70	const frame_type = try frameType(magic);
60	71	switch (frame_type) {
...	...	@@ -68,41 +79,74 @@ pub fn decodeFrameHeader(source: anytype) error{ BadMagic, EndOfStream, Reserved
68	79	}
69	80	}
70	81
71		const ReadWriteCount = struct {
	82	pub const ReadWriteCount = struct {
72	83	read_count: usize,
73	84	write_count: usize,
74	85	};
75	86
76		/// Decodes frames from `src` into `dest`; see `decodeFrame()`.
77		pub fn decode(dest: []u8, src: []const u8, verify_checksum: bool) !usize {
	87	/// Decodes frames from `src` into `dest`; returns the length of the result.
	88	/// The stream should not have extra trailing bytes - either all bytes in `src`
	89	/// will be decoded, or an error will be returned. An error will be returned if
	90	/// a Zstandard frame in `src` does not declare its content size.
	91	///
	92	/// Errors returned:
	93	/// - `error.DictionaryIdFlagUnsupported` if a `src` contains a frame that
	94	/// uses a dictionary
	95	/// - `error.MalformedFrame` if a frame in `src` is invalid
	96	/// - `error.UnknownContentSizeUnsupported` if a frame in `src` does not
	97	/// declare its content size
	98	pub fn decode(dest: []u8, src: []const u8, verify_checksum: bool) error{
	99	MalformedFrame,
	100	UnknownContentSizeUnsupported,
	101	DictionaryIdFlagUnsupported,
	102	}!usize {
78	103	var write_count: usize = 0;
79	104	var read_count: usize = 0;
80	105	while (read_count < src.len) {
81		const counts = try decodeFrame(dest, src[read_count..], verify_checksum);
	106	const counts = decodeFrame(dest, src[read_count..], verify_checksum) catch \|err\| {
	107	switch (err) {
	108	error.UnknownContentSizeUnsupported => return error.UnknownContentSizeUnsupported,
	109	error.DictionaryIdFlagUnsupported => return error.DictionaryIdFlagUnsupported,
	110	else => return error.MalformedFrame,
	111	}
	112	};
82	113	read_count += counts.read_count;
83	114	write_count += counts.write_count;
84	115	}
85	116	return write_count;
86	117	}
87	118
	119	/// Decodes a stream of frames from `src`; returns the decoded bytes. The stream
	120	/// should not have extra trailing bytes - either all bytes in `src` will be
	121	/// decoded, or an error will be returned.
	122	///
	123	/// Errors returned:
	124	/// - `error.DictionaryIdFlagUnsupported` if a `src` contains a frame that
	125	/// uses a dictionary
	126	/// - `error.MalformedFrame` if a frame in `src` is invalid
	127	/// - `error.OutOfMemory` if `allocator` cannot allocate enough memory
88	128	pub fn decodeAlloc(
89	129	allocator: Allocator,
90	130	src: []const u8,
91	131	verify_checksum: bool,
92	132	window_size_max: usize,
93		) ![]u8 {
	133	) error{ DictionaryIdFlagUnsupported, MalformedFrame, OutOfMemory }![]u8 {
94	134	var result = std.ArrayList(u8).init(allocator);
95	135	errdefer result.deinit();
96	136
97	137	var read_count: usize = 0;
98	138	while (read_count < src.len) {
99		read_count += try decodeFrameArrayList(
	139	read_count += decodeFrameArrayList(
100	140	allocator,
101	141	&result,
102	142	src[read_count..],
103	143	verify_checksum,
104	144	window_size_max,
105		);
	145	) catch \|err\| switch (err) {
	146	error.OutOfMemory => return error.OutOfMemory,
	147	error.DictionaryIdFlagUnsupported => return error.DictionaryIdFlagUnsupported,
	148	else => return error.MalformedFrame,
	149	};
106	150	}
107	151	return result.toOwnedSlice();
108	152	}
...	...	@@ -112,18 +156,24 @@ pub fn decodeAlloc(
112	156	/// frames that declare the decompressed content size.
113	157	///
114	158	/// Errors returned:
	159	/// - `error.BadMagic` if the first 4 bytes of `src` is not a valid magic
	160	/// number for a Zstandard or skippable frame
115	161	/// - `error.UnknownContentSizeUnsupported` if the frame does not declare the
116	162	/// uncompressed content size
	163	/// - `error.WindowSizeUnknown` if the frame does not have a valid window size
117	164	/// - `error.ContentTooLarge` if `dest` is smaller than the uncompressed data
118	165	/// size declared by the frame header
119		/// - `error.BadMagic` if the first 4 bytes of `src` is not a valid magic
120		/// number for a Zstandard or Skippable frame
	166	/// - `error.ContentSizeTooLarge` if the frame header indicates a content size
	167	/// that is larger than `std.math.maxInt(usize)`
121	168	/// - `error.DictionaryIdFlagUnsupported` if the frame uses a dictionary
122	169	/// - `error.ChecksumFailure` if `verify_checksum` is true and the frame
123	170	/// contains a checksum that does not match the checksum of the decompressed
124	171	/// data
125		/// - `error.ReservedBitSet` if the reserved bit of the frame header is set
	172	/// - `error.ReservedBitSet` if any of the reserved bits of the frame header
	173	/// are set
126	174	/// - `error.EndOfStream` if `src` does not contain a complete frame
	175	/// - `error.BadContentSize` if the content size declared by the frame does
	176	/// not equal the actual size of decompressed data
127	177	/// - an error in `block.Error` if there are errors decoding a block
128	178	/// - `error.SkippableSizeTooLarge` if the frame is skippable and reports a
129	179	/// size greater than `src.len`
...	...	@@ -131,7 +181,15 @@ pub fn decodeFrame(
131	181	dest: []u8,
132	182	src: []const u8,
133	183	verify_checksum: bool,
134		) !ReadWriteCount {
	184	) (error{
	185	BadMagic,
	186	UnknownContentSizeUnsupported,
	187	ContentTooLarge,
	188	ContentSizeTooLarge,
	189	WindowSizeUnknown,
	190	DictionaryIdFlagUnsupported,
	191	SkippableSizeTooLarge,
	192	} \|\| FrameError)!ReadWriteCount {
135	193	var fbs = std.io.fixedBufferStream(src);
136	194	switch (try decodeFrameType(fbs.reader())) {
137	195	.zstandard => return decodeZstandardFrame(dest, src, verify_checksum),
...	...	@@ -153,16 +211,21 @@ pub fn decodeFrame(
153	211	///
154	212	/// Errors returned:
155	213	/// - `error.BadMagic` if the first 4 bytes of `src` is not a valid magic
156		/// number for a Zstandard or Skippable frame
	214	/// number for a Zstandard or skippable frame
157	215	/// - `error.WindowSizeUnknown` if the frame does not have a valid window size
158	216	/// - `error.WindowTooLarge` if the window size is larger than
159	217	/// `window_size_max`
	218	/// - `error.ContentSizeTooLarge` if the frame header indicates a content size
	219	/// that is larger than `std.math.maxInt(usize)`
160	220	/// - `error.DictionaryIdFlagUnsupported` if the frame uses a dictionary
161	221	/// - `error.ChecksumFailure` if `verify_checksum` is true and the frame
162	222	/// contains a checksum that does not match the checksum of the decompressed
163	223	/// data
164		/// - `error.ReservedBitSet` if the reserved bit of the frame header is set
	224	/// - `error.ReservedBitSet` if any of the reserved bits of the frame header
	225	/// are set
165	226	/// - `error.EndOfStream` if `src` does not contain a complete frame
	227	/// - `error.BadContentSize` if the content size declared by the frame does
	228	/// not equal the actual size of decompressed data
166	229	/// - `error.OutOfMemory` if `allocator` cannot allocate enough memory
167	230	/// - an error in `block.Error` if there are errors decoding a block
168	231	/// - `error.SkippableSizeTooLarge` if the frame is skippable and reports a
...	...	@@ -173,12 +236,18 @@ pub fn decodeFrameArrayList(
173	236	src: []const u8,
174	237	verify_checksum: bool,
175	238	window_size_max: usize,
176		) !usize {
	239	) (error{ BadMagic, OutOfMemory, SkippableSizeTooLarge } \|\| FrameContext.Error \|\| FrameError)!usize {
177	240	var fbs = std.io.fixedBufferStream(src);
178	241	const reader = fbs.reader();
179	242	const magic = try reader.readIntLittle(u32);
180	243	switch (try frameType(magic)) {
181		.zstandard => return decodeZstandardFrameArrayList(allocator, dest, src, verify_checksum, window_size_max),
	244	.zstandard => return decodeZstandardFrameArrayList(
	245	allocator,
	246	dest,
	247	src,
	248	verify_checksum,
	249	window_size_max,
	250	),
182	251	.skippable => {
183	252	const content_size = try fbs.reader().readIntLittle(u32);
184	253	if (content_size > std.math.maxInt(usize) - 8) return error.SkippableSizeTooLarge;
...	...	@@ -211,7 +280,10 @@ const FrameError = error{
211	280	/// uncompressed content size
212	281	/// - `error.ContentTooLarge` if `dest` is smaller than the uncompressed data
213	282	/// size declared by the frame header
	283	/// - `error.WindowSizeUnknown` if the frame does not have a valid window size
214	284	/// - `error.DictionaryIdFlagUnsupported` if the frame uses a dictionary
	285	/// - `error.ContentSizeTooLarge` if the frame header indicates a content size
	286	/// that is larger than `std.math.maxInt(usize)`
215	287	/// - `error.ChecksumFailure` if `verify_checksum` is true and the frame
216	288	/// contains a checksum that does not match the checksum of the decompressed
217	289	/// data
...	...	@@ -239,7 +311,11 @@ pub fn decodeZstandardFrame(
239	311	var source = fbs.reader();
240	312	const frame_header = try decodeZstandardHeader(source);
241	313	consumed_count += fbs.pos;
242		break :context FrameContext.init(frame_header, std.math.maxInt(usize), verify_checksum) catch \|err\| switch (err) {
	314	break :context FrameContext.init(
	315	frame_header,
	316	std.math.maxInt(usize),
	317	verify_checksum,
	318	) catch \|err\| switch (err) {
243	319	error.WindowTooLarge => unreachable,
244	320	inline else => \|e\| return e,
245	321	};
...	...	@@ -260,7 +336,8 @@ pub fn decodeZStandardFrameBlocks(
260	336	src: []const u8,
261	337	frame_context: *FrameContext,
262	338	) (error{ ContentTooLarge, UnknownContentSizeUnsupported } \|\| FrameError)!ReadWriteCount {
263		const content_size = frame_context.content_size orelse return error.UnknownContentSizeUnsupported;
	339	const content_size = frame_context.content_size orelse
	340	return error.UnknownContentSizeUnsupported;
264	341	if (dest.len < content_size) return error.ContentTooLarge;
265	342
266	343	var consumed_count: usize = 0;
...	...	@@ -304,14 +381,19 @@ pub const FrameContext = struct {
304	381	///
305	382	/// Errors returned:
306	383	/// - `error.DictionaryIdFlagUnsupported` if the frame uses a dictionary
307		/// - `error.WindowSizeUnknown` if the frame does not have a valid window size
308		/// - `error.WindowTooLarge` if the window size is larger than `window_size_max`
	384	/// - `error.WindowSizeUnknown` if the frame does not have a valid window
	385	/// size
	386	/// - `error.WindowTooLarge` if the window size is larger than
	387	/// `window_size_max`
	388	/// - `error.ContentSizeTooLarge` if the frame header indicates a content
	389	/// size larger than `std.math.maxInt(usize)`
309	390	pub fn init(
310		frame_header: frame.Zstandard.Header,
	391	frame_header: ZstandardHeader,
311	392	window_size_max: usize,
312	393	verify_checksum: bool,
313	394	) Error!FrameContext {
314		if (frame_header.descriptor.dictionary_id_flag != 0) return error.DictionaryIdFlagUnsupported;
	395	if (frame_header.descriptor.dictionary_id_flag != 0)
	396	return error.DictionaryIdFlagUnsupported;
315	397
316	398	const window_size_raw = frameWindowSize(frame_header) orelse return error.WindowSizeUnknown;
317	399	const window_size = if (window_size_raw > window_size_max)
...	...	@@ -319,7 +401,8 @@ pub const FrameContext = struct {
319	401	else
320	402	@intCast(usize, window_size_raw);
321	403
322		const should_compute_checksum = frame_header.descriptor.content_checksum_flag and verify_checksum;
	404	const should_compute_checksum =
	405	frame_header.descriptor.content_checksum_flag and verify_checksum;
323	406
324	407	const content_size = if (frame_header.content_size) \|size\|
325	408	std.math.cast(usize, size) orelse return error.ContentSizeTooLarge
...	...	@@ -345,6 +428,8 @@ pub const FrameContext = struct {
345	428	/// - `error.WindowTooLarge` if the window size is larger than
346	429	/// `window_size_max`
347	430	/// - `error.DictionaryIdFlagUnsupported` if the frame uses a dictionary
	431	/// - `error.ContentSizeTooLarge` if the frame header indicates a content size
	432	/// that is larger than `std.math.maxInt(usize)`
348	433	/// - `error.ChecksumFailure` if `verify_checksum` is true and the frame
349	434	/// contains a checksum that does not match the checksum of the decompressed
350	435	/// data
...	...	@@ -441,8 +526,6 @@ pub fn decodeZstandardFrameBlocksArrayList(
441	526	return consumed_count;
442	527	}
443	528
444		/// Convenience wrapper for decoding all blocks in a frame; see
445		/// `decodeZStandardFrameBlocks()`.
446	529	fn decodeFrameBlocksInner(
447	530	dest: []u8,
448	531	src: []const u8,
...	...	@@ -459,7 +542,7 @@ fn decodeFrameBlocksInner(
459	542	var bytes_read: usize = 3;
460	543	defer consumed_count.* += bytes_read;
461	544	var decode_state = block.DecodeState.init(&literal_fse_data, &match_fse_data, &offset_fse_data);
462		var written_count: usize = 0;
	545	var count: usize = 0;
463	546	while (true) : ({
464	547	block_header = try block.decodeBlockHeaderSlice(src[bytes_read..]);
465	548	bytes_read += 3;
...	...	@@ -471,18 +554,18 @@ fn decodeFrameBlocksInner(
471	554	&decode_state,
472	555	&bytes_read,
473	556	block_size_max,
474		written_count,
	557	count,
475	558	);
476		if (hash) \|hash_state\| hash_state.update(dest[written_count .. written_count + written_size]);
477		written_count += written_size;
	559	if (hash) \|hash_state\| hash_state.update(dest[count .. count + written_size]);
	560	count += written_size;
478	561	if (block_header.last_block) break;
479	562	}
480		return written_count;
	563	return count;
481	564	}
482	565
483	566	/// Decode the header of a skippable frame. The first four bytes of `src` must
484		/// be a valid magic number for a Skippable frame.
485		pub fn decodeSkippableHeader(src: *const [8]u8) frame.Skippable.Header {
	567	/// be a valid magic number for a skippable frame.
	568	pub fn decodeSkippableHeader(src: *const [8]u8) SkippableHeader {
486	569	const magic = readInt(u32, src[0..4]);
487	570	assert(isSkippableMagic(magic));
488	571	const frame_size = readInt(u32, src[4..8]);
...	...	@@ -494,7 +577,7 @@ pub fn decodeSkippableHeader(src: *const [8]u8) frame.Skippable.Header {
494	577
495	578	/// Returns the window size required to decompress a frame, or `null` if it
496	579	/// cannot be determined (which indicates a malformed frame header).
497		pub fn frameWindowSize(header: frame.Zstandard.Header) ?u64 {
	580	pub fn frameWindowSize(header: ZstandardHeader) ?u64 {
498	581	if (header.window_descriptor) \|descriptor\| {
499	582	const exponent = (descriptor & 0b11111000) >> 3;
500	583	const mantissa = descriptor & 0b00000111;
...	...	@@ -508,10 +591,10 @@ pub fn frameWindowSize(header: frame.Zstandard.Header) ?u64 {
508	591	/// Decode the header of a Zstandard frame.
509	592	///
510	593	/// Errors returned:
511		/// - `error.ReservedBitSet` if the reserved bits of the header are set
	594	/// - `error.ReservedBitSet` if any of the reserved bits of the header are set
512	595	/// - `error.EndOfStream` if `source` does not contain a complete header
513		pub fn decodeZstandardHeader(source: anytype) error{ EndOfStream, ReservedBitSet }!frame.Zstandard.Header {
514		const descriptor = @bitCast(frame.Zstandard.Header.Descriptor, try source.readByte());
	596	pub fn decodeZstandardHeader(source: anytype) error{ EndOfStream, ReservedBitSet }!ZstandardHeader {
	597	const descriptor = @bitCast(ZstandardHeader.Descriptor, try source.readByte());
515	598
516	599	if (descriptor.reserved) return error.ReservedBitSet;
517	600
...	...	@@ -534,7 +617,7 @@ pub fn decodeZstandardHeader(source: anytype) error{ EndOfStream, ReservedBitSet
534	617	if (field_size == 2) content_size.? += 256;
535	618	}
536	619
537		const header = frame.Zstandard.Header{
	620	const header = ZstandardHeader{
538	621	.descriptor = descriptor,
539	622	.window_descriptor = window_descriptor,
540	623	.dictionary_id = dictionary_id,

lib/std/compress/zstandard/types.zig+10-8

...	...	@@ -92,13 +92,13 @@ pub const compressed_block = struct {
92	92	index: usize,
93	93	};
94	94
95		pub fn query(self: HuffmanTree, index: usize, prefix: u16) error{PrefixNotFound}!Result {
	95	pub fn query(self: HuffmanTree, index: usize, prefix: u16) error{NotFound}!Result {
96	96	var node = self.nodes[index];
97	97	const weight = node.weight;
98	98	var i: usize = index;
99	99	while (node.weight == weight) {
100	100	if (node.prefix == prefix) return Result{ .symbol = node.symbol };
101		if (i == 0) return error.PrefixNotFound;
	101	if (i == 0) return error.NotFound;
102	102	i -= 1;
103	103	node = self.nodes[i];
104	104	}
...	...	@@ -164,12 +164,14 @@ pub const compressed_block = struct {
164	164	};
165	165
166	166	pub const match_length_code_table = [53]struct { u32, u5 }{
167		.{ 3, 0 }, .{ 4, 0 }, .{ 5, 0 }, .{ 6, 0 }, .{ 7, 0 }, .{ 8, 0 }, .{ 9, 0 }, .{ 10, 0 },
168		.{ 11, 0 }, .{ 12, 0 }, .{ 13, 0 }, .{ 14, 0 }, .{ 15, 0 }, .{ 16, 0 }, .{ 17, 0 }, .{ 18, 0 },
169		.{ 19, 0 }, .{ 20, 0 }, .{ 21, 0 }, .{ 22, 0 }, .{ 23, 0 }, .{ 24, 0 }, .{ 25, 0 }, .{ 26, 0 },
170		.{ 27, 0 }, .{ 28, 0 }, .{ 29, 0 }, .{ 30, 0 }, .{ 31, 0 }, .{ 32, 0 }, .{ 33, 0 }, .{ 34, 0 },
171		.{ 35, 1 }, .{ 37, 1 }, .{ 39, 1 }, .{ 41, 1 }, .{ 43, 2 }, .{ 47, 2 }, .{ 51, 3 }, .{ 59, 3 },
172		.{ 67, 4 }, .{ 83, 4 }, .{ 99, 5 }, .{ 131, 7 }, .{ 259, 8 }, .{ 515, 9 }, .{ 1027, 10 }, .{ 2051, 11 },
	167	.{ 3, 0 }, .{ 4, 0 }, .{ 5, 0 }, .{ 6, 0 }, .{ 7, 0 }, .{ 8, 0 },
	168	.{ 9, 0 }, .{ 10, 0 }, .{ 11, 0 }, .{ 12, 0 }, .{ 13, 0 }, .{ 14, 0 },
	169	.{ 15, 0 }, .{ 16, 0 }, .{ 17, 0 }, .{ 18, 0 }, .{ 19, 0 }, .{ 20, 0 },
	170	.{ 21, 0 }, .{ 22, 0 }, .{ 23, 0 }, .{ 24, 0 }, .{ 25, 0 }, .{ 26, 0 },
	171	.{ 27, 0 }, .{ 28, 0 }, .{ 29, 0 }, .{ 30, 0 }, .{ 31, 0 }, .{ 32, 0 },
	172	.{ 33, 0 }, .{ 34, 0 }, .{ 35, 1 }, .{ 37, 1 }, .{ 39, 1 }, .{ 41, 1 },
	173	.{ 43, 2 }, .{ 47, 2 }, .{ 51, 3 }, .{ 59, 3 }, .{ 67, 4 }, .{ 83, 4 },
	174	.{ 99, 5 }, .{ 131, 7 }, .{ 259, 8 }, .{ 515, 9 }, .{ 1027, 10 }, .{ 2051, 11 },
173	175	.{ 4099, 12 }, .{ 8195, 13 }, .{ 16387, 14 }, .{ 32771, 15 }, .{ 65539, 16 },
174	176	};
175	177