updated to 2021 toolchain + metadata is know saved

src/file_sink.rs

@@ -1,22 +1,34 @@
-use librespot::playback::audio_backend::{Open, Sink};
-use std::io::{self};
+use std::path::Path;
 
-extern crate flac_bound;
+use audiotags::{Tag, TagType};
+use librespot::{playback::{audio_backend::{Open, Sink, SinkError}, config::AudioFormat, decoder::AudioPacket, convert::Converter}};
+
+// extern crate flac_bound;
 
 use flac_bound::{FlacEncoder};
 
+use crate::TrackMetadata;
+
 pub struct FileSink {
     sink: String,
-    content: Vec<i32>
+    content: Vec<i32>,
+    metadata: Option<TrackMetadata>
+}
+
+impl FileSink {
+    pub fn add_metadata(&mut self, meta: TrackMetadata) {
+        self.metadata = Some(meta);
+    }
 }
 
 impl Open for FileSink {
-    fn open(path: Option<String>) -> Self {
+    fn open(path: Option<String>, _audio_format: AudioFormat) -> Self {
         if let Some(path) = path {
             let file = path;
             FileSink {
                 sink: file,
-                content: Vec::new()
+                content: Vec::new(),
+                metadata: None
             }
         } else {
             panic!();
@@ -25,20 +37,35 @@ impl Open for FileSink {
 }
 
 impl Sink for FileSink {
-    fn start(&mut self) -> io::Result<()> {
+    fn start(&mut self) -> Result<(), SinkError> {
         Ok(())
     }
 
-    fn stop(&mut self) -> io::Result<()> {
-        let mut encoder = FlacEncoder::new().unwrap().channels(2).bits_per_sample(16).compression_level(0).init_file(&self.sink).unwrap();
+    fn stop(&mut self) -> Result<(), SinkError> {
+        let mut encoder = FlacEncoder::new().unwrap().channels(2).bits_per_sample(16).compression_level(4).init_file(&self.sink).unwrap();
         encoder.process_interleaved(self.content.as_slice(), (self.content.len()/2) as u32).unwrap();
         encoder.finish().unwrap();
+
+        match &self.metadata {
+            Some(meta) => {
+                let mut tag = Tag::new().with_tag_type(TagType::Flac).read_from_path(Path::new(&self.sink)).unwrap();
+
+                tag.set_album_title(&meta.album);
+                for artist in &meta.artists {
+                    tag.add_artist(artist);
+                }
+                tag.set_title(&meta.track_name);
+                tag.write_to_path(&self.sink).expect("Failed to write metadata");
+            },
+            None => (),
+        }
         Ok(())
     }
 
-    fn write(&mut self, data: &[i16]) -> io::Result<()> {
-        let mut input: Vec<i32> = data.iter().map(|el| i32::from(*el)).collect();
-        self.content.append(&mut input);
+    fn write(&mut self, packet: &AudioPacket, converter: &mut Converter) -> Result<(), SinkError> {
+        let data = converter.f64_to_s16(packet.samples().unwrap());
+        let mut data32: Vec<i32> = data.iter().map(|el| i32::from(*el)).collect();
+        self.content.append(&mut data32);
         Ok(())
     }
-}
+}