| ... | @@ -50,19 +50,17 @@ pub const RangeDecoder = struct { | ... | @@ -50,19 +50,17 @@ pub const RangeDecoder = struct { |
| 50 | return result; | 50 | return result; |
| 51 | } | 51 | } |
| 52 | | 52 | |
| 53 | pub fn decodeBit(self: *RangeDecoder, reader: *Reader, prob: *u16, update: bool) !bool { | 53 | pub fn decodeBit(self: *RangeDecoder, reader: *Reader, prob: *u16) !bool { |
| 54 | const bound = (self.range >> 11) * prob.*; | 54 | const bound = (self.range >> 11) * prob.*; |
| 55 | | 55 | |
| 56 | if (self.code < bound) { | 56 | if (self.code < bound) { |
| 57 | if (update) | 57 | prob.* += (0x800 - prob.*) >> 5; |
| 58 | prob.* += (0x800 - prob.*) >> 5; | | |
| 59 | self.range = bound; | 58 | self.range = bound; |
| 60 | | 59 | |
| 61 | try self.normalize(reader); | 60 | try self.normalize(reader); |
| 62 | return false; | 61 | return false; |
| 63 | } else { | 62 | } else { |
| 64 | if (update) | 63 | prob.* -= prob.* >> 5; |
| 65 | prob.* -= prob.* >> 5; | | |
| 66 | self.code -= bound; | 64 | self.code -= bound; |
| 67 | self.range -= bound; | 65 | self.range -= bound; |
| 68 | | 66 | |
| ... | @@ -76,12 +74,11 @@ pub const RangeDecoder = struct { | ... | @@ -76,12 +74,11 @@ pub const RangeDecoder = struct { |
| 76 | reader: *Reader, | 74 | reader: *Reader, |
| 77 | num_bits: u5, | 75 | num_bits: u5, |
| 78 | probs: []u16, | 76 | probs: []u16, |
| 79 | update: bool, | | |
| 80 | ) !u32 { | 77 | ) !u32 { |
| 81 | var tmp: u32 = 1; | 78 | var tmp: u32 = 1; |
| 82 | var i: @TypeOf(num_bits) = 0; | 79 | var i: @TypeOf(num_bits) = 0; |
| 83 | while (i < num_bits) : (i += 1) { | 80 | while (i < num_bits) : (i += 1) { |
| 84 | const bit = try self.decodeBit(reader, &probs[tmp], update); | 81 | const bit = try self.decodeBit(reader, &probs[tmp]); |
| 85 | tmp = (tmp << 1) ^ @intFromBool(bit); | 82 | tmp = (tmp << 1) ^ @intFromBool(bit); |
| 86 | } | 83 | } |
| 87 | return tmp - (@as(u32, 1) << num_bits); | 84 | return tmp - (@as(u32, 1) << num_bits); |
| ... | @@ -93,13 +90,12 @@ pub const RangeDecoder = struct { | ... | @@ -93,13 +90,12 @@ pub const RangeDecoder = struct { |
| 93 | num_bits: u5, | 90 | num_bits: u5, |
| 94 | probs: []u16, | 91 | probs: []u16, |
| 95 | offset: usize, | 92 | offset: usize, |
| 96 | update: bool, | | |
| 97 | ) !u32 { | 93 | ) !u32 { |
| 98 | var result: u32 = 0; | 94 | var result: u32 = 0; |
| 99 | var tmp: usize = 1; | 95 | var tmp: usize = 1; |
| 100 | var i: @TypeOf(num_bits) = 0; | 96 | var i: @TypeOf(num_bits) = 0; |
| 101 | while (i < num_bits) : (i += 1) { | 97 | while (i < num_bits) : (i += 1) { |
| 102 | const bit = @intFromBool(try self.decodeBit(reader, &probs[offset + tmp], update)); | 98 | const bit = @intFromBool(try self.decodeBit(reader, &probs[offset + tmp])); |
| 103 | tmp = (tmp << 1) ^ bit; | 99 | tmp = (tmp << 1) ^ bit; |
| 104 | result ^= @as(u32, bit) << i; | 100 | result ^= @as(u32, bit) << i; |
| 105 | } | 101 | } |
| ... | @@ -186,97 +182,76 @@ pub const Decode = struct { | ... | @@ -186,97 +182,76 @@ pub const Decode = struct { |
| 186 | allocating: *Writer.Allocating, | 182 | allocating: *Writer.Allocating, |
| 187 | buffer: *CircularBuffer, | 183 | buffer: *CircularBuffer, |
| 188 | decoder: *RangeDecoder, | 184 | decoder: *RangeDecoder, |
| 189 | update: bool, | | |
| 190 | ) !ProcessingStatus { | 185 | ) !ProcessingStatus { |
| 191 | const gpa = allocating.allocator; | 186 | const gpa = allocating.allocator; |
| 192 | const writer = &allocating.writer; | 187 | const writer = &allocating.writer; |
| 193 | const pos_state = buffer.len & ((@as(usize, 1) << self.properties.pb) - 1); | 188 | const pos_state = buffer.len & ((@as(usize, 1) << self.properties.pb) - 1); |
| 194 | | 189 | |
| 195 | if (!try decoder.decodeBit(reader, &self.is_match[(self.state << 4) + pos_state], update)) { | 190 | if (!try decoder.decodeBit(reader, &self.is_match[(self.state << 4) + pos_state])) { |
| 196 | const byte: u8 = try self.decodeLiteral(reader, buffer, decoder, update); | 191 | const byte: u8 = try self.decodeLiteral(reader, buffer, decoder); |
| 197 | | 192 | |
| 198 | if (update) { | 193 | try buffer.appendLiteral(gpa, byte, writer); |
| 199 | try buffer.appendLiteral(gpa, byte, writer); | | |
| 200 | | 194 | |
| 201 | self.state = if (self.state < 4) | 195 | self.state = if (self.state < 4) |
| 202 | 0 | 196 | 0 |
| 203 | else if (self.state < 10) | 197 | else if (self.state < 10) |
| 204 | self.state - 3 | 198 | self.state - 3 |
| 205 | else | 199 | else |
| 206 | self.state - 6; | 200 | self.state - 6; |
| 207 | } | | |
| 208 | return .more; | 201 | return .more; |
| 209 | } | 202 | } |
| 210 | | 203 | |
| 211 | var len: usize = undefined; | 204 | var len: usize = undefined; |
| 212 | if (try decoder.decodeBit(reader, &self.is_rep[self.state], update)) { | 205 | if (try decoder.decodeBit(reader, &self.is_rep[self.state])) { |
| 213 | if (!try decoder.decodeBit(reader, &self.is_rep_g0[self.state], update)) { | 206 | if (!try decoder.decodeBit(reader, &self.is_rep_g0[self.state])) { |
| 214 | if (!try decoder.decodeBit( | 207 | if (!try decoder.decodeBit(reader, &self.is_rep_0long[(self.state << 4) + pos_state])) { |
| 215 | reader, | 208 | self.state = if (self.state < 7) 9 else 11; |
| 216 | &self.is_rep_0long[(self.state << 4) + pos_state], | 209 | const dist = self.rep[0] + 1; |
| 217 | update, | 210 | try buffer.appendLz(gpa, 1, dist, writer); |
| 218 | )) { | | |
| 219 | if (update) { | | |
| 220 | self.state = if (self.state < 7) 9 else 11; | | |
| 221 | const dist = self.rep[0] + 1; | | |
| 222 | try buffer.appendLz(gpa, 1, dist, writer); | | |
| 223 | } | | |
| 224 | return .more; | 211 | return .more; |
| 225 | } | 212 | } |
| 226 | } else { | 213 | } else { |
| 227 | const idx: usize = if (!try decoder.decodeBit(reader, &self.is_rep_g1[self.state], update)) | 214 | const idx: usize = if (!try decoder.decodeBit(reader, &self.is_rep_g1[self.state])) |
| 228 | 1 | 215 | 1 |
| 229 | else if (!try decoder.decodeBit(reader, &self.is_rep_g2[self.state], update)) | 216 | else if (!try decoder.decodeBit(reader, &self.is_rep_g2[self.state])) |
| 230 | 2 | 217 | 2 |
| 231 | else | 218 | else |
| 232 | 3; | 219 | 3; |
| 233 | if (update) { | 220 | const dist = self.rep[idx]; |
| 234 | const dist = self.rep[idx]; | 221 | var i = idx; |
| 235 | var i = idx; | 222 | while (i > 0) : (i -= 1) { |
| 236 | while (i > 0) : (i -= 1) { | 223 | self.rep[i] = self.rep[i - 1]; |
| 237 | self.rep[i] = self.rep[i - 1]; | | |
| 238 | } | | |
| 239 | self.rep[0] = dist; | | |
| 240 | } | 224 | } |
| | 225 | self.rep[0] = dist; |
| 241 | } | 226 | } |
| 242 | | 227 | |
| 243 | len = try self.rep_len_decoder.decode(reader, decoder, pos_state, update); | 228 | len = try self.rep_len_decoder.decode(reader, decoder, pos_state); |
| 244 | | 229 | |
| 245 | if (update) { | 230 | self.state = if (self.state < 7) 8 else 11; |
| 246 | self.state = if (self.state < 7) 8 else 11; | | |
| 247 | } | | |
| 248 | } else { | 231 | } else { |
| 249 | if (update) { | 232 | self.rep[3] = self.rep[2]; |
| 250 | self.rep[3] = self.rep[2]; | 233 | self.rep[2] = self.rep[1]; |
| 251 | self.rep[2] = self.rep[1]; | 234 | self.rep[1] = self.rep[0]; |
| 252 | self.rep[1] = self.rep[0]; | | |
| 253 | } | | |
| 254 | | 235 | |
| 255 | len = try self.len_decoder.decode(reader, decoder, pos_state, update); | 236 | len = try self.len_decoder.decode(reader, decoder, pos_state); |
| 256 | | 237 | |
| 257 | if (update) { | 238 | self.state = if (self.state < 7) 7 else 10; |
| 258 | self.state = if (self.state < 7) 7 else 10; | | |
| 259 | } | | |
| 260 | | 239 | |
| 261 | const rep_0 = try self.decodeDistance(reader, decoder, len, update); | 240 | const rep_0 = try self.decodeDistance(reader, decoder, len); |
| 262 | | 241 | |
| 263 | if (update) { | 242 | self.rep[0] = rep_0; |
| 264 | self.rep[0] = rep_0; | 243 | if (self.rep[0] == 0xFFFF_FFFF) { |
| 265 | if (self.rep[0] == 0xFFFF_FFFF) { | 244 | if (decoder.isFinished()) { |
| 266 | if (decoder.isFinished()) { | 245 | return .finished; |
| 267 | return .finished; | | |
| 268 | } | | |
| 269 | return error.CorruptInput; | | |
| 270 | } | 246 | } |
| | 247 | return error.CorruptInput; |
| 271 | } | 248 | } |
| 272 | } | 249 | } |
| 273 | | 250 | |
| 274 | if (update) { | 251 | len += 2; |
| 275 | len += 2; | | |
| 276 | | 252 | |
| 277 | const dist = self.rep[0] + 1; | 253 | const dist = self.rep[0] + 1; |
| 278 | try buffer.appendLz(gpa, len, dist, writer); | 254 | try buffer.appendLz(gpa, len, dist, writer); |
| 279 | } | | |
| 280 | | 255 | |
| 281 | return .more; | 256 | return .more; |
| 282 | } | 257 | } |
| ... | @@ -296,7 +271,7 @@ pub const Decode = struct { | ... | @@ -296,7 +271,7 @@ pub const Decode = struct { |
| 296 | } else if (decoder.isFinished()) { | 271 | } else if (decoder.isFinished()) { |
| 297 | break :process_next; | 272 | break :process_next; |
| 298 | } | 273 | } |
| 299 | switch (try self.processNext(reader, allocating, buffer, decoder, true)) { | 274 | switch (try self.processNext(reader, allocating, buffer, decoder)) { |
| 300 | .more => return, | 275 | .more => return, |
| 301 | .finished => {}, | 276 | .finished => {}, |
| 302 | } | 277 | } |
| ... | @@ -315,7 +290,6 @@ pub const Decode = struct { | ... | @@ -315,7 +290,6 @@ pub const Decode = struct { |
| 315 | reader: *Reader, | 290 | reader: *Reader, |
| 316 | buffer: *CircularBuffer, | 291 | buffer: *CircularBuffer, |
| 317 | decoder: *RangeDecoder, | 292 | decoder: *RangeDecoder, |
| 318 | update: bool, | | |
| 319 | ) !u8 { | 293 | ) !u8 { |
| 320 | const def_prev_byte = 0; | 294 | const def_prev_byte = 0; |
| 321 | const prev_byte = @as(usize, buffer.lastOr(def_prev_byte)); | 295 | const prev_byte = @as(usize, buffer.lastOr(def_prev_byte)); |
| ... | @@ -334,7 +308,6 @@ pub const Decode = struct { | ... | @@ -334,7 +308,6 @@ pub const Decode = struct { |
| 334 | const bit = @intFromBool(try decoder.decodeBit( | 308 | const bit = @intFromBool(try decoder.decodeBit( |
| 335 | reader, | 309 | reader, |
| 336 | &probs[((@as(usize, 1) + match_bit) << 8) + result], | 310 | &probs[((@as(usize, 1) + match_bit) << 8) + result], |
| 337 | update, | | |
| 338 | )); | 311 | )); |
| 339 | result = (result << 1) ^ bit; | 312 | result = (result << 1) ^ bit; |
| 340 | if (match_bit != bit) { | 313 | if (match_bit != bit) { |
| ... | @@ -344,7 +317,7 @@ pub const Decode = struct { | ... | @@ -344,7 +317,7 @@ pub const Decode = struct { |
| 344 | } | 317 | } |
| 345 | | 318 | |
| 346 | while (result < 0x100) { | 319 | while (result < 0x100) { |
| 347 | result = (result << 1) ^ @intFromBool(try decoder.decodeBit(reader, &probs[result], update)); | 320 | result = (result << 1) ^ @intFromBool(try decoder.decodeBit(reader, &probs[result])); |
| 348 | } | 321 | } |
| 349 | | 322 | |
| 350 | return @as(u8, @truncate(result - 0x100)); | 323 | return @as(u8, @truncate(result - 0x100)); |
| ... | @@ -355,11 +328,10 @@ pub const Decode = struct { | ... | @@ -355,11 +328,10 @@ pub const Decode = struct { |
| 355 | reader: *Reader, | 328 | reader: *Reader, |
| 356 | decoder: *RangeDecoder, | 329 | decoder: *RangeDecoder, |
| 357 | length: usize, | 330 | length: usize, |
| 358 | update: bool, | | |
| 359 | ) !usize { | 331 | ) !usize { |
| 360 | const len_state = if (length > 3) 3 else length; | 332 | const len_state = if (length > 3) 3 else length; |
| 361 | | 333 | |
| 362 | const pos_slot = @as(usize, try self.pos_slot_decoder[len_state].parse(reader, decoder, update)); | 334 | const pos_slot = @as(usize, try self.pos_slot_decoder[len_state].parse(reader, decoder)); |
| 363 | if (pos_slot < 4) | 335 | if (pos_slot < 4) |
| 364 | return pos_slot; | 336 | return pos_slot; |
| 365 | | 337 | |
| ... | @@ -372,11 +344,10 @@ pub const Decode = struct { | ... | @@ -372,11 +344,10 @@ pub const Decode = struct { |
| 372 | num_direct_bits, | 344 | num_direct_bits, |
| 373 | &self.pos_decoders, | 345 | &self.pos_decoders, |
| 374 | result - pos_slot, | 346 | result - pos_slot, |
| 375 | update, | | |
| 376 | ); | 347 | ); |
| 377 | } else { | 348 | } else { |
| 378 | result += @as(usize, try decoder.get(reader, num_direct_bits - 4)) << 4; | 349 | result += @as(usize, try decoder.get(reader, num_direct_bits - 4)) << 4; |
| 379 | result += try self.align_decoder.parseReverse(reader, decoder, update); | 350 | result += try self.align_decoder.parseReverse(reader, decoder); |
| 380 | } | 351 | } |
| 381 | | 352 | |
| 382 | return result; | 353 | return result; |
| ... | @@ -500,22 +471,16 @@ pub const Decode = struct { | ... | @@ -500,22 +471,16 @@ pub const Decode = struct { |
| 500 | return struct { | 471 | return struct { |
| 501 | probs: [1 << num_bits]u16 = @splat(0x400), | 472 | probs: [1 << num_bits]u16 = @splat(0x400), |
| 502 | | 473 | |
| 503 | pub fn parse( | 474 | pub fn parse(self: *@This(), reader: *Reader, decoder: *RangeDecoder) !u32 { |
| 504 | self: *@This(), | 475 | return decoder.parseBitTree(reader, num_bits, &self.probs); |
| 505 | reader: *Reader, | | |
| 506 | decoder: *RangeDecoder, | | |
| 507 | update: bool, | | |
| 508 | ) !u32 { | | |
| 509 | return decoder.parseBitTree(reader, num_bits, &self.probs, update); | | |
| 510 | } | 476 | } |
| 511 | | 477 | |
| 512 | pub fn parseReverse( | 478 | pub fn parseReverse( |
| 513 | self: *@This(), | 479 | self: *@This(), |
| 514 | reader: *Reader, | 480 | reader: *Reader, |
| 515 | decoder: *RangeDecoder, | 481 | decoder: *RangeDecoder, |
| 516 | update: bool, | | |
| 517 | ) !u32 { | 482 | ) !u32 { |
| 518 | return decoder.parseReverseBitTree(reader, num_bits, &self.probs, 0, update); | 483 | return decoder.parseReverseBitTree(reader, num_bits, &self.probs, 0); |
| 519 | } | 484 | } |
| 520 | | 485 | |
| 521 | pub fn reset(self: *@This()) void { | 486 | pub fn reset(self: *@This()) void { |
| ... | @@ -536,14 +501,13 @@ pub const Decode = struct { | ... | @@ -536,14 +501,13 @@ pub const Decode = struct { |
| 536 | reader: *Reader, | 501 | reader: *Reader, |
| 537 | decoder: *RangeDecoder, | 502 | decoder: *RangeDecoder, |
| 538 | pos_state: usize, | 503 | pos_state: usize, |
| 539 | update: bool, | | |
| 540 | ) !usize { | 504 | ) !usize { |
| 541 | if (!try decoder.decodeBit(reader, &self.choice, update)) { | 505 | if (!try decoder.decodeBit(reader, &self.choice)) { |
| 542 | return @as(usize, try self.low_coder[pos_state].parse(reader, decoder, update)); | 506 | return @as(usize, try self.low_coder[pos_state].parse(reader, decoder)); |
| 543 | } else if (!try decoder.decodeBit(reader, &self.choice2, update)) { | 507 | } else if (!try decoder.decodeBit(reader, &self.choice2)) { |
| 544 | return @as(usize, try self.mid_coder[pos_state].parse(reader, decoder, update)) + 8; | 508 | return @as(usize, try self.mid_coder[pos_state].parse(reader, decoder)) + 8; |
| 545 | } else { | 509 | } else { |
| 546 | return @as(usize, try self.high_coder.parse(reader, decoder, update)) + 16; | 510 | return @as(usize, try self.high_coder.parse(reader, decoder)) + 16; |
| 547 | } | 511 | } |
| 548 | } | 512 | } |
| 549 | | 513 | |