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
|
use anyhow::bail;
use crate::{
pixel::Pixel,
ser::{Ser, Sink, Source},
};
#[derive(Clone, Debug)]
pub struct Block {
pub size: (usize, usize),
pub inner: BlockInner,
}
#[derive(Clone, Debug)]
pub enum BlockInner {
Literal(Vec<Pixel>),
Split(Box<[Block; 2]>),
Reference { translation: (usize, usize) },
}
impl Block {
pub fn write(&self, sink: &mut impl std::io::Write) -> anyhow::Result<()> {
match &self.inner {
BlockInner::Literal(pixels) => {
sink.put(0u8)?;
pixels.write(sink)?;
}
BlockInner::Split(box [a, b]) => {
sink.put(1u8)?;
a.write(sink)?;
b.write(sink)?;
}
BlockInner::Reference { translation: _ } => {
sink.put(2u8)?;
// sink.put(*translation)?;
}
}
Ok(())
}
pub fn read(source: &mut impl std::io::Read, size: (usize, usize)) -> anyhow::Result<Self> {
let inner = match source.get::<u8>()? {
0 => BlockInner::Literal(source.get()?),
1 => BlockInner::Split(Box::new({
let vert = size.0 > size.1;
let asize = if vert {
(size.0 / 2, size.1)
} else {
(size.0, size.1 / 2)
};
let bsize = if vert {
(size.0 - size.0 / 2, size.1)
} else {
(size.0, size.1 - size.1 / 2)
};
let a = Block::read(source, asize)?;
let b = Block::read(source, bsize)?;
[a, b]
})),
2 => BlockInner::Reference {
translation: (0, 0), //source.get()?,
},
x => bail!("corrupt block type ({})", x),
};
Ok(Self { size, inner })
}
}
impl Block {
pub fn is_literal(&self) -> bool {
matches!(self.inner, BlockInner::Literal(..))
}
}
|
