G2/lbee-utils
1
0
Fork 0
mirror of https://github.com/G2-Games/lbee-utils.git synced 2025-04-19 07:12:55 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replaced byteorder with byteorder-lite, ran cargo fmt

Browse source
This commit is contained in:
G2-Games 2024-11-12 19:50:10 -06:00
parent d253d57816
commit ec60308e6a
15 changed files with 72 additions and 106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cz/Cargo.toml
View file

@ -13,7 +13,7 @@ authors.workspace = true
png = ["dep:image"]
[dependencies]
byteorder = "1.5"
byteorder-lite = "0.1.0"
thiserror = "1.0"
imagequant = "4.3"
rgb = "0.8"

6
cz/src/color.rs
View file

@ -1,4 +1,3 @@
use byteorder::ReadBytesExt;
use imagequant::Attributes;
use rgb::{ComponentSlice, RGBA8};
use std::{
@ -35,10 +34,7 @@ impl Palette {
}
/// Get a palette from the input stream, beginning where the palette starts.
pub fn get_palette<T: Seek + ReadBytesExt + Read>(
input: &mut T,
num_colors: usize,
) -> Result<Palette, CzError> {
pub fn get_palette<T: Seek + Read>(input: &mut T, num_colors: usize) -> Result<Palette, CzError> {
let mut colormap = Vec::with_capacity(num_colors);
let mut rgba_buf = [0u8; 4];

50
cz/src/common.rs
View file

@ -2,7 +2,7 @@
use std::io::{self, Read, Seek, Write};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use byteorder_lite::{ReadBytesExt, WriteBytesExt, LE};
use thiserror::Error;
#[derive(Error, Debug)]
@ -132,10 +132,10 @@ impl CommonHeader {
let mut header = Self {
version,
length: bytes.read_u32::<LittleEndian>()?,
width: bytes.read_u16::<LittleEndian>()?,
height: bytes.read_u16::<LittleEndian>()?,
depth: bytes.read_u16::<LittleEndian>()?,
length: bytes.read_u32::<LE>()?,
width: bytes.read_u16::<LE>()?,
height: bytes.read_u16::<LE>()?,
depth: bytes.read_u16::<LE>()?,
unknown: bytes.read_u8()?,
};
@ -204,10 +204,10 @@ impl CommonHeader {
let magic_bytes = [b'C', b'Z', b'0' + self.version as u8, b'\0'];
output.write_all(&magic_bytes)?;
output.write_u32::<LittleEndian>(self.length() as u32)?;
output.write_u16::<LittleEndian>(self.width())?;
output.write_u16::<LittleEndian>(self.height())?;
output.write_u16::<LittleEndian>(self.depth())?;
output.write_u32::<LE>(self.length() as u32)?;
output.write_u16::<LE>(self.width())?;
output.write_u16::<LE>(self.height())?;
output.write_u16::<LE>(self.depth())?;
output.write_u8(self.color_block())?;
Ok(())
@ -282,27 +282,27 @@ impl ExtendedHeader {
self
}
pub fn from_bytes<T: Seek + ReadBytesExt + Read>(
pub fn from_bytes<T: Seek + Read>(
input: &mut T,
common_header: &CommonHeader,
) -> Result<Self, CzError> {
let mut unknown_1 = [0u8; 5];
input.read_exact(&mut unknown_1)?;
let crop_width = input.read_u16::<LittleEndian>()?;
let crop_height = input.read_u16::<LittleEndian>()?;
let crop_width = input.read_u16::<LE>()?;
let crop_height = input.read_u16::<LE>()?;
let bounds_width = input.read_u16::<LittleEndian>()?;
let bounds_height = input.read_u16::<LittleEndian>()?;
let bounds_width = input.read_u16::<LE>()?;
let bounds_height = input.read_u16::<LE>()?;
let mut offset_width = None;
let mut offset_height = None;
let mut unknown_2 = None;
if common_header.length() > 28 {
offset_width = Some(input.read_u16::<LittleEndian>()?);
offset_height = Some(input.read_u16::<LittleEndian>()?);
offset_width = Some(input.read_u16::<LE>()?);
offset_height = Some(input.read_u16::<LE>()?);
unknown_2 = Some(input.read_u32::<LittleEndian>()?);
unknown_2 = Some(input.read_u32::<LE>()?);
}
Ok(Self {
@ -321,17 +321,17 @@ impl ExtendedHeader {
})
}
pub fn write_into<T: WriteBytesExt + Write>(&self, output: &mut T) -> Result<(), io::Error> {
pub fn write_into<T: Write>(&self, output: &mut T) -> Result<(), io::Error> {
output.write_all(&self.unknown_1)?;
output.write_u16::<LittleEndian>(self.crop_width)?;
output.write_u16::<LittleEndian>(self.crop_height)?;
output.write_u16::<LittleEndian>(self.bounds_width)?;
output.write_u16::<LittleEndian>(self.bounds_height)?;
output.write_u16::<LE>(self.crop_width)?;
output.write_u16::<LE>(self.crop_height)?;
output.write_u16::<LE>(self.bounds_width)?;
output.write_u16::<LE>(self.bounds_height)?;
if self.offset_width.is_some() {
output.write_u16::<LittleEndian>(self.offset_width.unwrap())?;
output.write_u16::<LittleEndian>(self.offset_height.unwrap())?;
output.write_u32::<LittleEndian>(self.unknown_2.unwrap())?;
output.write_u16::<LE>(self.offset_width.unwrap())?;
output.write_u16::<LE>(self.offset_height.unwrap())?;
output.write_u32::<LE>(self.unknown_2.unwrap())?;
}
Ok(())

21
cz/src/compression.rs
View file

@ -1,4 +1,3 @@
use byteorder::{ReadBytesExt, WriteBytesExt, LE};
use std::{
collections::HashMap,
io::{Read, Seek, Write},
@ -6,6 +5,7 @@ use std::{
use crate::binio::BitIo;
use crate::common::CzError;
use byteorder_lite::{ReadBytesExt, WriteBytesExt, LE};
/// The size of compressed data in each chunk
#[derive(Debug, Clone, Copy)]
@ -37,10 +37,7 @@ pub struct CompressionInfo {
}
impl CompressionInfo {
pub fn write_into<T: WriteBytesExt + Write>(
&self,
output: &mut T,
) -> Result<(), std::io::Error> {
pub fn write_into<T: Write>(&self, output: &mut T) -> Result<(), std::io::Error> {
output.write_u32::<LE>(self.chunk_count as u32)?;
for chunk in &self.chunks {
@ -56,9 +53,7 @@ impl CompressionInfo {
///
/// These are defined by a length value, followed by the number of data chunks
/// that length value says split into compressed and original size u32 values
pub fn get_chunk_info<T: Seek + ReadBytesExt + Read>(
bytes: &mut T,
) -> Result<CompressionInfo, CzError> {
pub fn get_chunk_info<T: Seek + Read>(bytes: &mut T) -> Result<CompressionInfo, CzError> {
let parts_count = bytes.read_u32::<LE>()?;
let mut part_sizes = vec![];
@ -89,7 +84,7 @@ pub fn get_chunk_info<T: Seek + ReadBytesExt + Read>(
}
/// Decompress an LZW compressed stream like CZ1
pub fn decompress<T: Seek + ReadBytesExt + Read>(
pub fn decompress<T: Seek + Read>(
input: &mut T,
chunk_info: &CompressionInfo,
) -> Result<Vec<u8>, CzError> {
@ -144,7 +139,7 @@ fn decompress_lzw(input_data: &[u16], size: usize) -> Vec<u8> {
}
/// Decompress an LZW compressed stream like CZ2
pub fn decompress2<T: Seek + ReadBytesExt + Read>(
pub fn decompress2<T: Seek + Read>(
input: &mut T,
chunk_info: &CompressionInfo,
) -> Result<Vec<u8>, CzError> {
@ -196,7 +191,11 @@ fn decompress_lzw2(input_data: &[u8], size: usize) -> Vec<u8> {
entry = w.clone();
entry.push(w[0])
} else {
panic!("Bad compressed element {} at offset {}", element, bit_io.byte_offset())
panic!(
"Bad compressed element {} at offset {}",
element,
bit_io.byte_offset()
)
}
//println!("{}", element);

2
cz/src/dynamic.rs
View file

@ -1,4 +1,4 @@
use byteorder::ReadBytesExt;
use byteorder_lite::ReadBytesExt;
use rgb::ComponentSlice;
use std::{
fs::File,

5
cz/src/formats/cz0.rs
View file

@ -1,9 +1,8 @@
use byteorder::{ReadBytesExt, WriteBytesExt};
use std::io::{Read, Seek, Write};
use crate::common::CzError;
pub fn decode<T: Seek + ReadBytesExt + Read>(input: &mut T) -> Result<Vec<u8>, CzError> {
pub fn decode<T: Seek + Read>(input: &mut T) -> Result<Vec<u8>, CzError> {
// Get the rest of the file, which is the bitmap
let mut bitmap = vec![];
input.read_to_end(&mut bitmap)?;
@ -11,7 +10,7 @@ pub fn decode<T: Seek + ReadBytesExt + Read>(input: &mut T) -> Result<Vec<u8>, C
Ok(bitmap)
}
pub fn encode<T: WriteBytesExt + Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
pub fn encode<T: Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
output.write_all(bitmap)?;
Ok(())

5
cz/src/formats/cz1.rs
View file

@ -1,10 +1,9 @@
use byteorder::{ReadBytesExt, WriteBytesExt};
use std::io::{Read, Seek, SeekFrom, Write};
use crate::common::CzError;
use crate::compression::{compress, decompress, get_chunk_info};
pub fn decode<T: Seek + ReadBytesExt + Read>(bytes: &mut T) -> Result<Vec<u8>, CzError> {
pub fn decode<T: Seek + Read>(bytes: &mut T) -> Result<Vec<u8>, CzError> {
// Get information about the compressed chunks
let block_info = get_chunk_info(bytes)?;
bytes.seek(SeekFrom::Start(block_info.length as u64))?;
@ -15,7 +14,7 @@ pub fn decode<T: Seek + ReadBytesExt + Read>(bytes: &mut T) -> Result<Vec<u8>, C
Ok(bitmap)
}
pub fn encode<T: WriteBytesExt + Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
pub fn encode<T: Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
let (compressed_data, compressed_info) = compress(bitmap, 0xFEFD);
compressed_info.write_into(output)?;

5
cz/src/formats/cz2.rs
View file

@ -1,10 +1,9 @@
use byteorder::{ReadBytesExt, WriteBytesExt};
use std::io::{Read, Seek, SeekFrom, Write};
use crate::common::CzError;
use crate::compression::{compress2, decompress2, get_chunk_info};
pub fn decode<T: Seek + ReadBytesExt + Read>(bytes: &mut T) -> Result<Vec<u8>, CzError> {
pub fn decode<T: Seek + Read>(bytes: &mut T) -> Result<Vec<u8>, CzError> {
// Get information about the compressed chunks
let block_info = get_chunk_info(bytes)?;
bytes.seek(SeekFrom::Start(block_info.length as u64))?;
@ -15,7 +14,7 @@ pub fn decode<T: Seek + ReadBytesExt + Read>(bytes: &mut T) -> Result<Vec<u8>, C
Ok(bitmap)
}
pub fn encode<T: WriteBytesExt + Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
pub fn encode<T: Write>(output: &mut T, bitmap: &[u8]) -> Result<(), CzError> {
let (compressed_data, compressed_info) = compress2(&bitmap);
compressed_info.write_into(output)?;

8
cz/src/formats/cz3.rs
View file

@ -1,13 +1,9 @@
use byteorder::{ReadBytesExt, WriteBytesExt};
use std::io::{Read, Seek, SeekFrom, Write};
use crate::common::{CommonHeader, CzError};
use crate::compression::{compress, decompress, get_chunk_info};
pub fn decode<T: Seek + ReadBytesExt + Read>(
bytes: &mut T,
header: &CommonHeader,
) -> Result<Vec<u8>, CzError> {
pub fn decode<T: Seek + Read>(bytes: &mut T, header: &CommonHeader) -> Result<Vec<u8>, CzError> {
let block_info = get_chunk_info(bytes)?;
bytes.seek(SeekFrom::Start(block_info.length as u64))?;
@ -18,7 +14,7 @@ pub fn decode<T: Seek + ReadBytesExt + Read>(
Ok(bitmap)
}
pub fn encode<T: WriteBytesExt + Write>(
pub fn encode<T: Write>(
output: &mut T,
bitmap: &[u8],
header: &CommonHeader,

8
cz/src/formats/cz4.rs
View file

@ -1,13 +1,9 @@
use byteorder::{ReadBytesExt, WriteBytesExt};
use std::io::{Read, Seek, SeekFrom, Write};
use crate::common::{CommonHeader, CzError};
use crate::compression::{compress, decompress, get_chunk_info};
pub fn decode<T: Seek + ReadBytesExt + Read>(
bytes: &mut T,
header: &CommonHeader,
) -> Result<Vec<u8>, CzError> {
pub fn decode<T: Seek + Read>(bytes: &mut T, header: &CommonHeader) -> Result<Vec<u8>, CzError> {
let block_info = get_chunk_info(bytes)?;
bytes.seek(SeekFrom::Start(block_info.length as u64))?;
@ -18,7 +14,7 @@ pub fn decode<T: Seek + ReadBytesExt + Read>(
Ok(bitmap)
}
pub fn encode<T: WriteBytesExt + Write>(
pub fn encode<T: Write>(
output: &mut T,
bitmap: &[u8],
header: &CommonHeader,

35
cz/tests/round_trip.rs
View file

@ -13,12 +13,7 @@ const TEST_IMAGES: &[TestImage] = &[KODIM03, KODIM23, SQPTEXT, DPFLOGO];
#[test]
fn cz0_round_trip() {
for image in TEST_IMAGES {
let original_cz = DynamicCz::from_raw(
CzVersion::CZ0,
image.0,
image.1,
image.2.to_vec()
);
let original_cz = DynamicCz::from_raw(CzVersion::CZ0, image.0, image.1, image.2.to_vec());
let mut cz_bytes = Vec::new();
original_cz.encode(&mut cz_bytes).unwrap();
@ -33,12 +28,7 @@ fn cz0_round_trip() {
#[test]
fn cz1_round_trip() {
for image in TEST_IMAGES {
let original_cz = DynamicCz::from_raw(
CzVersion::CZ1,
image.0,
image.1,
image.2.to_vec()
);
let original_cz = DynamicCz::from_raw(CzVersion::CZ1, image.0, image.1, image.2.to_vec());
let mut cz_bytes = Vec::new();
original_cz.encode(&mut cz_bytes).unwrap();
@ -54,12 +44,7 @@ fn cz1_round_trip() {
fn cz2_round_trip() {
let mut i = 0;
for image in TEST_IMAGES {
let original_cz = DynamicCz::from_raw(
CzVersion::CZ2,
image.0,
image.1,
image.2.to_vec()
);
let original_cz = DynamicCz::from_raw(CzVersion::CZ2, image.0, image.1, image.2.to_vec());
let mut cz_bytes = Vec::new();
original_cz.encode(&mut cz_bytes).unwrap();
@ -76,12 +61,7 @@ fn cz2_round_trip() {
#[test]
fn cz3_round_trip() {
for image in TEST_IMAGES {
let original_cz = DynamicCz::from_raw(
CzVersion::CZ3,
image.0,
image.1,
image.2.to_vec()
);
let original_cz = DynamicCz::from_raw(CzVersion::CZ3, image.0, image.1, image.2.to_vec());
let mut cz_bytes = Vec::new();
original_cz.encode(&mut cz_bytes).unwrap();
@ -96,12 +76,7 @@ fn cz3_round_trip() {
#[test]
fn cz4_round_trip() {
for image in TEST_IMAGES {
let original_cz = DynamicCz::from_raw(
CzVersion::CZ4,
image.0,
image.1,
image.2.to_vec()
);
let original_cz = DynamicCz::from_raw(CzVersion::CZ4, image.0, image.1, image.2.to_vec());
let mut cz_bytes = Vec::new();
original_cz.encode(&mut cz_bytes).unwrap();

2
luca_pak/src/lib.rs
View file

@ -66,7 +66,7 @@ pub struct PakLimits {
impl Default for PakLimits {
fn default() -> Self {
Self {
entry_limit: 10_000, // 10,000 entries
entry_limit: 10_000, // 10,000 entries
size_limit: u32::MAX as usize, // 10 gb
}
}

18
utils/build.rs
View file

@ -8,10 +8,16 @@ fn main() {
let si = SysinfoBuilder::all_sysinfo().unwrap();
Emitter::default()
.add_instructions(&build).unwrap()
.add_instructions(&cargo).unwrap()
.add_instructions(&git2).unwrap()
.add_instructions(&rustc).unwrap()
.add_instructions(&si).unwrap()
.emit().unwrap();
.add_instructions(&build)
.unwrap()
.add_instructions(&cargo)
.unwrap()
.add_instructions(&git2)
.unwrap()
.add_instructions(&rustc)
.unwrap()
.add_instructions(&si)
.unwrap()
.emit()
.unwrap();
}

3
utils/src/bin/czutil.rs
View file

@ -1,7 +1,8 @@
use clap::{error::ErrorKind, Command, Error, Parser, Subcommand};
use std::{
fs,
path::{Path, PathBuf}, process::exit,
path::{Path, PathBuf},
process::exit,
};
/// Utility to maniuplate CZ image files from the LUCA System game engine by

8
utils/src/bin/pakutil.rs
View file

@ -67,9 +67,9 @@ fn main() {
println!(
"{}, {} v{}-{}",
env!("CARGO_BIN_NAME"),
env!("CARGO_PKG_NAME"),
env!("CARGO_PKG_VERSION"),
&env!("VERGEN_GIT_SHA")[0..=6]
env!("CARGO_PKG_NAME"),
env!("CARGO_PKG_VERSION"),
&env!("VERGEN_GIT_SHA")[0..=6]
);
exit(0);
}
@ -83,7 +83,7 @@ fn main() {
Some(c) => c,
None => {
exit(0);
},
}
};
match command {