Merge pull request #153 from dotX12/dev

Minor code optimization

Author: marin-m

src/fingerprinting/algorithm.rs

@@ -119,7 +119,7 @@ impl SignatureGenerator {
         this.signature
     }
 
-    fn do_fft(self: &mut Self, s16_mono_16khz_buffer: &[i16]) {
+    fn do_fft(&mut self, s16_mono_16khz_buffer: &[i16]) {
 
         // Copy the 128 input s16le samples to the local ring buffer
 
@@ -130,10 +130,10 @@ impl SignatureGenerator {
 
         // Reorder the items (put the latest data at end) and apply Hanning window
 
-        for index in 0..=2047 {
+        for (index, multiplier) in HANNING_WINDOW_2048_MULTIPLIERS.iter().enumerate() {
             self.reordered_ring_buffer_of_samples[index] =
                 self.ring_buffer_of_samples[(index + self.ring_buffer_of_samples_index) & 2047] as f32 *
-                    HANNING_WINDOW_2048_MULTIPLIERS[index];
+                    multiplier;
         }
 
         // Perform Fast Fourier transform
@@ -159,7 +159,7 @@ impl SignatureGenerator {
         self.fft_outputs_index &= 255;
     }
 
-    fn do_peak_spreading(self: &mut Self) {
+    fn do_peak_spreading(&mut self) {
         let real_fft_results = &self.fft_outputs[((self.fft_outputs_index as i32 - 1) & 255) as usize];
 
         let spread_fft_results = &mut self.spread_fft_outputs[self.spread_fft_outputs_index];
@@ -191,7 +191,7 @@ impl SignatureGenerator {
         self.spread_fft_outputs_index &= 255;
     }
 
-    fn do_peak_recognition(self: &mut Self) {
+    fn do_peak_recognition(&mut self) {
 
         // Note: when substracting an array index, casting to signed is needed
         // to avoid underflow panics at runtime.
@@ -265,15 +265,19 @@ impl SignatureGenerator {
                             _ => { continue; }
                         };
 
-                        if !self.signature.frequency_band_to_sound_peaks.contains_key(&frequency_band) {
-                            self.signature.frequency_band_to_sound_peaks.insert(frequency_band, vec![]);
-                        }
+                        // In Rust, the entry method returns an Entry object,
+                        // which represents a cell in a HashMap that is either occupied or vacant.
+                        // You can use or_default to insert a value if the key is missing,
+                        // which avoids a double search of the key in the hash map.
+                        self.signature.frequency_band_to_sound_peaks
+                            .entry(frequency_band)
+                            .or_default();
 
                         self.signature.frequency_band_to_sound_peaks.get_mut(&frequency_band).unwrap().push(
                             FrequencyPeak {
-                                fft_pass_number: fft_pass_number,
+                                fft_pass_number,
                                 peak_magnitude: peak_magnitude as u16,
-                                corrected_peak_frequency_bin: corrected_peak_frequency_bin,
+                                corrected_peak_frequency_bin,
                                 sample_rate_hz: 16000,
                             }
                         );

src/fingerprinting/signature_format.rs

@@ -21,15 +21,15 @@ impl FrequencyPeak {
     /// rate, 1024 useful bins and the multiplication by 64 made before
     /// storing the information
     
-    pub fn get_frequency_hz(self: &Self) -> f32 {
+    pub fn get_frequency_hz(&self) -> f32 {
 
         self.corrected_peak_frequency_bin as f32 * (self.sample_rate_hz as f32 / 2.0 / 1024.0 / 64.0)
 
     }
 
     /// Not sure about this calculation but gives small enough numbers
     
-    pub fn get_amplitude_pcm(self: &Self) -> f32 {
+    pub fn get_amplitude_pcm(&self) -> f32 {
 
         (((self.peak_magnitude as f32 - 6144.0) / 1477.3).exp() * ((1 << 17) as f32) / 2.0).sqrt() / 1024.0
 
@@ -38,7 +38,7 @@ impl FrequencyPeak {
     /// Assume that new FFT bins are emitted every 128 samples, on a
     /// standard 16 KHz sample rate basis.
     
-    pub fn get_seconds(self: &Self) -> f32 {
+    pub fn get_seconds(&self) -> f32 {
 
         (self.fft_pass_number as f32 * 128.0) / self.sample_rate_hz as f32
 
@@ -174,13 +174,13 @@ impl DecodedSignature {
                         if !frequency_band_to_sound_peaks.contains_key(&frequency_band) {
                             frequency_band_to_sound_peaks.insert(frequency_band, vec![]);
                         }
-                                                
+
                         frequency_band_to_sound_peaks.get_mut(&frequency_band).unwrap().push(
                             FrequencyPeak {
-                                fft_pass_number: fft_pass_number,
+                                fft_pass_number,
                                 peak_magnitude: frequency_peaks_cursor.read_u16::<LittleEndian>()?,
                                 corrected_peak_frequency_bin: frequency_peaks_cursor.read_u16::<LittleEndian>()?,
-                                sample_rate_hz: sample_rate_hz
+                                sample_rate_hz
                             }
                         );
                     }
@@ -210,7 +210,7 @@ impl DecodedSignature {
 
     }
 
-    pub fn encode_to_binary(self: &Self) -> Result<Vec<u8>, Box<dyn Error>> {
+    pub fn encode_to_binary(&self) -> Result<Vec<u8>, Box<dyn Error>> {
 
         let mut cursor = Cursor::new(vec![]);
 
@@ -242,7 +242,7 @@ impl DecodedSignature {
         cursor.write_u32::<LittleEndian>(0)?; // size_minus_header - Will write later
 
         let mut sorted_iterator: Vec<_> = self.frequency_band_to_sound_peaks.iter().collect();
-        sorted_iterator.sort_by(|x,y| x.0.cmp(&y.0));
+        sorted_iterator.sort_by(|x, y| x.0.cmp(y.0));
 
         for (frequency_band, frequency_peaks) in sorted_iterator {
 
@@ -275,7 +275,7 @@ impl DecodedSignature {
 
             cursor.write_u32::<LittleEndian>(0x60030040 + *frequency_band as u32)?;
             cursor.write_u32::<LittleEndian>(peaks_buffer.len() as u32)?;
-            cursor.write(&peaks_buffer)?;
+            cursor.write_all(&peaks_buffer)?;
             for _padding_index in 0..((4 - peaks_buffer.len() as u32 % 4) % 4) {
                 cursor.write_u8(0)?;
             }
@@ -298,13 +298,13 @@ impl DecodedSignature {
         Ok(cursor.into_inner())
     }
 
-    pub fn encode_to_uri(self: &Self) -> Result<String, Box<dyn Error>> {
+    pub fn encode_to_uri(&self) -> Result<String, Box<dyn Error>> {
 
         Ok(format!("{}{}", DATA_URI_PREFIX, base64::encode(self.encode_to_binary()?)))
 
     }
 
-    pub fn to_lure(self: &Self) -> Result<Vec<i16>, Box<dyn Error>> {
+    pub fn to_lure(&self) -> Result<Vec<i16>, Box<dyn Error>> {
 
         let mut buffer: Vec<i16> = [0].repeat((self.number_samples as f32 / self.sample_rate_hz as f32 * 16000.0) as usize);
 

src/gui/song_history_interface.rs

@@ -269,7 +269,7 @@ impl SongRecordInterface for FavoritesInterface {
 }
 
 impl FavoritesInterface {
-    pub fn get_is_favorite(self: &Self) -> &HashSet<Song> {
+    pub fn get_is_favorite(&self) -> &HashSet<Song> {
         &self.is_favorite
     }
 }

src/utils/csv_song_history.rs

@@ -35,11 +35,11 @@ pub struct Song {
 }
 
 pub trait IsSong {
-    fn get_song(self: Self) -> Song;
+    fn get_song(self) -> Song;
 }
 
 impl IsSong for SongHistoryRecord {
-    fn get_song(self: Self) -> Song {
+    fn get_song(self) -> Song {
         return Song {
             song_name: self.song_name,
             album: self.album,