authorgravatar for 4678790+dweiller@users.noreply.github.comDominic <4678790+dweiller@users.noreply.github.com> 2023-01-23 12:47:46+11:00
committergravatar for 4678790+dweiller@users.noreply.github.comDominic <4678790+dweiller@users.noreply.github.com> 2023-02-20 09:09:05+11:00
logcbfaa876d466a885c54ead16a5901399619ed0c8
tree964fd36b471b6975433e4db6bc3562526caf03f8
parentc819e58c20b23d625b2b2350d1fc655481309d9f

std.compress.zstandard: cleanup ReverseBitReader

1 files changed, 42 insertions(+), 49 deletions(-)

lib/std/compress/zstandard/decompress.zig+42-49
......@@ -68,8 +68,7 @@ const DecodeState = struct {
6868
6969 fse_tables_undefined: bool,
7070
71 literal_stream_reader: ReverseBitReader(ReversedByteReader.Reader),
72 literal_stream_bytes: ReversedByteReader,
71 literal_stream_reader: ReverseBitReader,
7372 literal_stream_index: usize,
7473 huffman_tree: ?Literals.HuffmanTree,
7574
......@@ -288,9 +287,7 @@ const DecodeState = struct {
288287
289288 fn initLiteralStream(self: *DecodeState, bytes: []const u8) !void {
290289 log.debug("initing literal stream: {}", .{std.fmt.fmtSliceHexUpper(bytes)});
291 self.literal_stream_bytes = reversedByteReader(bytes);
292 self.literal_stream_reader = reverseBitReader(self.literal_stream_bytes.reader());
293 while (0 == try self.literal_stream_reader.readBitsNoEof(u1, 1)) {}
290 try self.literal_stream_reader.init(bytes);
294291 }
295292
296293 fn decodeLiteralsSlice(self: *DecodeState, dest: []u8, literals: Literals, len: usize) !void {
......@@ -532,7 +529,6 @@ pub fn decodeZStandardFrameAlloc(allocator: std.mem.Allocator, src: []const u8,
532529
533530 .literal_written_count = 0,
534531 .literal_stream_reader = undefined,
535 .literal_stream_bytes = undefined,
536532 .literal_stream_index = undefined,
537533 .huffman_tree = null,
538534 };
......@@ -591,7 +587,6 @@ pub fn decodeFrameBlocks(dest: []u8, src: []const u8, consumed_count: *usize, ha
591587
592588 .literal_written_count = 0,
593589 .literal_stream_reader = undefined,
594 .literal_stream_bytes = undefined,
595590 .literal_stream_index = undefined,
596591 .huffman_tree = null,
597592 };
......@@ -725,10 +720,9 @@ pub fn decodeBlock(
725720 var bytes_written: usize = 0;
726721 if (sequences_header.sequence_count > 0) {
727722 const bit_stream_bytes = src[bytes_read..block_size];
728 var reverse_byte_reader = reversedByteReader(bit_stream_bytes);
729 var bit_stream = reverseBitReader(reverse_byte_reader.reader());
723 var bit_stream: ReverseBitReader = undefined;
724 try bit_stream.init(bit_stream_bytes);
730725
731 while (0 == try bit_stream.readBitsNoEof(u1, 1)) {}
732726 try decode_state.readInitialState(&bit_stream);
733727
734728 var i: usize = 0;
......@@ -791,10 +785,9 @@ pub fn decodeBlockRingBuffer(
791785 var bytes_written: usize = 0;
792786 if (sequences_header.sequence_count > 0) {
793787 const bit_stream_bytes = src[bytes_read..block_size];
794 var reverse_byte_reader = reversedByteReader(bit_stream_bytes);
795 var bit_stream = reverseBitReader(reverse_byte_reader.reader());
788 var bit_stream: ReverseBitReader = undefined;
789 try bit_stream.init(bit_stream_bytes);
796790
797 while (0 == try bit_stream.readBitsNoEof(u1, 1)) {}
798791 try decode_state.readInitialState(&bit_stream);
799792
800793 var i: usize = 0;
......@@ -1028,9 +1021,8 @@ fn decodeHuffmanTree(src: []const u8, consumed_count: *usize) !Literals.HuffmanT
10281021 const accuracy_log = std.math.log2_int_ceil(usize, table_size);
10291022
10301023 var huff_data = src[1 + counting_reader.bytes_read .. compressed_size + 1];
1031 var huff_data_bytes = reversedByteReader(huff_data);
1032 var huff_bits = reverseBitReader(huff_data_bytes.reader());
1033 while (0 == try huff_bits.readBitsNoEof(u1, 1)) {}
1024 var huff_bits: ReverseBitReader = undefined;
1025 try huff_bits.init(huff_data);
10341026
10351027 dumpFseTable("huffman", entries[0..table_size]);
10361028
......@@ -1415,48 +1407,49 @@ const ReversedByteReader = struct {
14151407
14161408 const Reader = std.io.Reader(*ReversedByteReader, error{}, readFn);
14171409
1410 fn init(bytes: []const u8) ReversedByteReader {
1411 return .{
1412 .bytes = bytes,
1413 .remaining_bytes = bytes.len,
1414 };
1415 }
1416
14181417 fn reader(self: *ReversedByteReader) Reader {
14191418 return .{ .context = self };
14201419 }
1421};
1422
1423fn readFn(ctx: *ReversedByteReader, buffer: []u8) !usize {
1424 if (ctx.remaining_bytes == 0) return 0;
1425 const byte_index = ctx.remaining_bytes - 1;
1426 buffer[0] = ctx.bytes[byte_index];
1427 // buffer[0] = @bitReverse(ctx.bytes[byte_index]);
1428 ctx.remaining_bytes = byte_index;
1429 return 1;
1430}
14311420
1432fn reversedByteReader(bytes: []const u8) ReversedByteReader {
1433 return ReversedByteReader{
1434 .remaining_bytes = bytes.len,
1435 .bytes = bytes,
1436 };
1437}
1421 fn readFn(ctx: *ReversedByteReader, buffer: []u8) !usize {
1422 if (ctx.remaining_bytes == 0) return 0;
1423 const byte_index = ctx.remaining_bytes - 1;
1424 buffer[0] = ctx.bytes[byte_index];
1425 // buffer[0] = @bitReverse(ctx.bytes[byte_index]);
1426 ctx.remaining_bytes = byte_index;
1427 return 1;
1428 }
1429};
14381430
1439fn ReverseBitReader(comptime Reader: type) type {
1440 return struct {
1441 underlying: std.io.BitReader(.Big, Reader),
1431const ReverseBitReader = struct {
1432 byte_reader: ReversedByteReader,
1433 bit_reader: std.io.BitReader(.Big, ReversedByteReader.Reader),
14421434
1443 fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: usize) !U {
1444 return self.underlying.readBitsNoEof(U, num_bits);
1445 }
1435 fn init(self: *ReverseBitReader, bytes: []const u8) !void {
1436 self.byte_reader = ReversedByteReader.init(bytes);
1437 self.bit_reader = std.io.bitReader(.Big, self.byte_reader.reader());
1438 while (0 == self.readBitsNoEof(u1, 1) catch return error.BitStreamHasNoStartBit) {}
1439 }
14461440
1447 fn readBits(self: *@This(), comptime U: type, num_bits: usize, out_bits: *usize) !U {
1448 return try self.underlying.readBits(U, num_bits, out_bits);
1449 }
1441 fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: usize) !U {
1442 return self.bit_reader.readBitsNoEof(U, num_bits);
1443 }
14501444
1451 fn alignToByte(self: *@This()) void {
1452 self.underlying.alignToByte();
1453 }
1454 };
1455}
1445 fn readBits(self: *@This(), comptime U: type, num_bits: usize, out_bits: *usize) !U {
1446 return try self.bit_reader.readBits(U, num_bits, out_bits);
1447 }
14561448
1457fn reverseBitReader(reader: anytype) ReverseBitReader(@TypeOf(reader)) {
1458 return .{ .underlying = std.io.bitReader(.Big, reader) };
1459}
1449 fn alignToByte(self: *@This()) void {
1450 self.bit_reader.alignToByte();
1451 }
1452};
14601453
14611454fn BitReader(comptime Reader: type) type {
14621455 return struct {