-
Notifications
You must be signed in to change notification settings - Fork 597
/
DeflateParams.scala
174 lines (152 loc) · 6.98 KB
/
DeflateParams.scala
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
/*
* Copyright (c) 2013 Functional Streams for Scala
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package fs2.compression
/** Deflate algorithm parameters.
*/
sealed trait DeflateParams {
/** Size of the internal buffer. Default size is 32 KB.
*/
val bufferSize: Int
/** Compression header. Defaults to [[ZLibParams.Header.ZLIB]].
*/
val header: ZLibParams.Header
/** Compression level. Default level is [[java.util.zip.Deflater.DEFAULT_COMPRESSION]].
*/
val level: DeflateParams.Level
/** Compression strategy. Default strategy is [[java.util.zip.Deflater.DEFAULT_STRATEGY]].
*/
val strategy: DeflateParams.Strategy
/** Compression flush mode. Default flush mode is [[java.util.zip.Deflater.NO_FLUSH]].
*/
val flushMode: DeflateParams.FlushMode
/** A [[Boolean]] indicating whether the `FLG.FHCRC` bit is set. Default is `false`.
* This is provided so that the compressor can be configured to have the CRC16 check enabled.
* Why opt-in and not opt-out? It turned out not all clients implemented that right.
* More context [[https://github.com/http4s/http4s/issues/5417 in this issue]].
*/
val fhCrcEnabled: Boolean
private[fs2] val bufferSizeOrMinimum: Int = bufferSize.max(128)
}
object DeflateParams {
def apply(
bufferSize: Int = 1024 * 32,
header: ZLibParams.Header = ZLibParams.Header.ZLIB,
level: DeflateParams.Level = DeflateParams.Level.DEFAULT,
strategy: DeflateParams.Strategy = DeflateParams.Strategy.DEFAULT,
flushMode: DeflateParams.FlushMode = DeflateParams.FlushMode.DEFAULT
): DeflateParams =
DeflateParamsImpl(bufferSize, header, level, strategy, flushMode, false)
def apply(
bufferSize: Int,
header: ZLibParams.Header,
level: DeflateParams.Level,
strategy: DeflateParams.Strategy,
flushMode: DeflateParams.FlushMode,
fhCrcEnabled: Boolean
): DeflateParams =
DeflateParamsImpl(bufferSize, header, level, strategy, flushMode, fhCrcEnabled)
private case class DeflateParamsImpl(
bufferSize: Int,
header: ZLibParams.Header,
level: DeflateParams.Level,
strategy: DeflateParams.Strategy,
flushMode: DeflateParams.FlushMode,
fhCrcEnabled: Boolean
) extends DeflateParams
sealed abstract class Level(private[fs2] val juzDeflaterLevel: Int)
case object Level {
private[fs2] def apply(level: Int): Level =
level match {
case DEFAULT.juzDeflaterLevel => Level.DEFAULT
case ZERO.juzDeflaterLevel => Level.ZERO
case ONE.juzDeflaterLevel => Level.ONE
case TWO.juzDeflaterLevel => Level.TWO
case THREE.juzDeflaterLevel => Level.THREE
case FOUR.juzDeflaterLevel => Level.FOUR
case FIVE.juzDeflaterLevel => Level.FIVE
case SIX.juzDeflaterLevel => Level.SIX
case SEVEN.juzDeflaterLevel => Level.SEVEN
case EIGHT.juzDeflaterLevel => Level.EIGHT
case NINE.juzDeflaterLevel => Level.NINE
}
case object DEFAULT extends Level(juzDeflaterLevel = -1)
case object BEST_SPEED extends Level(juzDeflaterLevel = 1)
case object BEST_COMPRESSION extends Level(juzDeflaterLevel = 9)
case object NO_COMPRESSION extends Level(juzDeflaterLevel = 0)
case object ZERO extends Level(juzDeflaterLevel = 0)
case object ONE extends Level(juzDeflaterLevel = 1)
case object TWO extends Level(juzDeflaterLevel = 2)
case object THREE extends Level(juzDeflaterLevel = 3)
case object FOUR extends Level(juzDeflaterLevel = 4)
case object FIVE extends Level(juzDeflaterLevel = 5)
case object SIX extends Level(juzDeflaterLevel = 6)
case object SEVEN extends Level(juzDeflaterLevel = 7)
case object EIGHT extends Level(juzDeflaterLevel = 8)
case object NINE extends Level(juzDeflaterLevel = 9)
}
sealed abstract class Strategy(private[fs2] val juzDeflaterStrategy: Int)
case object Strategy {
private[fs2] def apply(strategy: Int): Strategy =
strategy match {
case DEFAULT.juzDeflaterStrategy => Strategy.DEFAULT
case FILTERED.juzDeflaterStrategy => Strategy.FILTERED
case HUFFMAN_ONLY.juzDeflaterStrategy => Strategy.HUFFMAN_ONLY
}
case object DEFAULT extends Strategy(juzDeflaterStrategy = 0)
case object BEST_SPEED extends Strategy(juzDeflaterStrategy = 2)
case object BEST_COMPRESSION extends Strategy(juzDeflaterStrategy = 0)
case object FILTERED extends Strategy(juzDeflaterStrategy = 1)
case object HUFFMAN_ONLY extends Strategy(juzDeflaterStrategy = 2)
}
sealed abstract class FlushMode(private[fs2] val juzDeflaterFlushMode: Int)
case object FlushMode {
private[fs2] def apply(flushMode: Int): FlushMode =
flushMode match {
case DEFAULT.juzDeflaterFlushMode => FlushMode.NO_FLUSH
case SYNC_FLUSH.juzDeflaterFlushMode => FlushMode.SYNC_FLUSH
case FULL_FLUSH.juzDeflaterFlushMode => FlushMode.FULL_FLUSH
}
case object DEFAULT extends FlushMode(juzDeflaterFlushMode = 0)
case object BEST_SPEED extends FlushMode(juzDeflaterFlushMode = 3)
case object BEST_COMPRESSION extends FlushMode(juzDeflaterFlushMode = 0)
case object NO_FLUSH extends FlushMode(juzDeflaterFlushMode = 0)
case object SYNC_FLUSH extends FlushMode(juzDeflaterFlushMode = 2)
case object FULL_FLUSH extends FlushMode(juzDeflaterFlushMode = 3)
}
/** Reasonable defaults for most applications.
*/
val DEFAULT: DeflateParams = DeflateParams()
/** Best speed for real-time, intermittent, fragmented, interactive or discontinuous streams.
*/
val BEST_SPEED: DeflateParams = DeflateParams(
level = Level.BEST_SPEED,
strategy = Strategy.BEST_SPEED,
flushMode = FlushMode.BEST_SPEED
)
/** Best compression for finite, complete, readily-available, continuous or file streams.
*/
val BEST_COMPRESSION: DeflateParams = DeflateParams(
bufferSize = 1024 * 128,
level = Level.BEST_COMPRESSION,
strategy = Strategy.BEST_COMPRESSION,
flushMode = FlushMode.BEST_COMPRESSION
)
}