compression_codecs/brotli/
params.rs

1//! This module contains Brotli-specific types for async-compression.
2
3use brotli::enc::backward_references::{BrotliEncoderMode, BrotliEncoderParams};
4use compression_core::Level;
5
6/// Brotli compression parameters builder. This is a stable wrapper around Brotli's own encoder
7/// params type, to abstract over different versions of the Brotli library.
8///
9/// See the [Brotli documentation](https://www.brotli.org/encode.html#a9a8) for more information on
10/// these parameters.
11///
12/// # Examples
13///
14/// ```
15/// use compression_codecs::brotli;
16///
17/// let params = brotli::params::EncoderParams::default()
18///     .window_size(12)
19///     .text_mode();
20/// ```
21#[derive(Debug, Clone, Default)]
22pub struct EncoderParams {
23    inner: BrotliEncoderParams,
24}
25
26impl From<EncoderParams> for BrotliEncoderParams {
27    fn from(value: EncoderParams) -> Self {
28        value.inner
29    }
30}
31
32impl EncoderParams {
33    pub fn quality(mut self, level: Level) -> Self {
34        let quality = match level {
35            Level::Fastest => Some(0),
36            Level::Best => Some(11),
37            Level::Precise(quality) => Some(quality.clamp(0, 11)),
38            _ => None,
39        };
40        match quality {
41            Some(quality) => self.inner.quality = quality,
42            None => {
43                let default_params = BrotliEncoderParams::default();
44                self.inner.quality = default_params.quality;
45            }
46        }
47
48        self
49    }
50
51    /// Sets window size in bytes (as a power of two).
52    ///
53    /// Used as Brotli's `lgwin` parameter.
54    ///
55    /// `window_size` is clamped to `0 <= window_size <= 24`.
56    pub fn window_size(mut self, window_size: i32) -> Self {
57        self.inner.lgwin = window_size.clamp(0, 24);
58        self
59    }
60
61    /// Sets input block size in bytes (as a power of two).
62    ///
63    /// Used as Brotli's `lgblock` parameter.
64    ///
65    /// `block_size` is clamped to `16 <= block_size <= 24`.
66    pub fn block_size(mut self, block_size: i32) -> Self {
67        self.inner.lgblock = block_size.clamp(16, 24);
68        self
69    }
70
71    /// Sets hint for size of data to be compressed.
72    pub fn size_hint(mut self, size_hint: usize) -> Self {
73        self.inner.size_hint = size_hint;
74        self
75    }
76
77    /// Sets encoder to text mode.
78    ///
79    /// If input data is known to be UTF-8 text, this allows the compressor to make assumptions and
80    /// optimizations.
81    ///
82    /// Used as Brotli's `mode` parameter.
83    pub fn text_mode(mut self) -> Self {
84        self.inner.mode = BrotliEncoderMode::BROTLI_MODE_TEXT;
85        self
86    }
87
88    pub fn mode(mut self, mode: BrotliEncoderMode) -> Self {
89        self.inner.mode = mode;
90        self
91    }
92}