djvu-rs 0.30.2

Read, render, convert, and create DjVu files. Pure-Rust DjVu decoder/encoder with CLI, WebAssembly, and Python bindings. DjVu to PDF, EPUB, TIFF, PNG, and text. MIT licensed, no GPL dependencies.
Documentation 
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

//! Test-only writers shared by streaming export tests.

use std::io::{self, Seek, SeekFrom, Write};

/// A sink that accepts a fixed number of complete writes, then returns an
/// injected I/O error.
#[derive(Debug)]
pub(crate) struct FailingWriter {
    writes_until_failure: usize,
    position: u64,
    len: u64,
}

impl FailingWriter {
    pub(crate) fn after(writes_until_failure: usize) -> Self {
        Self {
            writes_until_failure,
            position: 0,
            len: 0,
        }
    }
}

impl Write for FailingWriter {
    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
        if self.writes_until_failure == 0 {
            return Err(io::Error::other("injected sink failure"));
        }

        self.writes_until_failure -= 1;
        let written = bytes.len();
        self.position = self.position.saturating_add(written as u64);
        self.len = self.len.max(self.position);
        Ok(written)
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl Seek for FailingWriter {
    fn seek(&mut self, position: SeekFrom) -> io::Result<u64> {
        let position = match position {
            SeekFrom::Start(position) => i128::from(position),
            SeekFrom::End(offset) => i128::from(self.len) + i128::from(offset),
            SeekFrom::Current(offset) => i128::from(self.position) + i128::from(offset),
        };
        self.position = u64::try_from(position).map_err(|_| {
            io::Error::new(io::ErrorKind::InvalidInput, "invalid injected writer seek")
        })?;
        Ok(self.position)
    }
}

/// A sink that counts output without retaining any bytes.
#[cfg(feature = "pdf")]
#[derive(Default)]
pub(crate) struct CountingWriter {
    position: u64,
    len: u64,
}

#[cfg(feature = "pdf")]
impl CountingWriter {
    pub(crate) fn bytes_written(&self) -> u64 {
        self.len
    }
}

#[cfg(feature = "pdf")]
impl Write for CountingWriter {
    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
        self.position = self.position.saturating_add(bytes.len() as u64);
        self.len = self.len.max(self.position);
        Ok(bytes.len())
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

#[cfg(feature = "pdf")]
impl Seek for CountingWriter {
    fn seek(&mut self, position: SeekFrom) -> io::Result<u64> {
        let position = match position {
            SeekFrom::Start(position) => i128::from(position),
            SeekFrom::End(offset) => i128::from(self.len) + i128::from(offset),
            SeekFrom::Current(offset) => i128::from(self.position) + i128::from(offset),
        };
        self.position = u64::try_from(position).map_err(|_| {
            io::Error::new(io::ErrorKind::InvalidInput, "invalid counting writer seek")
        })?;
        Ok(self.position)
    }
}