Fix leftovers from merging diverging branches

playback/src/convert.rs

@@ -36,6 +36,10 @@ impl Converter {
         // the reference Vorbis implementation uses: sample * 32768 (for 16 bit)
         let int_value = sample * factor as f32;
 
+        // https://doc.rust-lang.org/nomicon/casts.html: casting float to integer
+        // rounds towards zero, then saturates. Ideally halves should round to even to
+        // prevent any bias, but since it is extremely unlikely that a float has
+        // *exactly* .5 as fraction, this should be more than precise enough.
         match self.ditherer {
             Some(ref mut d) => int_value + d.noise(int_value),
             None => int_value,
@@ -62,10 +66,6 @@ impl Converter {
         int_value
     }
 
-    // https://doc.rust-lang.org/nomicon/casts.html: casting float to integer
-    // rounds towards zero, then saturates. Ideally halves should round to even to
-    // prevent any bias, but since it is extremely unlikely that a float has
-    // *exactly* .5 as fraction, this should be more than precise enough.
     pub fn f32_to_s32(&mut self, samples: &[f32]) -> Vec<i32> {
         samples
             .iter()

playback/src/decoder/libvorbis_decoder.rs

@@ -1,86 +0,0 @@
-#[cfg(feature = "with-tremor")]
-use librespot_tremor as vorbis;
-
-use super::{AudioDecoder, AudioError, AudioPacket};
-use std::error;
-use std::fmt;
-use std::io::{Read, Seek};
-
-pub struct VorbisDecoder<R: Read + Seek>(vorbis::Decoder<R>);
-pub struct VorbisError(vorbis::VorbisError);
-
-impl<R> VorbisDecoder<R>
-where
-    R: Read + Seek,
-{
-    pub fn new(input: R) -> Result<VorbisDecoder<R>, VorbisError> {
-        Ok(VorbisDecoder(vorbis::Decoder::new(input)?))
-    }
-}
-
-impl<R> AudioDecoder for VorbisDecoder<R>
-where
-    R: Read + Seek,
-{
-    #[cfg(not(feature = "with-tremor"))]
-    fn seek(&mut self, ms: i64) -> Result<(), AudioError> {
-        self.0.time_seek(ms as f64 / 1000f64)?;
-        Ok(())
-    }
-
-    #[cfg(feature = "with-tremor")]
-    fn seek(&mut self, ms: i64) -> Result<(), AudioError> {
-        self.0.time_seek(ms)?;
-        Ok(())
-    }
-
-    fn next_packet(&mut self) -> Result<Option<AudioPacket>, AudioError> {
-        loop {
-            match self.0.packets().next() {
-                Some(Ok(packet)) => {
-                    return Ok(Some(AudioPacket::Samples(
-                        packet
-                            .data
-                            .iter()
-                            .map(|sample| (*sample as f64 / 0x8000 as f64) as f32)
-                            .collect(),
-                    )));
-                }
-                None => return Ok(None),
-
-                Some(Err(vorbis::VorbisError::Hole)) => (),
-                Some(Err(err)) => return Err(err.into()),
-            }
-        }
-    }
-}
-
-impl From<vorbis::VorbisError> for VorbisError {
-    fn from(err: vorbis::VorbisError) -> VorbisError {
-        VorbisError(err)
-    }
-}
-
-impl fmt::Debug for VorbisError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.0, f)
-    }
-}
-
-impl fmt::Display for VorbisError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl error::Error for VorbisError {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        error::Error::source(&self.0)
-    }
-}
-
-impl From<vorbis::VorbisError> for AudioError {
-    fn from(err: vorbis::VorbisError) -> AudioError {
-        AudioError::VorbisError(VorbisError(err))
-    }
-}

playback/src/mixer/mappings.rs

@@ -17,7 +17,7 @@ impl MappedCtrl for VolumeCtrl {
         // reach zero).
         if volume == 0 {
             return 0.0;
-        } else if volume == 1 {
+        } else if volume == Self::MAX_VOLUME {
             // And limit in case of rounding errors (as is the case for log).
             return 1.0;
         }