Fixed bug
parent
e6e403eb36
commit
1775bbc171
GPG Key ID:
A53FDD4FD091A276
|
|
@ -51,9 +51,21 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.9.0"
|
||||
version = "1.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
|
||||
checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
|
||||
|
||||
[[package]]
|
||||
name = "exf"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"arbitrary-int",
|
||||
"bilge",
|
||||
"bitstream-io",
|
||||
"bitvec",
|
||||
"either",
|
||||
"ux",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "funty"
|
||||
|
|
@ -70,18 +82,6 @@ dependencies = [
|
|||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pictext"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"arbitrary-int",
|
||||
"bilge",
|
||||
"bitstream-io",
|
||||
"bitvec",
|
||||
"either",
|
||||
"ux",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error"
|
||||
version = "1.0.4"
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
[package]
|
||||
name = "pictext"
|
||||
name = "exf"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
|
|
|
|||
277
src/lib.rs
277
src/lib.rs
|
|
@ -1,17 +1,93 @@
|
|||
use bitstream_io::{BigEndian, BitRead, BitReader, BitWrite, BitWriter, Endianness};
|
||||
use bitvec::{slice::BitSlice, vec::BitVec};
|
||||
use bitvec::{field::BitField, slice::BitSlice, vec::BitVec};
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
ops::Index,
|
||||
cell::{Cell, RefCell},
|
||||
ops::{DerefMut, Range},
|
||||
};
|
||||
mod bits;
|
||||
use bits::*;
|
||||
use either::Either;
|
||||
use ux::u1;
|
||||
|
||||
pub fn read_quad_tree(input: &mut &BitSlice) {}
|
||||
pub fn split_each_mut<'a>(
|
||||
array2: &'a mut [&'a mut BitSlice<u8>],
|
||||
at: usize,
|
||||
) -> (
|
||||
&'a mut [&'a mut BitSlice<u8>],
|
||||
&'a mut [&'a mut BitSlice<u8>],
|
||||
) {
|
||||
let a = &mut [];
|
||||
let b = &mut [];
|
||||
for (i, row) in array2.iter_mut().enumerate() {
|
||||
let c = row.split_at_mut(at);
|
||||
(a[i], b[i]) = (
|
||||
c.0.bit_domain_mut().region().unwrap().1,
|
||||
c.1.bit_domain_mut().region().unwrap().1,
|
||||
);
|
||||
}
|
||||
(a, b)
|
||||
}
|
||||
|
||||
pub fn read_char_bits(input: &mut &BitSlice) -> BitVec {
|
||||
pub fn index_2d<'a>(
|
||||
mut input: &'a mut [&'a mut BitSlice<u8>],
|
||||
index: (Range<usize>, Range<usize>),
|
||||
) -> Vec<&'a mut BitSlice<u8>> {
|
||||
let mut output = Vec::new();
|
||||
for row in input[index.1].iter_mut() {
|
||||
output.push(&mut row[index.0.clone()])
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
pub fn write_each(value: bool, output: &mut [&mut BitSlice<u8>]) {
|
||||
for row in output {
|
||||
for mut bit in row.iter_mut() {
|
||||
bit.set(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_quad_tree<'a>(input: &mut &BitSlice, output: &'a mut [&'a mut BitSlice<u8>]) {
|
||||
let (i0, i1, i2, i3) = (input[0], input[1], input[2], input[3]);
|
||||
*input = &input[4..];
|
||||
let hlen = output.first().map_or(0, |f| f.len());
|
||||
let vlen = output.len();
|
||||
let hmid = hlen / 2;
|
||||
let vmid = vlen / 2;
|
||||
let temp_share = RefCell::new(output);
|
||||
let mut q0 = index_2d(unsafe { *temp_share.as_ptr() }, (0..hmid, 0..vmid));
|
||||
let mut q1 = index_2d(unsafe { *temp_share.as_ptr() }, (hmid..hlen, 0..vmid));
|
||||
let mut q2 = index_2d(unsafe { *temp_share.as_ptr() }, (0..hmid, vmid..vlen));
|
||||
let mut q3 = index_2d(unsafe { *temp_share.as_ptr() }, (hmid..hlen, vmid..vlen));
|
||||
if hlen == 2 || vlen == 2 {
|
||||
q0[0].set(0, i0);
|
||||
q1[0].set(0, i1);
|
||||
q2[0].set(0, i2);
|
||||
q3[0].set(0, i3);
|
||||
} else {
|
||||
if i0 {
|
||||
read_quad_tree(input, &mut q0);
|
||||
} else {
|
||||
write_each(input[0], &mut q0);
|
||||
*input = &input[1..];
|
||||
}
|
||||
if i1 {
|
||||
read_quad_tree(input, &mut q1);
|
||||
} else {
|
||||
write_each(input[0], &mut q1);
|
||||
*input = &input[1..];
|
||||
}
|
||||
if i2 {
|
||||
read_quad_tree(input, &mut q2);
|
||||
} else {
|
||||
write_each(input[0], &mut q2);
|
||||
*input = &input[1..];
|
||||
}
|
||||
if i3 {
|
||||
read_quad_tree(input, &mut q3);
|
||||
} else {
|
||||
write_each(input[0], &mut q3);
|
||||
*input = &input[1..];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_element_bits(input: &mut &BitSlice) -> BitVec {
|
||||
let mut output = BitVec::new();
|
||||
let mut end = 0;
|
||||
for byte in input.chunks(8) {
|
||||
|
|
@ -25,6 +101,41 @@ pub fn read_char_bits(input: &mut &BitSlice) -> BitVec {
|
|||
output
|
||||
}
|
||||
|
||||
pub enum Element {
|
||||
ControlCode {
|
||||
data: u128,
|
||||
},
|
||||
Glyph {
|
||||
courtesy_space: bool,
|
||||
image_data: Vec<BitVec<u8>>,
|
||||
},
|
||||
}
|
||||
|
||||
pub fn parse_element(input: &mut &BitSlice) -> Element {
|
||||
let element_bits = read_element_bits(input);
|
||||
let is_glyph = input[0];
|
||||
*input = &input[1..];
|
||||
if is_glyph {
|
||||
let cs = input[0];
|
||||
*input = &input[1..];
|
||||
|
||||
let mut image_data = vec![BitVec::<u8>::repeat(false, 64); 64];
|
||||
let slice2d = &mut [];
|
||||
for (i, row) in image_data.iter_mut().enumerate() {
|
||||
slice2d[i] = &mut row[..];
|
||||
}
|
||||
read_quad_tree(&mut &element_bits[..], slice2d);
|
||||
Element::Glyph {
|
||||
courtesy_space: cs,
|
||||
image_data,
|
||||
}
|
||||
} else {
|
||||
Element::ControlCode {
|
||||
data: input.load_le(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Subject to change
|
||||
pub enum ControlCode {
|
||||
DirectionRightDown = 4,
|
||||
|
|
@ -32,149 +143,3 @@ pub enum ControlCode {
|
|||
DirectionRightUp = 6,
|
||||
DirectionLeftUp = 7,
|
||||
}
|
||||
|
||||
pub struct Character {
|
||||
pub x_offset: i8,
|
||||
pub y_offset: i8,
|
||||
pub control_code: Option<u8>,
|
||||
pub graphical_data: Option<[u8; 512]>,
|
||||
}
|
||||
|
||||
pub struct QuadNode<T> {
|
||||
q0: T,
|
||||
q1: T,
|
||||
q2: T,
|
||||
q3: T,
|
||||
}
|
||||
|
||||
impl<T> Index<usize> for QuadNode<T> {
|
||||
type Output = T;
|
||||
|
||||
fn index(&self, index: usize) -> &Self::Output {
|
||||
match index {
|
||||
0 => &self.q0,
|
||||
1 => &self.q1,
|
||||
2 => &self.q2,
|
||||
3 => &self.q3,
|
||||
_ => panic![
|
||||
"Index out of bounds: QuadNode can be indexed up to 4 but the index was {index}"
|
||||
],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub type GraphicalData = QuadNode<
|
||||
Either<
|
||||
QuadNode<
|
||||
Either<
|
||||
QuadNode<Either<QuadNode<Either<QuadNode<Either<QuadNode<u1>, u1>>, u1>>, u1>>,
|
||||
u1,
|
||||
>,
|
||||
>,
|
||||
u1,
|
||||
>,
|
||||
>;
|
||||
|
||||
pub fn read_int() {}
|
||||
|
||||
pub fn decode(input: &[u8]) -> Vec<Character> {
|
||||
let mut input = BitReaderWrapper {
|
||||
bit_count: 0,
|
||||
bitreader: BitReader::<&[u8], BigEndian>::new(input),
|
||||
};
|
||||
let mut output = vec![];
|
||||
while let Ok(graphical) = input.bitreader.read_bit() {
|
||||
input.bit_count += 1;
|
||||
if graphical {
|
||||
let offset_x = input.read_bit().unwrap();
|
||||
let offset_y = input.read_bit().unwrap();
|
||||
let mut x_offset = 0i8;
|
||||
let mut y_offset = 0i8;
|
||||
if offset_x {
|
||||
x_offset = input.read::<i8>(7).unwrap();
|
||||
}
|
||||
if offset_y {
|
||||
y_offset = input.read_signed::<i8>(7).unwrap();
|
||||
}
|
||||
let mut map = [0u64; 64];
|
||||
let mut value = None;
|
||||
let mut erase: i8 = -1;
|
||||
for (index, shift, q) in (0..4096).map(|n| {
|
||||
(
|
||||
n / 64 as usize,
|
||||
n % 64 as usize,
|
||||
[
|
||||
(n / 1024 % 4) as u8,
|
||||
(n / 256 % 4) as u8,
|
||||
(n / 64 % 4) as u8,
|
||||
(n / 16 % 4) as u8,
|
||||
(n / 4 % 4) as u8,
|
||||
(n % 4) as u8,
|
||||
],
|
||||
)
|
||||
}) {
|
||||
// Check start of sub tree traversals to see if cached homogeneity.
|
||||
for i in 0..q.len() as i8 {
|
||||
if value.is_none() {
|
||||
if q.ends_with(&vec![0; q.len() - i as usize]) {
|
||||
if input.read_bit().unwrap() {
|
||||
erase = i;
|
||||
value = Some(input.read_bit().unwrap());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
map[index] |= if let Some(v) = value {
|
||||
if v {
|
||||
1 << shift
|
||||
} else {
|
||||
0
|
||||
}
|
||||
} else if input.read_bit().unwrap() {
|
||||
1 << shift
|
||||
} else {
|
||||
0
|
||||
};
|
||||
// Check ends of traversals to reset state.
|
||||
for i in 0..q.len() as i8 {
|
||||
if q.ends_with(&vec![3; q.len() - i as usize]) {
|
||||
if erase == i {
|
||||
value = None;
|
||||
erase = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut raster_data: [u8; 512] = [0; 512];
|
||||
let mut iter = map.iter().map(|t6| t6.to_le_bytes()).flatten();
|
||||
raster_data.fill_with(|| iter.next().unwrap());
|
||||
output.push(Character {
|
||||
x_offset,
|
||||
y_offset,
|
||||
control_code: None,
|
||||
graphical_data: Some(raster_data),
|
||||
});
|
||||
input.skip(8 - input.bit_count as u32 % 8).ok();
|
||||
} else {
|
||||
output.push(Character {
|
||||
x_offset: 0,
|
||||
y_offset: 0,
|
||||
control_code: input.read::<u8>(7).unwrap().into(),
|
||||
graphical_data: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
pub fn encode(input: &[Character]) -> Vec<u8> {
|
||||
let mut tree_data = vec![];
|
||||
let mut output = BitWriter::<&mut Vec<u8>, BigEndian>::new(&mut tree_data);
|
||||
for character in input {
|
||||
if let Some(raster) = character.graphical_data {
|
||||
output.write_bit(true);
|
||||
}
|
||||
}
|
||||
|
||||
tree_data
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue