Generate thumbnails in rust

packages/main/src/controllers/local-library.ts

@@ -54,7 +54,7 @@ class LocalIpcCtrl {
         .map(folder => this.localLibraryDb.addFolder(this.normalizeFolderPath(folder)))
     );
 
-    const cache = await scanFolders(directories, ['mp3'], (scanProgress, scanTotal) => {
+    const cache = await scanFolders(directories, ['mp3'], this.localLibrary.getThumbnailsDir(), (scanProgress, scanTotal) => {
       this.window.send(IpcEvents.LOCAL_FILES_PROGRESS, {scanProgress, scanTotal});
     });
 
@@ -84,7 +84,7 @@ class LocalIpcCtrl {
     try {
       const folders = await this.localLibraryDb.getLocalFolders();
 
-      const cache = await scanFolders(folders.map(folder => folder.path), ['mp3'], (scanProgress, scanTotal) => {
+      const cache = await scanFolders(folders.map(folder => folder.path), ['mp3'], this.localLibrary.getThumbnailsDir(), (scanProgress, scanTotal) => {
         this.window.send(IpcEvents.LOCAL_FILES_PROGRESS, {scanProgress, scanTotal});
       });
 

packages/main/src/services/local-library/index.ts

@@ -53,6 +53,10 @@ class LocalLibrary {
     }
   }
 
+  getThumbnailsDir() {
+    return this.mediaDir;
+  }
+
   /**
    * Format metadata from files to nuclear format
    */

packages/scanner/Cargo.toml

@@ -10,8 +10,13 @@ crate-type = ["cdylib"]
 
 [dependencies]
 id3 = "1.7.0"
+md5 = "0.7.0"
 mockall = "0.11.4"
 
+[dependencies.image]
+version = "0.24.7"
+features = ["webp-encoder"]
+
 [dependencies.uuid]
 version = "1.3.4"
 features = [

packages/scanner/index.d.ts

@@ -4,7 +4,7 @@ export type LocalTrack = {
     title?: string;
     album?: string;
     duration?: number;
-    thumbnail?: Buffer;
+    thumbnail?: string;
     position?: number;
     year?: string;
 
@@ -16,6 +16,10 @@ export type LocalTrack = {
 declare const scanFolders = (
   folders: string[], 
   supportedFormats: string[], 
+  thumbnailsDir: string,
   onProgress: (progress: number, total: number, lastScanned?: string) => void
 ) => new Promise<LocalTrack[]>;
-export { scanFolders };
+
+declare const generateThumbnail = (filename: string, thumbnailsDir: string) => new Promise<string>;
+
+export { scanFolders, generateThumbnail };

packages/scanner/src/lib.rs

@@ -2,16 +2,20 @@ mod error;
 mod js;
 mod local_track;
 mod scanner;
+mod thumbnails;
 use id3::Tag;
-use js::{set_optional_field_buffer, set_optional_field_str, set_optional_field_u32};
+use js::{set_optional_field_str, set_optional_field_u32};
 use neon::prelude::*;
 use scanner::{visit_directory, visit_file};
 use std::collections::LinkedList;
+use thumbnails::create_thumbnails_dir;
 
 fn scan_folders(mut cx: FunctionContext) -> JsResult<JsArray> {
     let folders: Handle<JsArray> = cx.argument(0)?;
     let supported_formats: Handle<JsArray> = cx.argument(1)?;
-    let on_progress_callback: Handle<JsFunction> = cx.argument(2)?;
+    let thumbnails_dir: Handle<JsString> = cx.argument(2)?;
+    let thumbnails_dir_str = thumbnails_dir.value(&mut cx);
+    let on_progress_callback: Handle<JsFunction> = cx.argument(3)?;
     let result: Handle<JsArray> = cx.empty_array();
 
     // Copy all the starting folders to a queue, which holds all the folders left to scan
@@ -52,14 +56,21 @@ fn scan_folders(mut cx: FunctionContext) -> JsResult<JsArray> {
         on_progress_callback.call(&mut cx, this, args)?;
     }
 
+    // First, create a directory for thumbnails
+    create_thumbnails_dir(thumbnails_dir_str.as_str());
+
     // All folders have been scanned, now scan the files
     total_files_to_scan_num = files_to_scan_queue.len();
     while !files_to_scan_queue.is_empty() {
         // Get the next file to scan
         let file = files_to_scan_queue.pop_front().unwrap();
 
         // Scan the file
-        let track = visit_file(file.clone(), |path| Tag::read_from_path(path));
+        let track = visit_file(
+            file.clone(),
+            |path| Tag::read_from_path(path),
+            thumbnails_dir_str.as_str(),
+        );
 
         if track.is_err() {
             // Call the progress callback
@@ -89,7 +100,7 @@ fn scan_folders(mut cx: FunctionContext) -> JsResult<JsArray> {
         let track_duration_js_number = cx.number(track.duration);
         track_js_object.set(&mut cx, "duration", track_duration_js_number)?;
 
-        set_optional_field_buffer(&mut cx, &mut track_js_object, "thumbnail", track.thumbnail);
+        set_optional_field_str(&mut cx, &mut track_js_object, "thumbnail", track.thumbnail);
 
         set_optional_field_u32(&mut cx, &mut track_js_object, "position", track.position);
         set_optional_field_u32(&mut cx, &mut track_js_object, "disc", track.disc);

packages/scanner/src/local_track.rs

@@ -5,7 +5,7 @@ pub struct LocalTrack {
     pub title: Option<String>,
     pub album: Option<String>,
     pub duration: u32,
-    pub thumbnail: Option<Vec<u8>>,
+    pub thumbnail: Option<String>,
     pub disc: Option<u32>,
     pub position: Option<u32>,
     pub year: Option<u32>,

packages/scanner/src/scanner.rs

@@ -5,12 +5,17 @@ use uuid::Uuid;
 
 use crate::error::ScannerError;
 use crate::local_track::LocalTrack;
+use crate::thumbnails::generate_thumbnail;
 
 pub trait TagReader {
     fn read_from_path(path: impl AsRef<Path>) -> Result<Tag, Error>;
 }
 
-pub fn visit_file<F>(path: String, tag_reader: F) -> Result<LocalTrack, ScannerError>
+pub fn visit_file<F>(
+    path: String,
+    tag_reader: F,
+    thumbnails_dir: &str,
+) -> Result<LocalTrack, ScannerError>
 where
     F: FnOnce(&str) -> Result<Tag, id3::Error>,
 {
@@ -23,10 +28,7 @@ where
             title: tag.title().map(|s| s.to_string()),
             album: tag.album().map(|s| s.to_string()),
             duration: tag.duration().unwrap_or(0),
-            thumbnail: tag
-                .pictures()
-                .find(|p| p.picture_type == id3::frame::PictureType::CoverFront)
-                .map(|p| p.data.clone()),
+            thumbnail: generate_thumbnail(&path, thumbnails_dir),
             position: tag.track(),
             disc: tag.disc(),
             year: tag.year().map(|s| s as u32),
@@ -110,7 +112,10 @@ mod tests {
             assert_eq!(track.year, Some(2020));
             assert_eq!(track.filename, String::from("file.mp3"));
             assert_eq!(track.path, path);
-            assert_eq!(track.thumbnail, Some(vec![1, 2, 3]));
+            assert_eq!(
+                track.thumbnail,
+                Some("file://path/to/valid/file.webp".to_string())
+            );
         } else {
             panic!("Result is not ok");
         }

packages/scanner/src/thumbnails.rs

@@ -0,0 +1,59 @@
+use id3::Tag;
+use image::{imageops::resize, imageops::FilterType, io::Reader as ImageReader, ImageFormat};
+use md5;
+use std::io::Cursor;
+use std::path::{Path, PathBuf};
+
+fn hash_thumb_filename(path: &str) -> String {
+    let filename = Path::new(path).file_name().unwrap();
+    let hash = md5::compute(filename.to_string_lossy().as_bytes());
+    format!("{:x}.webp", hash)
+}
+
+pub fn create_thumbnails_dir(thumbnails_dir: &str) {
+    let thumbnails_dir_path = Path::new(thumbnails_dir);
+
+    if !thumbnails_dir_path.exists() {
+        std::fs::create_dir(thumbnails_dir_path).unwrap();
+    }
+}
+
+fn url_path_from_path(path: &str) -> String {
+    let path = path.replace("\\", "/");
+    let path = path.replace(" ", "%20");
+    format!("file://{}", path)
+}
+
+pub fn generate_thumbnail(filename: &str, thumbnails_dir: &str) -> Option<String> {
+    let mut thumbnail_path = PathBuf::from(thumbnails_dir);
+
+    thumbnail_path.push(hash_thumb_filename(filename));
+
+    let thumbnail_path_str = thumbnail_path.to_str().unwrap();
+
+    if Path::new(thumbnail_path_str).exists() {
+        return Some(url_path_from_path(thumbnail_path_str));
+    }
+
+    let tag = Tag::read_from_path(filename).unwrap();
+    let thumbnail = tag
+        .pictures()
+        .find(|p| p.picture_type == id3::frame::PictureType::CoverFront)
+        .map(|p| p.data.clone());
+
+    if let Some(thumbnail) = thumbnail {
+        let img = ImageReader::new(Cursor::new(&thumbnail))
+            .with_guessed_format()
+            .unwrap()
+            .decode()
+            .unwrap();
+
+        let img = resize(&img, 192, 192, FilterType::Lanczos3);
+        img.save_with_format(thumbnail_path_str, ImageFormat::WebP)
+            .unwrap();
+    } else {
+        return None;
+    }
+
+    Some(url_path_from_path(thumbnail_path_str))
+}