1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55

/*
 * Delta decoder
 *
 * Author: Lasse Collin <lasse.collin@tukaani.org>
 *
 * Translation to Go: Michael Cross <https://github.com/xi2>
 *
 * This file has been put into the public domain.
 * You can do whatever you want with this file.
 */

package xz

type xzDecDelta struct {
	delta    [256]byte
	pos      byte
	distance int // in range [1, 256]
}

/*
 * Decode raw stream which has a delta filter as the first filter.
 */
func xzDecDeltaRun(s *xzDecDelta, b *xzBuf, chain func(*xzBuf) xzRet) xzRet {
	outStart := b.outPos
	ret := chain(b)
	for i := outStart; i < b.outPos; i++ {
		tmp := b.out[i] + s.delta[byte(s.distance+int(s.pos))]
		s.delta[s.pos] = tmp
		b.out[i] = tmp
		s.pos--
	}
	return ret
}

/*
 * Allocate memory for a delta decoder. xzDecDeltaReset must be used
 * before calling xzDecDeltaRun.
 */
func xzDecDeltaCreate() *xzDecDelta {
	return new(xzDecDelta)
}

/*
 * Returns xzOK if the given distance is valid. Otherwise
 * xzOptionsError is returned.
 */
func xzDecDeltaReset(s *xzDecDelta, distance int) xzRet {
	if distance < 1 || distance > 256 {
		return xzOptionsError
	}
	s.delta = [256]byte{}
	s.pos = 0
	s.distance = distance
	return xzOK
}