Add unknown texture for textures not in assets (pack.png for example)

Author: misieur

packobf/src/file_parser.rs

@@ -18,6 +18,7 @@ use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::watch::Sender;
+use crate::resource_pack::files::unknowntexture::UnknownTexture;
 
 pub fn parse_resource_pack_files(
     logger: &UnboundedSender<LogMessage>,
@@ -210,9 +211,13 @@ fn parse_resource_pack_file(
         }
     } else if name.ends_with(".mcmeta") {
         json_file(logger, pack, name, content);
-    } else if name.ends_with(".png") && get_type(name) == Some("textures") {
-        let (overlay, identifier) = parse_path(name);
-        pack.texture(Texture::new(overlay, identifier, content.to_owned()));
+    } else if name.ends_with(".png") {
+        if get_type(name) == Some("textures") {
+            let (overlay, identifier) = parse_path(name);
+            pack.texture(Texture::new(overlay, identifier, content.to_owned()));
+        } else {
+            pack.unknown_texture(UnknownTexture::new(name.as_str(), content.to_owned()))
+        }
     } else if name.ends_with(".vsh") || name.ends_with(".fsh") || name.ends_with(".glsl") {
         pack.shader(Shader::new(
             name.to_owned(),

packobf/src/lib.rs

@@ -37,6 +37,7 @@ use std::sync::Arc;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::watch::Sender;
 use zip::ZipArchive;
+use crate::resource_pack::files::unknowntexture::UnknownTexture;
 
 pub fn process_zip(
     input_bytes: Vec<u8>,
@@ -186,7 +187,7 @@ fn add_item_to_archive(
     match item {
         ResourcePackItem::Texture(o) => {
             o.optimize(options, logger, cache);
-            writer.add_file(name.as_str(), o.bytes.as_slice(), options, cache)
+            writer.add_file(name.as_str(), o.unknown_texture.bytes.as_slice(), options, cache)
         }
         ResourcePackItem::Shader(o) => {
             o.optimize(options, logger);
@@ -223,6 +224,9 @@ fn add_item_to_archive(
         ResourcePackItem::Atlas(o) => {
             writer.add_file(name.as_str(), o.to_string().as_bytes(), options, cache)
         }
+        ResourcePackItem::UnknownTexture(o) => {
+            writer.add_file(name.as_str(), o.bytes.as_slice(), options, cache)
+        }
     }?;
     Ok(())
 }
@@ -235,6 +239,12 @@ fn collect_files(pack: Arc<ResourcePack>) -> Vec<(String, ResourcePackItem)> {
             ResourcePackItem::Texture(kv.value().clone()),
         )
     });
+    let unknown_texture_iter = pack.unknown_textures.par_iter().map(|kv| {
+        (
+            kv.key().clone(),
+            ResourcePackItem::UnknownTexture(kv.value().clone()),
+        )
+    });
     let shader_iter = pack.shaders.par_iter().map(|kv| {
         (
             kv.key().clone(),
@@ -295,6 +305,7 @@ fn collect_files(pack: Arc<ResourcePack>) -> Vec<(String, ResourcePackItem)> {
     });
 
     texture_iter
+        .chain(unknown_texture_iter)
         .chain(shader_iter)
         .chain(model_iter)
         .chain(json_iter)
@@ -329,6 +340,7 @@ pub enum Progress {
 #[derive(Clone, Debug)]
 enum ResourcePackItem {
     Texture(Texture),
+    UnknownTexture(UnknownTexture),
     Shader(Shader),
     Json(Json),
     Model(Model),

packobf/src/resource_pack/files/mod.rs

@@ -9,3 +9,4 @@ pub mod font;
 pub mod sound;
 pub mod sound_definitions;
 pub mod atlas;
+pub mod unknowntexture;

packobf/src/resource_pack/files/texture.rs

@@ -1,20 +1,15 @@
-use crate::cache::{Cache, ItemType};
-use crate::options::{Compression, Options};
-use crate::png::{crc, recoverer};
+use crate::cache::Cache;
+use crate::options::Options;
+use crate::resource_pack::files::unknowntexture::UnknownTexture;
 use crate::resource_pack::identifier::Identifier;
-use crate::LogLevel::{Info, Warning};
-use crate::{options, profile_scope, LogMessage};
-use once_cell::sync::Lazy;
-use oxipng::{indexset, optimize_from_memory, Deflater, FilterStrategy, StripChunks};
-use sha2::{Digest, Sha256};
-use std::time::Duration;
+use crate::LogMessage;
 
 // textures are referenced in `models`, `items` and `font`
 #[derive(Clone, Debug)]
 pub struct Texture {
     pub overlay: String,
     pub identifier: Identifier,
-    pub bytes: Vec<u8>,
+    pub unknown_texture: UnknownTexture
 }
 
 impl Texture {
@@ -23,10 +18,22 @@ impl Texture {
         identifier: impl Into<Identifier>,
         bytes: Vec<u8>,
     ) -> Self {
+        let overlay = overlay.into();
+        let prefix = if overlay.is_empty() {
+            "".to_string()
+        } else {
+            format!("{}/", overlay)
+        };
+        let identifier = identifier.into();
+        let path = format!(
+            "{}assets/{}/textures/{}.png",
+            prefix, identifier.namespace, identifier.path
+        );
+        let unknown_texture = UnknownTexture::new(path, bytes);
         Self {
             overlay: overlay.into(),
             identifier: identifier.into(),
-            bytes,
+            unknown_texture,
         }
     }
 
@@ -36,232 +43,11 @@ impl Texture {
         logger: &tokio::sync::mpsc::UnboundedSender<LogMessage>,
         cache: &Option<Cache>,
     ) {
-        self.bytes = Self::cache_or_optimize(&self.bytes, options, logger, cache, &self.path());
-        if options.corrupt_png_files {
-            match crc::modify_png_crcs(&self.bytes) {
-                Ok(bytes) => {
-                    self.bytes = bytes;
-                }
-                Err(e) => {
-                    let _ = logger.send(LogMessage {
-                        level: Warning,
-                        message: format!("Could not corrupt image '{}'. Error: {}", self.path(), e),
-                    });
-                }
-            }
-        }
-    }
-
-    fn cache_or_optimize(
-        bytes: &[u8],
-        options: &Options,
-        logger: &tokio::sync::mpsc::UnboundedSender<LogMessage>,
-        cache: &Option<Cache>,
-        path: &str,
-    ) -> Vec<u8> {
-        profile_scope!("cache_or_optimize::texture");
-        if let Some(cache) = cache {
-            let mut sha256 = Sha256::new();
-            sha256.update(bytes);
-            let hash: [u8; 32] = sha256.finalize().into();
-
-            if let Some(bytes) = cache
-                .with_item(&hash, ItemType::Image, |it| {
-                    (it.compression as u8 >= options.compression.clone() as u8)
-                        .then(|| it.data.clone())
-                })
-                .flatten()
-            {
-                let _ = logger.send(LogMessage {
-                    level: Info,
-                    message: format!("Image '{}' was loaded from cache.", path),
-                });
-                return bytes;
-            }
-        }
-        let oxipng_options = match options.compression {
-            Compression::Simplest => &DEFAULT_OPTIONS,
-            Compression::Normal => &NORMAL_OPTIONS,
-            Compression::Max => &MAX_OPTIONS,
-        };
-        match optimize_from_memory(bytes, oxipng_options) {
-            Ok(value) => {
-                if let Some(cache) = cache {
-                    cache.add_item(
-                        bytes,
-                        &*value,
-                        options.compression.clone() as u8,
-                        ItemType::Image,
-                    )
-                }
-                value
-            }
-            Err(e) => {
-                let _ = logger.send(LogMessage {
-                    level: Info,
-                    message: format!(
-                        "Could not optimize image '{}'. Trying to recover it. Error: {}",
-                        path, e
-                    ),
-                });
-                match recoverer::recover_png(bytes) {
-                    Ok(value) => {
-                        let _ = logger.send(LogMessage {
-                            level: Info,
-                            message: format!("Image '{}' was recovered successfully.", path),
-                        });
-                        match optimize_from_memory(value.as_slice(), oxipng_options) {
-                            Ok(value) => {
-                                if let Some(cache) = cache {
-                                    cache.add_item(
-                                        bytes,
-                                        &*value,
-                                        options.compression.clone() as u8,
-                                        ItemType::Image,
-                                    )
-                                }
-                                value
-                            }
-                            Err(e) => {
-                                let _ = logger.send(LogMessage {
-                                    level: Warning,
-                                    message: format!(
-                                        "Could not optimize image '{}'. Skipping optimization. Error: {}",
-                                        path,
-                                        e),
-                                });
-                                value
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        let _ = logger.send(LogMessage {
-                            level: Warning,
-                            message: format!(
-                                "Could not recover image '{}'. Skipping optimization. Error: {}",
-                                path, e
-                            ),
-                        });
-                        bytes.to_owned()
-                    }
-                }
-            }
-        }
+        self.unknown_texture.optimize(options, logger, cache);
     }
 
     pub fn path(&self) -> String {
-        let prefix = if self.overlay.is_empty() {
-            "".to_string()
-        } else {
-            format!("{}/", self.overlay)
-        };
-        format!(
-            "{}assets/{}/textures/{}.png",
-            prefix, self.identifier.namespace, self.identifier.path
-        )
+        self.unknown_texture.path.clone()
     }
 }
 
-/**
-Currently, only the `deflater` option changes, but some other options could be modified based on the compression wanted.
-*/
-//<editor-fold desc="Oxipng options" defaultstate="collapsed">
-static DEFAULT_OPTIONS: Lazy<oxipng::Options> = Lazy::new(|| oxipng::Options {
-    fix_errors: true,
-    force: false,
-    filters: indexset! {
-        FilterStrategy::NONE,
-        FilterStrategy::SUB,
-        FilterStrategy::UP,
-        FilterStrategy::AVERAGE,
-        FilterStrategy::PAETH,
-        FilterStrategy::MinSum,
-        FilterStrategy::Entropy,
-        FilterStrategy::Bigrams,
-        FilterStrategy::BigEnt,
-        FilterStrategy::Brute {
-            num_lines: 8,
-            level: 12,
-        },
-    },
-    interlace: Some(false),
-    optimize_alpha: true,
-    bit_depth_reduction: true,
-    color_type_reduction: true,
-    palette_reduction: true,
-    grayscale_reduction: true,
-    idat_recoding: true,
-    scale_16: false,
-    strip: StripChunks::All,
-    deflater: Deflater::Libdeflater { compression: 6 }, // 6: default compression level
-    fast_evaluation: false,
-    timeout: Some(Duration::from_secs(3)),
-    max_decompressed_size: None,
-});
-
-static NORMAL_OPTIONS: Lazy<oxipng::Options> = Lazy::new(|| oxipng::Options {
-    fix_errors: true,
-    force: false,
-    filters: indexset! {
-        FilterStrategy::NONE,
-        FilterStrategy::SUB,
-        FilterStrategy::UP,
-        FilterStrategy::AVERAGE,
-        FilterStrategy::PAETH,
-        FilterStrategy::MinSum,
-        FilterStrategy::Entropy,
-        FilterStrategy::Bigrams,
-        FilterStrategy::BigEnt,
-        FilterStrategy::Brute {
-            num_lines: 8,
-            level: 12,
-        },
-    },
-    interlace: Some(false),
-    optimize_alpha: true,
-    bit_depth_reduction: true,
-    color_type_reduction: true,
-    palette_reduction: true,
-    grayscale_reduction: true,
-    idat_recoding: true,
-    scale_16: false,
-    strip: StripChunks::All,
-    deflater: Deflater::Libdeflater { compression: 12 }, // 12: max compression level for libdeflater
-    fast_evaluation: false,
-    timeout: Some(Duration::from_secs(3)),
-    max_decompressed_size: None,
-});
-
-static MAX_OPTIONS: Lazy<oxipng::Options> = Lazy::new(|| oxipng::Options {
-    fix_errors: true,
-    force: false,
-    filters: indexset! {
-        FilterStrategy::NONE,
-        FilterStrategy::SUB,
-        FilterStrategy::UP,
-        FilterStrategy::AVERAGE,
-        FilterStrategy::PAETH,
-        FilterStrategy::MinSum,
-        FilterStrategy::Entropy,
-        FilterStrategy::Bigrams,
-        FilterStrategy::BigEnt,
-        FilterStrategy::Brute {
-            num_lines: 8,
-            level: 12,
-        },
-    },
-    interlace: Some(false),
-    optimize_alpha: true,
-    bit_depth_reduction: true,
-    color_type_reduction: true,
-    palette_reduction: true,
-    grayscale_reduction: true,
-    idat_recoding: true,
-    scale_16: false,
-    strip: StripChunks::All,
-    deflater: Deflater::Zopfli(options::ZOPFLI_OPTIONS.to_owned()), // zopfli: best compression
-    fast_evaluation: false,
-    timeout: Some(Duration::from_secs(3)),
-    max_decompressed_size: None,
-});
-//</editor-fold>