C4TG1RL5_UN1T3D/zardzewialy-dekoder-cif
4
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Added u8 nummap

Browse source
This commit is contained in:
famfo 2022-01-24 21:35:44 +01:00
parent aafd5f14ac
commit 43f76b9434
2 changed files with 340 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

122
src/main.rs
View file

@ -1,8 +1,8 @@
use std::{env, io, process};
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Lines};
use arrayvec::{ArrayString, ArrayVec};
use png::{BitDepth, ColorType, EncodingError};
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Lines};
use std::{env, io, process};
use thiserror::Error;
mod nummap;
@ -32,7 +32,7 @@ enum CifError {
#[error("CIF image doesn't contain any pixels")]
NoDataError,
#[error("PNG error: {0}")]
PngError(EncodingError)
PngError(EncodingError),
}
#[allow(clippy::enum_glob_use)]
@ -75,7 +75,7 @@ fn join_to_arraystring<const C: usize>(elems: &[&str], str: &mut ArrayString<C>)
fn lines_read_noempty<T: BufRead>(lines: &mut Lines<T>) -> Result<Option<String>> {
while let Some(s) = lines.next().transpose()? {
if !s.is_empty() {
return Ok(Some(s))
return Ok(Some(s));
}
}
Ok(None)
@ -84,7 +84,8 @@ fn lines_read_noempty<T: BufRead>(lines: &mut Lines<T>) -> Result<Option<String>
fn unfuck_cif_number(number: &str) -> Result<u32> {
let mut buf = ArrayString::<2048>::new();
// the split later will discard leading/trailing whitespace information, so we first check if it's there
if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len()-1] == 32 {
if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len() - 1] == 32
{
return Err(GrammarError(number.to_string()));
}
let split = number.split_ascii_whitespace().collect::<ArrayVec<_, 64>>();
@ -104,39 +105,48 @@ fn unfuck_cif_number(number: &str) -> Result<u32> {
"tysięcy" | "tysiące" => {
if i > 0 {
join_to_arraystring(&split[..i], &mut buf)?;
nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?
nummap::U16_NUMMAP
.get(&buf)
.ok_or_else(|| GrammarError(number.to_string()))?
} else {
return Err(GrammarError(number.to_string()));
}
}
_ => return Err(GrammarError(number.to_string()))
_ => return Err(GrammarError(number.to_string())),
};
let remainder = if i + 1 < splitlen {
buf.clear();
join_to_arraystring(&split[i + 1..], &mut buf)?;
nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?
nummap::U16_NUMMAP
.get(&buf)
.ok_or_else(|| GrammarError(number.to_string()))?
} else {
&0_u16
};
return Ok(u32::from(*thousands) * 1000 + u32::from(*remainder));
}
Ok(u32::from(*nummap::NUMMAP.get(number).ok_or_else(|| GrammarError(number.to_string()))?))
Ok(u32::from(
*nummap::U16_NUMMAP
.get(number)
.ok_or_else(|| GrammarError(number.to_string()))?,
))
}
fn unfuck_cif_number_fast(number: &str) -> Result<u8> {
if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len()-1] == 32 {
if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len() - 1] == 32
{
return Err(GrammarError(number.to_string()));
}
let mut buf = ArrayString::<2048>::new();
let split = number.split_ascii_whitespace().take(8).collect::<ArrayVec<_, 8>>();
let split = number
.split_ascii_whitespace()
.take(8)
.collect::<ArrayVec<_, 8>>();
join_to_arraystring(&split, &mut buf)?;
let number = *(nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?);
if number < 256 {
#[allow(clippy::cast_possible_truncation)]
Ok(number as u8)
} else {
Err(OutOfRangeError(number.to_string(), number))
}
let number = *(nummap::U8_NUMMAP
.get(&buf)
.ok_or_else(|| GrammarError(number.to_string()))?);
Ok(number)
}
fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
@ -145,41 +155,65 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
let mut lines = BufReader::new(infile).lines();
let rawriter = BufWriter::new(outfile);
if !lines.next().transpose()?.ok_or(InvalidHeaderError)?.starts_with("CIF:") {
return Err(InvalidHeaderError)
if !lines
.next()
.transpose()?
.ok_or(InvalidHeaderError)?
.starts_with("CIF:")
{
return Err(InvalidHeaderError);
}
let version_str = lines_read_noempty(&mut lines)?.ok_or(InvalidHeaderError)?;
let version_split = version_str.split_ascii_whitespace().take(2).collect::<ArrayVec<_, 2>>();
let version_split = version_str
.split_ascii_whitespace()
.take(2)
.collect::<ArrayVec<_, 2>>();
if version_split.len() != 2 || version_split[0] != "WERSJA" || version_split[1] != "jeden" {
return Err(InvalidHeaderError)
return Err(InvalidHeaderError);
}
let size_string = lines_read_noempty(&mut lines)?.ok_or(InvalidHeaderError)?;
if size_string.len() < 8 || !size_string.starts_with("ROZMIAR") {
return Err(InvalidSizeError(size_string))
return Err(InvalidSizeError(size_string));
}
let size_split = (&size_string[7..]).split(',').take(3).collect::<ArrayVec<_, 3>>();
let size_split = (&size_string[7..])
.split(',')
.take(3)
.collect::<ArrayVec<_, 3>>();
if size_split.len() != 3 {
return Err(InvalidSizeError(size_string.to_string()))
return Err(InvalidSizeError(size_string.to_string()));
}
let width = unfuck_cif_number(size_split[0].trim_start().strip_prefix("szerokość:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start())?;
let height = unfuck_cif_number(size_split[1].trim_start().strip_prefix("wysokość:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start())?;
let width = unfuck_cif_number(
size_split[0]
.trim_start()
.strip_prefix("szerokość:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?
.trim_start(),
)?;
let height = unfuck_cif_number(
size_split[1]
.trim_start()
.strip_prefix("wysokość:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?
.trim_start(),
)?;
let format = match unfuck_cif_number_fast(
size_split[2].trim_start().strip_prefix("bitów_na_piksel:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start()
size_split[2]
.trim_start()
.strip_prefix("bitów_na_piksel:")
.ok_or_else(|| InvalidSizeError(size_string.to_string()))?
.trim_start(),
)? {
24 => ColorType::Rgb,
32 => ColorType::Rgba,
_ => return Err(InvalidSizeError(size_string.to_string()))
_ => return Err(InvalidSizeError(size_string.to_string())),
};
if width == 0 || height == 0 {
return Err(NoDataError)
return Err(NoDataError);
}
let mut outpng = png::Encoder::new(rawriter, width, height);
@ -194,26 +228,26 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
let split = line.split_ascii_whitespace().collect::<ArrayVec<_, 256>>();
join_to_arraystring(&split, &mut buf)?;
let md_split = buf.splitn(3, ' ').collect::<ArrayVec<_, 3>>();
if md_split.len() != 3 {
return Err(InvalidMetadataError(line.to_string()))
if md_split.len() != 3 {
return Err(InvalidMetadataError(line.to_string()));
}
outpng.add_itxt_chunk(md_split[1].to_string(), md_split[2].to_string())?;
continue
continue;
}
break line
break line;
}
return Err(NoDataError)
return Err(NoDataError);
};
let mut outpng = outpng.write_header()?;
let bytes_per_pixel = if format == ColorType::Rgb {3} else {4};
let bytes_per_pixel = if format == ColorType::Rgb { 3 } else { 4 };
let mut pixmap = Vec::with_capacity((bytes_per_pixel * width * height) as usize);
if !first.is_empty() {
let px_split = first.split(';').collect::<ArrayVec<_, 4>>();
if px_split.len() != bytes_per_pixel as usize {
return Err(InvalidPixelError(first.to_string()))
return Err(InvalidPixelError(first.to_string()));
}
for px in px_split {
pixmap.push(unfuck_cif_number_fast(px.trim_start())?);
@ -223,7 +257,7 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
while let Some(line) = lines_read_noempty(&mut lines)? {
let px_split = line.split(';').collect::<ArrayVec<_, 4>>();
if px_split.len() != bytes_per_pixel as usize {
return Err(InvalidPixelError(line.to_string()))
return Err(InvalidPixelError(line.to_string()));
}
for px in px_split {
pixmap.push(unfuck_cif_number_fast(px.trim())?);
@ -238,7 +272,9 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
fn main() {
let argv = env::args().skip(1).take(2).collect::<ArrayVec<_, 2>>();
if argv.len() != 2 {
eprintln!("Invalid usage;\nUsage: zardzewialy-dekoder-cif <input cif file> <output bmp file>");
eprintln!(
"Invalid usage;\nUsage: zardzewialy-dekoder-cif <input cif file> <output bmp file>"
);
process::exit(1);
}
if let Err(e) = decoder(&argv[0], &argv[1]) {

262
src/nummap.rs
View file

@ -1,6 +1,6 @@
use phf::{phf_map, Map};
pub static NUMMAP: Map<&'static str, u16> = phf_map! {
pub static U16_NUMMAP: Map<&'static str, u16> = phf_map! {
"zero" => 0,
"jeden" => 1,
"dwa" => 2,
@ -1002,3 +1002,263 @@ pub static NUMMAP: Map<&'static str, u16> = phf_map! {
"dziewięćset dziewięćdziesiąt osiem" => 998,
"dziewięćset dziewięćdziesiąt dziewięć" => 999,
};
pub static U8_NUMMAP: Map<&'static str, u8> = phf_map! {
"zero" => 0,
"jeden" => 1,
"dwa" => 2,
"trzy" => 3,
"cztery" => 4,
"pięć" => 5,
"sześć" => 6,
"siedem" => 7,
"osiem" => 8,
"dziewięć" => 9,
"dziesięć" => 10,
"jedenaście" => 11,
"dwanaście" => 12,
"trzynaście" => 13,
"czternaście" => 14,
"piętnaście" => 15,
"szesnaście" => 16,
"siedemnaście" => 17,
"osiemnaście" => 18,
"dziewiętnaście" => 19,
"dwadzieścia" => 20,
"dwadzieścia jeden" => 21,
"dwadzieścia dwa" => 22,
"dwadzieścia trzy" => 23,
"dwadzieścia cztery" => 24,
"dwadzieścia pięć" => 25,
"dwadzieścia sześć" => 26,
"dwadzieścia siedem" => 27,
"dwadzieścia osiem" => 28,
"dwadzieścia dziewięć" => 29,
"trzydzieści" => 30,
"trzydzieści jeden" => 31,
"trzydzieści dwa" => 32,
"trzydzieści trzy" => 33,
"trzydzieści cztery" => 34,
"trzydzieści pięć" => 35,
"trzydzieści sześć" => 36,
"trzydzieści siedem" => 37,
"trzydzieści osiem" => 38,
"trzydzieści dziewięć" => 39,
"czterdzieści" => 40,
"czterdzieści jeden" => 41,
"czterdzieści dwa" => 42,
"czterdzieści trzy" => 43,
"czterdzieści cztery" => 44,
"czterdzieści pięć" => 45,
"czterdzieści sześć" => 46,
"czterdzieści siedem" => 47,
"czterdzieści osiem" => 48,
"czterdzieści dziewięć" => 49,
"pięćdziesiąt" => 50,
"pięćdziesiąt jeden" => 51,
"pięćdziesiąt dwa" => 52,
"pięćdziesiąt trzy" => 53,
"pięćdziesiąt cztery" => 54,
"pięćdziesiąt pięć" => 55,
"pięćdziesiąt sześć" => 56,
"pięćdziesiąt siedem" => 57,
"pięćdziesiąt osiem" => 58,
"pięćdziesiąt dziewięć" => 59,
"sześćdziesiąt" => 60,
"sześćdziesiąt jeden" => 61,
"sześćdziesiąt dwa" => 62,
"sześćdziesiąt trzy" => 63,
"sześćdziesiąt cztery" => 64,
"sześćdziesiąt pięć" => 65,
"sześćdziesiąt sześć" => 66,
"sześćdziesiąt siedem" => 67,
"sześćdziesiąt osiem" => 68,
"sześćdziesiąt dziewięć" => 69,
"siedemdziesiąt" => 70,
"siedemdziesiąt jeden" => 71,
"siedemdziesiąt dwa" => 72,
"siedemdziesiąt trzy" => 73,
"siedemdziesiąt cztery" => 74,
"siedemdziesiąt pięć" => 75,
"siedemdziesiąt sześć" => 76,
"siedemdziesiąt siedem" => 77,
"siedemdziesiąt osiem" => 78,
"siedemdziesiąt dziewięć" => 79,
"osiemdziesiąt" => 80,
"osiemdziesiąt jeden" => 81,
"osiemdziesiąt dwa" => 82,
"osiemdziesiąt trzy" => 83,
"osiemdziesiąt cztery" => 84,
"osiemdziesiąt pięć" => 85,
"osiemdziesiąt sześć" => 86,
"osiemdziesiąt siedem" => 87,
"osiemdziesiąt osiem" => 88,
"osiemdziesiąt dziewięć" => 89,
"dziewięćdziesiąt" => 90,
"dziewięćdziesiąt jeden" => 91,
"dziewięćdziesiąt dwa" => 92,
"dziewięćdziesiąt trzy" => 93,
"dziewięćdziesiąt cztery" => 94,
"dziewięćdziesiąt pięć" => 95,
"dziewięćdziesiąt sześć" => 96,
"dziewięćdziesiąt siedem" => 97,
"dziewięćdziesiąt osiem" => 98,
"dziewięćdziesiąt dziewięć" => 99,
"sto" => 100,
"sto jeden" => 101,
"sto dwa" => 102,
"sto trzy" => 103,
"sto cztery" => 104,
"sto pięć" => 105,
"sto sześć" => 106,
"sto siedem" => 107,
"sto osiem" => 108,
"sto dziewięć" => 109,
"sto dziesięć" => 110,
"sto jedenaście" => 111,
"sto dwanaście" => 112,
"sto trzynaście" => 113,
"sto czternaście" => 114,
"sto piętnaście" => 115,
"sto szesnaście" => 116,
"sto siedemnaście" => 117,
"sto osiemnaście" => 118,
"sto dziewiętnaście" => 119,
"sto dwadzieścia" => 120,
"sto dwadzieścia jeden" => 121,
"sto dwadzieścia dwa" => 122,
"sto dwadzieścia trzy" => 123,
"sto dwadzieścia cztery" => 124,
"sto dwadzieścia pięć" => 125,
"sto dwadzieścia sześć" => 126,
"sto dwadzieścia siedem" => 127,
"sto dwadzieścia osiem" => 128,
"sto dwadzieścia dziewięć" => 129,
"sto trzydzieści" => 130,
"sto trzydzieści jeden" => 131,
"sto trzydzieści dwa" => 132,
"sto trzydzieści trzy" => 133,
"sto trzydzieści cztery" => 134,
"sto trzydzieści pięć" => 135,
"sto trzydzieści sześć" => 136,
"sto trzydzieści siedem" => 137,
"sto trzydzieści osiem" => 138,
"sto trzydzieści dziewięć" => 139,
"sto czterdzieści" => 140,
"sto czterdzieści jeden" => 141,
"sto czterdzieści dwa" => 142,
"sto czterdzieści trzy" => 143,
"sto czterdzieści cztery" => 144,
"sto czterdzieści pięć" => 145,
"sto czterdzieści sześć" => 146,
"sto czterdzieści siedem" => 147,
"sto czterdzieści osiem" => 148,
"sto czterdzieści dziewięć" => 149,
"sto pięćdziesiąt" => 150,
"sto pięćdziesiąt jeden" => 151,
"sto pięćdziesiąt dwa" => 152,
"sto pięćdziesiąt trzy" => 153,
"sto pięćdziesiąt cztery" => 154,
"sto pięćdziesiąt pięć" => 155,
"sto pięćdziesiąt sześć" => 156,
"sto pięćdziesiąt siedem" => 157,
"sto pięćdziesiąt osiem" => 158,
"sto pięćdziesiąt dziewięć" => 159,
"sto sześćdziesiąt" => 160,
"sto sześćdziesiąt jeden" => 161,
"sto sześćdziesiąt dwa" => 162,
"sto sześćdziesiąt trzy" => 163,
"sto sześćdziesiąt cztery" => 164,
"sto sześćdziesiąt pięć" => 165,
"sto sześćdziesiąt sześć" => 166,
"sto sześćdziesiąt siedem" => 167,
"sto sześćdziesiąt osiem" => 168,
"sto sześćdziesiąt dziewięć" => 169,
"sto siedemdziesiąt" => 170,
"sto siedemdziesiąt jeden" => 171,
"sto siedemdziesiąt dwa" => 172,
"sto siedemdziesiąt trzy" => 173,
"sto siedemdziesiąt cztery" => 174,
"sto siedemdziesiąt pięć" => 175,
"sto siedemdziesiąt sześć" => 176,
"sto siedemdziesiąt siedem" => 177,
"sto siedemdziesiąt osiem" => 178,
"sto siedemdziesiąt dziewięć" => 179,
"sto osiemdziesiąt" => 180,
"sto osiemdziesiąt jeden" => 181,
"sto osiemdziesiąt dwa" => 182,
"sto osiemdziesiąt trzy" => 183,
"sto osiemdziesiąt cztery" => 184,
"sto osiemdziesiąt pięć" => 185,
"sto osiemdziesiąt sześć" => 186,
"sto osiemdziesiąt siedem" => 187,
"sto osiemdziesiąt osiem" => 188,
"sto osiemdziesiąt dziewięć" => 189,
"sto dziewięćdziesiąt" => 190,
"sto dziewięćdziesiąt jeden" => 191,
"sto dziewięćdziesiąt dwa" => 192,
"sto dziewięćdziesiąt trzy" => 193,
"sto dziewięćdziesiąt cztery" => 194,
"sto dziewięćdziesiąt pięć" => 195,
"sto dziewięćdziesiąt sześć" => 196,
"sto dziewięćdziesiąt siedem" => 197,
"sto dziewięćdziesiąt osiem" => 198,
"sto dziewięćdziesiąt dziewięć" => 199,
"dwieście" => 200,
"dwieście jeden" => 201,
"dwieście dwa" => 202,
"dwieście trzy" => 203,
"dwieście cztery" => 204,
"dwieście pięć" => 205,
"dwieście sześć" => 206,
"dwieście siedem" => 207,
"dwieście osiem" => 208,
"dwieście dziewięć" => 209,
"dwieście dziesięć" => 210,
"dwieście jedenaście" => 211,
"dwieście dwanaście" => 212,
"dwieście trzynaście" => 213,
"dwieście czternaście" => 214,
"dwieście piętnaście" => 215,
"dwieście szesnaście" => 216,
"dwieście siedemnaście" => 217,
"dwieście osiemnaście" => 218,
"dwieście dziewiętnaście" => 219,
"dwieście dwadzieścia" => 220,
"dwieście dwadzieścia jeden" => 221,
"dwieście dwadzieścia dwa" => 222,
"dwieście dwadzieścia trzy" => 223,
"dwieście dwadzieścia cztery" => 224,
"dwieście dwadzieścia pięć" => 225,
"dwieście dwadzieścia sześć" => 226,
"dwieście dwadzieścia siedem" => 227,
"dwieście dwadzieścia osiem" => 228,
"dwieście dwadzieścia dziewięć" => 229,
"dwieście trzydzieści" => 230,
"dwieście trzydzieści jeden" => 231,
"dwieście trzydzieści dwa" => 232,
"dwieście trzydzieści trzy" => 233,
"dwieście trzydzieści cztery" => 234,
"dwieście trzydzieści pięć" => 235,
"dwieście trzydzieści sześć" => 236,
"dwieście trzydzieści siedem" => 237,
"dwieście trzydzieści osiem" => 238,
"dwieście trzydzieści dziewięć" => 239,
"dwieście czterdzieści" => 240,
"dwieście czterdzieści jeden" => 241,
"dwieście czterdzieści dwa" => 242,
"dwieście czterdzieści trzy" => 243,
"dwieście czterdzieści cztery" => 244,
"dwieście czterdzieści pięć" => 245,
"dwieście czterdzieści sześć" => 246,
"dwieście czterdzieści siedem" => 247,
"dwieście czterdzieści osiem" => 248,
"dwieście czterdzieści dziewięć" => 249,
"dwieście pięćdziesiąt" => 250,
"dwieście pięćdziesiąt jeden" => 251,
"dwieście pięćdziesiąt dwa" => 252,
"dwieście pięćdziesiąt trzy" => 253,
"dwieście pięćdziesiąt cztery" => 254,
"dwieście pięćdziesiąt pięć" => 255,
};