fix

src/library/album.rs

@@ -48,7 +48,7 @@ impl Album {
             .clone();
         let track_path = std::path::Path::new(&track_path);
 
-        for ext in ["png", "jpg", "jpeg", "avif"] {
+        for ext in ["png", "jpg", "jpeg", "avif", "webp"] {
             let cover_file = track_path.parent()?.join(format!("cover.{ext}"));
 
             if cover_file.exists() {

src/library/mod.rs

@@ -134,7 +134,7 @@ impl Libary {
     }
 
     pub async fn get_artists(&self) -> Vec<Artist> {
-        Artist::find(doc! {}, None).await.unwrap()
+        Artist::find_all().await.unwrap()
     }
 
     pub async fn get_albums_by_artist(&self, artist: &str) -> Vec<Album> {
@@ -240,7 +240,10 @@ impl Libary {
 
     pub async fn clean_lost_files(&self) {
         // tracks
-        for track in Track::find_partial(doc! {}, json!({"path": 1}), None).await.unwrap() {
+        for track in Track::find_partial(doc! {}, json!({"path": 1}), None)
+            .await
+            .unwrap()
+        {
             if !std::path::Path::new(&track.path.as_ref().unwrap()).exists() {
                 log::info!("Cleaning lost {}", track.path.as_ref().unwrap());
                 Track::remove(&track._id).await.unwrap();

src/library/track.rs

@@ -44,21 +44,31 @@ impl Track {
 
     /// Transcode audio to OPUS with `bitrate`
     pub fn get_opus(&self, bitrate: u32) -> Option<String> {
-        let transcoded = format!("./data/transcode/opus/{}/{}.opus", bitrate, self._id);
+        self.transcode("libopus", bitrate, "opus")
+    }
+
+    /// Transcode audio to AAC with `bitrate`
+    pub fn get_aac(&self, bitrate: u32) -> Option<String> {
+        self.transcode("aac", bitrate, "m4a")
+    }
+
+    /// Transcode audio
+    pub fn transcode(&self, codec: &str, bitrate: u32, ext: &str) -> Option<String> {
+        let transcoded = format!("./data/transcode/{codec}/{bitrate}/{}.{ext}", self._id);
 
         if std::path::Path::new(&transcoded).exists() {
             return Some(transcoded);
         }
 
-        log::info!("Transcoding {} to OPUS {}", self._id, bitrate);
+        log::info!("Transcoding {} to {} {}", self._id, codec, bitrate);
 
-        std::fs::create_dir_all(format!("./data/transcode/opus/{bitrate}")).unwrap();
+        std::fs::create_dir_all(format!("./data/transcode/{codec}/{bitrate}")).unwrap();
 
         let out = std::process::Command::new("ffmpeg")
             .arg("-i")
             .arg(&self.path)
             .arg("-c:a")
-            .arg("libopus")
+            .arg(codec)
             .arg("-b:a")
             .arg(format!("{bitrate}k"))
             .arg(&transcoded)

src/main.rs

@@ -61,6 +61,7 @@ async fn rocket() -> _ {
                 route::user::user_create_route,
                 route::user::users_route,
                 route::track::track_audio_opus128_route,
+                route::track::track_audio_aac128_route,
                 route::playlist::playlists_route,
                 route::playlist::playlist_route,
                 route::playlist::playlist_add_route,

src/route/album.rs

@@ -62,7 +62,7 @@ pub async fn album_cover_route(
 pub async fn latest_albums_route(cache: &State<RouteCache>) -> FallibleApiResponse {
     use_api_cache!("albums", "latest", cache);
 
-    let albums = Album::find(doc! {}, None).await.unwrap();
+    let albums = Album::find_all().await.unwrap();
 
     let mut albums_tracks = vec![];
 

src/route/track.rs

@@ -46,3 +46,9 @@ pub async fn track_audio_opus128_route(track_id: &str, lib: &State<Libary>) -> O
     let track = lib.get_track_by_id(track_id).await?;
     NamedFile::open(track.get_opus(128)?).await.ok()
 }
+
+#[get("/track/<track_id>/audio/aac128")]
+pub async fn track_audio_aac128_route(track_id: &str, lib: &State<Libary>) -> Option<NamedFile> {
+    let track = lib.get_track_by_id(track_id).await?;
+    NamedFile::open(track.get_aac(128)?).await.ok()
+}

src/route/user.rs

@@ -83,7 +83,7 @@ pub async fn passwd_route(passwd: Json<PasswdData>, mut u: User) -> FallibleApiR
 pub async fn users_route(u: User) -> FallibleApiResponse {
     check_admin!(u);
 
-    let users: Vec<_> = to_api(&User::find(doc! {}, None).await.unwrap()).await;
+    let users: Vec<_> = to_api(&User::find_all().await.unwrap()).await;
 
     Ok(json!({"users": users}))
 }