awaaz 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2aa5ae798de6f2b722134913cc7b055f53b4b035989e94521be55d1fe76acc7
-  data.tar.gz: b54beb3ae4fc90ab2a4c1485ffa91eccb1b53cafca27c04e7ece14263b65abb4
+  metadata.gz: 539ed57cbb902bb7b86939c6c9ccde9265cc8b28c4fee725359acdf918c9b2ff
+  data.tar.gz: ba30315c102903f622eead61d5a847d9c9b93e3d7a7cca790ebff995e909d014
 SHA512:
-  metadata.gz: b0c79b3dbf5396de690ee17868cb8a0d2d29dfe396b8c5dd9c9a098393a40d15715d4def9990990024ad356f9463cb28feab981e96f59e4961d978e373a104ce
-  data.tar.gz: d28e0001af9a5b8052298f33a5dbf72ca16325d15e3762187fd7a022b6140874729f52d71d32a0e39a589b712471e248fd28dd6e73dea35dd3fa26742a22ef2b
+  metadata.gz: 3a4fb5f88de016a035d06660deabc2472aaa423400cdf72acb7eb9440f23e8ab15606e74e23758ce812539e3878236b590580c9665614494631beba0e71d7dc3
+  data.tar.gz: b5ed50514a4c1a9be9c3008cbaa2661aaa1d69d6ba33dc3906db202ee10da20741e7cea4d488f27ce7029bfd40552edf4464f7debbf4bc37e47dd52cd4c4bcf2

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.4
+  TargetRubyVersion: 3.0
   NewCops: enable
 
 Style/StringLiterals:
@@ -11,5 +11,9 @@ Style/StringLiteralsInInterpolation:
 Metrics/MethodLength:
   Max: 20
 
+Style/NumericPredicate:
+  Enabled: false
 
+Metrics/ModuleLength:
+  Enabled: false # Temporary
 

data/.ruby-version

@@ -1 +1 @@
-3.4.2
+3.0.0

data/CHANGELOG.md

@@ -1,5 +1,16 @@
-## [Unreleased]
+## [Released]
 
-## [0.1.0] - 2025-07-21
+## [0.1.0] - 2025-08-12
 
 - Initial release
+- Ability to decode `.wav` and `.mp3`.
+
+## 0.2.0 - 2025-08-26
+
+- Introduced new features for audio analysis:
+  - RMS (Root Mean Square)
+  - Zero Crossing Rate
+  - Spectral Centroid
+  - Spectral Bandwidth
+  - Spectral Rolloff
+  - Spectral Flatness

data/GLOSSARY.md

@@ -1,3 +1,9 @@
 # Terms and Definitions for Audio Processing
 
-- **PCM (Pulse Code Modulation):** A method to convert analog audio signals into digital form by sampling the signal's ampllitude at regular intervals.
+- **PCM (Pulse Code Modulation):** A method to convert analog audio signals into digital form by sampling the signal's amplitude at regular intervals.
+- **RMS (Root Mean Square)**: Basically measures the average signal's power or loudness of time.
+- **Spectral Bandwidth:** Calculation of variation of frequencies around the spectral centroid of the audio. Low bandwidth indicates low variation in audio and the audio is concentrated around the centroid. Like a flute note. Higher bandwidth highlights noisy, loud sound, like a distorted guitar.
+- **Spectral Centroid**: It tells us about the 'center of mass' of the sound. Intuitively, lower spectral centroid score means bassier, muffled sound while high centroid value indicates bright, sharp, tinny audio.
+- **Spectral Flatness**: Can be used to identify the noisiness of audio. High flatness (~1) indicates high energy, white noise-like sound. Low value (~0) highlights harmonic signal or pure tone.
+- **Spectral Rolloff:** Measures the frequency below which a certain percentage of the total spectral energy is contained. Low rolloff - more energy is concentrated in lower frequencies, like drums, bass, male voices. High rolloff - significant energy in high frequencies like female voice, hissing sound etc.
+- **ZCR (Zero Crossing Rate)**: Counts how many times the audio changes signal from positive to negative and vice versa. If ZCR is high, the audio is noisy, sharp or high-pitched. And an audio with low ZCR is smooth, steady or low-pitched.

data/README.md

@@ -52,11 +52,14 @@ gem install awaaz
 ```ruby
 # To decode the audio file
 samples, sample_rate = Awaaz.load("path/to/audio_file")
-
-# To decode the audio file using specified decoder
-samples, sample_rate = Awaaz.load("path/to/audio_file", decoder: :sox)
 ```
 
+## Documentation
+
+[Documentation](https://www.rubydoc.info/github/SadMadLad/awaaz)
+
+Checkout [this demo](https://github.com/SadMadLad/awaaz-demo) to get more idea of some use cases of the gem
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/TODOS.md

@@ -1,3 +1,2 @@
-- Lazy decoding of an audio
-- `libsndfile` support
 - Streaming output of larger files
+- Improve and speed up resampling

data/lib/awaaz/config.rb

@@ -76,6 +76,28 @@ module Awaaz
       @available_decoders.nil? || @available_decoders.empty?
     end
 
+    ##
+    # Checks if there is at least one decoder capable of handling WAV files.
+    #
+    # Currently, `ffmpeg` and `sox` are considered capable of decoding WAV files.
+    #
+    # @return [Boolean] `true` if either `ffmpeg` or `sox` is available, otherwise `false`.
+    #
+    def decoders_for_wav?
+      ffmpeg? || sox?
+    end
+
+    ##
+    # Checks if there are no decoders available for handling WAV files.
+    #
+    # This is the logical negation of {#decoders_for_wav?}.
+    #
+    # @return [Boolean] `true` if neither `ffmpeg` nor `sox` is available, otherwise `false`.
+    #
+    def no_decoders_for_wav?
+      !decoders_for_wav?
+    end
+
     private
 
     ##

data/lib/awaaz/decoders/base_decoder.rb

@@ -41,9 +41,9 @@ module Awaaz
       set_available_options
 
       # @param filename [String] Path to the audio file to decode.
-      def initialize(filename, **)
+      def initialize(filename, **options)
         @filename = filename
-        @options = Utils::SoundConfig.new(available_options, **)
+        @options = Utils::SoundConfig.new(available_options, **options)
       end
 
       # Loads audio data.
@@ -72,7 +72,7 @@ module Awaaz
       #   - number of channels
       #   - sample rate
       def soundread
-        Utils::Soundread.new(@filename).read
+        Utils::Soundread.new(@filename, output_rate: sample_rate, sampling_option: resampling_option).read
       end
 
       # Processes the decoded audio samples by reshaping and optionally converting to mono.
@@ -83,7 +83,7 @@ module Awaaz
       # @return [Array<(Numo::DFloat, Integer)>] Processed samples and the sample rate.
       def process(input_samples, channels, sample_rate)
         input_samples = input_samples.reshape(channels, input_samples.size / channels)
-        input_samples = input_samples.mean(0) if mono?
+        input_samples = input_samples.mean(0).reshape(1, input_samples.shape[1]) if mono?
 
         [input_samples, sample_rate]
       end
@@ -107,7 +107,7 @@ module Awaaz
       # Delegates option accessors to the {Utils::SoundConfig} instance.
       %i[
         sample_rate num_channels decoder_option mono mono?
-        stereo? amplification_factor soundread?
+        stereo? amplification_factor soundread? resampling_option
       ].each do |option_key|
         define_method(option_key) { @options.public_send(option_key) }
       end

data/lib/awaaz/decoders/decode.rb

@@ -25,7 +25,7 @@ module Awaaz
     # @param filename [String] the path to the audio file
     # @raise [ArgumentError] if the MIME type is not supported
     # @return [Object] the result of decoding, as returned by the decoder class
-    def load(filename)
+    def load(filename, ...)
       fm = FileMagic.new(FileMagic::MAGIC_MIME_TYPE)
       mime_type = fm.file(filename)
 
@@ -35,7 +35,7 @@ module Awaaz
       end
 
       decoding_class = DECODER_MAP[mime_type]
-      decoding_class.load(filename)
+      decoding_class.load(filename, ...)
     end
   end
 end

data/lib/awaaz/features.rb

@@ -0,0 +1,533 @@
+# frozen_string_literal: true
+
+module Awaaz
+  # Audio Features
+  module Features
+    ##
+    # Calculates the total number of frames for a given signal length, frame size, and hop length.
+    #
+    # @param signal_length [Integer] Number of samples in the signal.
+    # @param frame_size [Integer] Size of each analysis frame (in samples).
+    # @param hop_length [Integer] Step size between consecutive frames (in samples).
+    #
+    # @return [Integer] The total number of frames.
+    #
+    def total_frames(signal_length, frame_size, hop_length)
+      ((signal_length - frame_size) / hop_length.to_f).ceil + 1
+    end
+
+    ##
+    # Computes how many samples are needed to right-pad a signal so
+    # that its length perfectly fits the given frame and hop size.
+    #
+    # @param signal_length [Integer] Number of samples in the signal.
+    # @param frame_size [Integer] Size of each analysis frame (in samples).
+    # @param hop_length [Integer] Step size between consecutive frames (in samples).
+    #
+    # @return [Integer] Number of padding samples required.
+    #
+    def pad_amount(signal_length, frame_size, hop_length)
+      frames = total_frames(signal_length, frame_size, hop_length)
+      padded_length = ((frames - 1) * hop_length) + frame_size
+      padded_length - signal_length
+    end
+
+    ##
+    # Pads an array with zeros (or a specified value) along a given axis.
+    #
+    # @param array [Numo::NArray] The input array (e.g., shape [channels, samples]).
+    # @param pad_count [Integer] Number of padding elements to add.
+    # @param axis [Integer] Axis along which to pad (default: 1 for time axis).
+    # @param with [Numeric] Value to pad with (default: 0).
+    #
+    # @return [Numo::NArray] The padded array.
+    #
+    def pad_right(array, pad_count, axis: 1, with: 0)
+      channels_count = array.shape.first
+      padded_array = Numo::SFloat.new(channels_count, pad_count).fill(with)
+
+      array.concatenate(padded_array, axis: axis)
+    end
+
+    ##
+    # Builds a list of sample index ranges for each analysis frame.
+    #
+    # @param signal_length [Integer] Number of samples in the (possibly padded) signal.
+    # @param frame_size [Integer] Size of each frame (in samples).
+    # @param hop_length [Integer] Step size between consecutive frames (in samples).
+    #
+    # @return [Array<Range>] An array where each element is the sample index range for one frame.
+    #
+    def build_ranges(signal_length, frame_size, hop_length)
+      ranges = []
+      start = 0
+      while start + frame_size <= signal_length
+        ranges << (start...(start + frame_size))
+        start += hop_length
+      end
+      ranges
+    end
+
+    ##
+    # Pads the signal (if necessary) and returns the padded array along with frame index ranges.
+    #
+    # @param array [Numo::NArray] A 2D array where shape is [channels, samples].
+    # @param frame_size [Integer] Size of each frame (in samples).
+    # @param hop_length [Integer] Step size between consecutive frames (in samples).
+    #
+    # @raise [ArgumentError] If hop length is less than 1.
+    #
+    # @return [Array<(Numo::NArray, Array<Range>)>]
+    #   - padded signal array
+    #   - array of frame index ranges
+    #
+    def frame_ranges(array, frame_size: 2048, hop_length: 512)
+      raise ArgumentError, "Hop Length can't be less than 1" if hop_length < 1
+
+      amount = pad_amount(array.shape[1], frame_size, hop_length)
+      array = pad_right(array, amount) if amount.positive?
+
+      [array, build_ranges(array.shape[1], frame_size, hop_length)]
+    end
+
+    ##
+    # Calculates the RMS (Root Mean Square) energy for each frame in the given audio.
+    #
+    # @param samples [Numo::NArray] A 2D array of shape [channels, samples].
+    # @param frame_size [Integer] Size of each analysis frame (in samples).
+    # @param hop_length [Integer] Step size between consecutive frames (in samples).
+    #
+    # @return [Numo::SFloat] A 2D array of RMS values with shape [channels, frames].
+    #
+    def rms(samples, frame_size: 2048, hop_length: 512)
+      samples, frame_groups = frame_ranges(samples, frame_size: frame_size, hop_length: hop_length)
+
+      means = Numo::SFloat.zeros(samples.shape[0], frame_groups.length)
+      frame_groups.each_with_index do |frame_range, idx|
+        means[true, idx] = samples[true, frame_range].rms(axis: 1)
+      end
+
+      means
+    end
+
+    ##
+    # Calculates the overall RMS for an entire signal without framing.
+    #
+    # @param samples [Numo::NArray] A 2D or 1D array of samples.
+    #
+    # @return [Float] RMS value for the entire signal.
+    #
+    def rms_overall(samples)
+      samples.rms
+    end
+
+    # Calculates the zero-crossing rate (ZCR) of an audio signal frame-by-frame.
+    #
+    # The zero-crossing rate is the proportion of consecutive samples in a frame
+    # where the signal changes sign (positive to negative or vice versa).
+    # It is often used as a simple feature in speech/music analysis.
+    #
+    # @param samples [Numo::NArray] 2D array of audio samples.
+    #   Shape: [n_channels, n_samples].
+    # @param frame_size [Integer] Size of each analysis frame in samples. Default: 2048.
+    # @param hop_length [Integer] Step size between successive frames in samples. Default: 512.
+    # @return [Numo::SFloat] 2D array of zero-crossing rates per frame for each channel.
+    #   Shape: [n_channels, n_frames].
+    #
+    # @example
+    #   # Stereo signal: 2 channels, 44100 samples
+    #   zcr_values = zcr(samples, frame_size: 2048, hop_length: 512)
+    #   puts zcr_values.shape  # => [2, n_frames]
+    #
+    def zcr(samples, frame_size: 2048, hop_length: 512)
+      framed_samples, frame_groups = frame_ranges(samples, frame_size: frame_size, hop_length: hop_length)
+
+      n_channels = framed_samples.shape[0]
+      zcrs = Numo::SFloat.zeros(n_channels, frame_groups.length)
+
+      frame_groups.each_with_index do |frame_range, idx|
+        zcrs[true, idx] = zcr_for_frame(framed_samples[true, frame_range], frame_size)
+      end
+
+      zcrs
+    end
+
+    # Calculates the zero-crossing rate for a single frame of audio.
+    #
+    # @param frame [Numo::NArray] 2D array containing audio samples for a single frame.
+    #   Shape: [n_channels, frame_size].
+    # @param frame_size [Integer] Number of samples in the frame.
+    # @return [Numo::SFloat] 1D array of zero-crossing rates for each channel in the frame.
+    #   Shape: [n_channels].
+    #
+    # @example
+    #   frame = samples[true, 0...2048]
+    #   single_frame_zcr = zcr_for_frame(frame, 2048)
+    #   puts single_frame_zcr  # => Numo::SFloat[0.15, 0.12]
+    def zcr_for_frame(frame, frame_size)
+      first_part = frame[true, 0...-1]
+      second_part = frame[true, 1..-1]
+      products = first_part * second_part
+
+      sign_changes = products < 0
+      counts = sign_changes.count_true(axis: 1)
+
+      counts / frame_size.to_f
+    end
+
+    # Calculates the overall zero-crossing rate (ZCR) of an entire audio signal.
+    #
+    # @param samples [Numo::NArray] 2D array of audio samples.
+    #   Shape: [n_channels, n_samples].
+    # @return [Numo::SFloat] 1D array containing the overall ZCR for each channel.
+    #   Shape: [n_channels].
+    #
+    # @example
+    #   # Stereo signal: 2 channels, 44100 samples
+    #   overall_zcr = zcr_overall(samples)
+    #   puts overall_zcr.shape  # => [2]
+    #
+    #
+    def zcr_overall(samples)
+      ((samples[true, 0...-1] * samples[true, 1..-1]) < 0).count_true(axis: 1) / samples.shape[1].to_f
+    end
+
+    # Generates a Hann window of given frame size.
+    #
+    # A Hann window is commonly used in spectral analysis
+    # to reduce spectral leakage before applying an FFT.
+    #
+    # @param frame_size [Integer] the size of the frame (number of samples per window)
+    # @return [Numo::DFloat] the Hann window of length `frame_size`
+    def hann_window(frame_size)
+      idx = Numo::DFloat.new(frame_size).seq
+      0.5 * (1 - Numo::NMath.cos(2 * Math::PI * idx / (frame_size - 1)))
+    end
+
+    # Prepares audio samples and parameters for FFT-based feature extraction.
+    #
+    # @param samples [Numo::NArray]
+    #   Multichannel audio samples as a 2D array
+    #   (shape: [channels, samples]).
+    # @param frame_size [Integer]
+    #   Number of samples per frame (FFT window length).
+    # @param hop_length [Integer]
+    #   Number of samples to shift between consecutive frames.
+    #
+    # @return [Array]
+    #   A tuple containing:
+    #   - samples [Numo::NArray] : Windowed audio samples aligned to frames
+    #   - ranges [Array<Range>] : Frame index ranges for iteration
+    #   - window [Numo::DFloat] : Hann window for FFT
+    #   - channels_count [Integer] : Number of audio channels
+    #   - freqs_size [Integer] : Number of FFT frequency bins per frame
+    #
+    # @example
+    #   samples, ranges, window, channels_count, freqs_size =
+    #     prepare_for_fft(audio, frame_size: 2048, hop_length: 512)
+    #
+    def prepare_for_fft(samples, frame_size:, hop_length:)
+      samples, ranges = frame_ranges(samples, frame_size: frame_size, hop_length: hop_length)
+      window = hann_window(frame_size)
+      channels_count = samples.shape[0]
+      freqs_size = (frame_size / 2) + 1
+
+      [samples, ranges, window, channels_count, freqs_size]
+    end
+
+    # Computes the Short-Time Fourier Transform (STFT) of a multi-channel signal.
+    #
+    # This method applies a sliding Hann window to the input signal, computes
+    # the FFT for each frame and each channel, and stores the positive frequency
+    # bins into a 3D complex-valued matrix.
+    #
+    # The resulting STFT matrix has dimensions:
+    #   `[channels, frequencies, frames]`
+    #
+    # @param samples [Numo::NArray] a 2D array of shape [channels, samples]
+    #   containing the audio data.
+    # @param frame_size [Integer] the size of each FFT frame (default: 2048)
+    # @param hop_length [Integer] the number of samples between successive frames (default: 512)
+    # @return [Numo::DComplex] a 3D array of shape
+    #   `[channels, (frame_size / 2 + 1), frames]` containing the complex STFT values
+    #
+    # @example Compute STFT for mono audio
+    #   samples = Numo::DFloat[[0.0, 1.0, 0.0, -1.0, ...]] # shape: [1, num_samples]
+    #   stft_matrix = stft(samples, frame_size: 1024, hop_length: 256)
+    #
+    def stft(samples, frame_size: 2048, hop_length: 512)
+      samples, ranges, window, channels_count, freqs_size = prepare_for_fft(samples, frame_size: frame_size,
+                                                                                     hop_length: hop_length)
+      stft_matrix = Numo::DComplex.zeros(channels_count, freqs_size, ranges.size)
+
+      ranges.each_with_index do |range, frame_idx|
+        channels_count.times do |ch|
+          fft_result = Numo::Pocketfft.fft(samples[ch, range] * window)
+          stft_matrix[ch, true, frame_idx] = fft_result[0...freqs_size]
+        end
+      end
+
+      stft_matrix
+    end
+
+    ##
+    # Computes the FFT (Fast Fourier Transform) of each channel
+    # in a multi-channel signal using a Hann window.
+    #
+    # @param samples [Numo::NArray] A 2D array of shape [channels, samples]
+    #   containing the audio data.
+    #
+    # @return [Numo::DComplex] A 2D complex array of shape
+    #   `[channels, samples]` containing the FFT result for each channel.
+    #
+    def fft(samples)
+      window = hann_window(samples.shape[1])
+      channels_count = samples.shape[0]
+      fft_results = channels_count.times.map do |ch|
+        Numo::Pocketfft.fft(samples[ch, true] * window)
+      end
+      Numo::DComplex[*fft_results]
+    end
+
+    ##
+    # Computes the frequency bin centers for an FFT.
+    #
+    # @param frame_size [Integer] The size of the FFT frame (in samples).
+    # @param sample_rate [Integer] The sampling rate of the audio (Hz).
+    #
+    # @return [Numo::DFloat] 1D array of frequency values (Hz)
+    #   corresponding to FFT bins. Shape: `[frame_size/2 + 1]`.
+    #
+    def frequency_bins(frame_size, sample_rate)
+      Numo::DFloat.new((frame_size / 2) + 1).seq * (sample_rate.to_f / frame_size)
+    end
+
+    ##
+    # Computes the magnitude spectrum of a single frame using an FFT.
+    #
+    # @param frame [Numo::NArray] 1D array of audio samples for a single frame.
+    #
+    # @return [Numo::DFloat] 1D array of magnitude values for each FFT bin.
+    #
+    def frame_magnitude(frame)
+      Numo::Pocketfft.rfft(frame).abs
+    end
+
+    ##
+    # Computes the spectral centroid of a single frame.
+    #
+    # The spectral centroid is the "center of mass" of the spectrum
+    # and is often associated with the perceived brightness of a sound.
+    #
+    # @param freqs [Numo::DFloat] 1D array of frequency bin centers.
+    # @param magnitude [Numo::DFloat] 1D array of magnitude values
+    #   corresponding to each frequency bin.
+    #
+    # @return [Float] The spectral centroid in Hz for the given frame.
+    #
+    def compute_centroid(freqs, magnitude)
+      mag_sum = magnitude.sum
+      return 0 if mag_sum.zero?
+
+      (freqs * magnitude).sum / mag_sum
+    end
+
+    ##
+    # Computes the spectral centroid trajectory of an audio signal.
+    #
+    # This method frames the signal, applies a Hann window,
+    # computes the FFT magnitudes, and calculates the centroid
+    # for each frame. The result is a time series of centroids.
+    #
+    # @param samples [Numo::NArray] A 2D array of shape [channels, samples].
+    # @param frame_size [Integer] Size of each analysis frame (default: 2048).
+    # @param hop_length [Integer] Step size between frames in samples (default: 512).
+    # @param sample_rate [Integer] Sampling rate of the audio in Hz (default: 22050).
+    #
+    # @return [Numo::DFloat] 2D array of spectral centroids with shape
+    #   `[channels, n_frames]`.
+    #
+    # @example
+    #   centroids = spectral_centroids(samples, frame_size: 1024, hop_length: 256, sample_rate: 44100)
+    #   puts centroids.shape # => [channels, n_frames]
+    #
+    def spectral_centroids(samples, frame_size: 2048, hop_length: 512, sample_rate: 22_050)
+      samples, ranges, window, channels_count = prepare_for_fft(samples, frame_size: frame_size, hop_length: hop_length)
+      freqs = frequency_bins(frame_size, sample_rate)
+      centroid_matrix = Numo::DFloat.zeros(channels_count, ranges.size)
+
+      ranges.each_with_index do |range, frame_idx|
+        channels_count.times do |ch|
+          frame = samples[ch, range] * window
+          magnitude = frame_magnitude(frame)
+          centroid_matrix[ch, frame_idx] = compute_centroid(freqs, magnitude)
+        end
+      end
+
+      centroid_matrix
+    end
+
+    # Computes the bandwidth for a single frame.
+    #
+    # @param freqs [Numo::DFloat] Frequency bins (Hz)
+    # @param magnitude [Numo::DFloat] Magnitude spectrum for the frame
+    # @param centroid [Float] Spectral centroid for the frame (Hz)
+    # @param power [Integer] Power/exponent used for bandwidth calculation (commonly 2)
+    # @return [Float] Spectral bandwidth for the frame
+    def compute_bandwidth(freqs, magnitude, centroid, power)
+      mag_sum = magnitude.sum
+      return 0 if mag_sum.zero?
+
+      diff = (freqs - centroid).abs**power
+      value = (magnitude * diff).sum / mag_sum
+      value**(1.0 / power)
+    end
+
+    # Computes the spectral bandwidth over time for a signal.
+    #
+    # @param samples [Numo::DFloat] Input samples (channels x samples)
+    # @param frame_size [Integer] FFT window size (default: 2048)
+    # @param hop_length [Integer] Step size between frames (default: 512)
+    # @param sample_rate [Integer] Sampling rate of the audio signal (default: 22050 Hz)
+    # @param power [Integer] Exponent for bandwidth calculation (default: 2)
+    # @return [Numo::DFloat] Spectral bandwidth matrix (channels x frames)
+    def spectral_bandwidth(samples, frame_size: 2048, hop_length: 512, sample_rate: 22_050, power: 2)
+      samples, ranges, window, channels_count = prepare_for_fft(samples, frame_size: frame_size, hop_length: hop_length)
+      freqs = frequency_bins(frame_size, sample_rate)
+      bandwidth_matrix = Numo::DFloat.zeros(channels_count, ranges.size)
+
+      ranges.each_with_index do |range, frame_idx|
+        channels_count.times do |ch|
+          magnitude = frame_magnitude(samples[ch, range] * window)
+          centroid = compute_centroid(freqs, magnitude)
+          bandwidth_matrix[ch, frame_idx] = compute_bandwidth(freqs, magnitude, centroid, power)
+        end
+      end
+
+      bandwidth_matrix
+    end
+
+    # Computes the spectral rolloff for a single frame.
+    #
+    # @param spectrum [Numo::DFloat] Magnitude spectrum for the frame
+    # @param freqs [Numo::DFloat] Frequency bins (Hz)
+    # @param threshold [Float] Proportion of spectral energy to retain (default: 0.85)
+    # @return [Float] Roll-off frequency (Hz) for the frame
+    def rolloff_for_frame(spectrum, freqs, threshold)
+      total_energy = spectrum.sum
+      return 0.0 if total_energy.zero?
+
+      cumsum = spectrum.cumsum
+      threshold_energy = threshold * total_energy
+
+      rolloff_bin = cumsum.ge(threshold_energy).where[0]
+      rolloff_bin ||= freqs.size - 1
+
+      freqs[rolloff_bin]
+    end
+
+    # Computes the spectral rolloff over time for a signal.
+    #
+    # Spectral rolloff is the frequency below which a fixed percentage
+    # (threshold) of the total spectral energy is contained.
+    #
+    # @param samples [Numo::DFloat] Input samples (channels x samples)
+    # @param frame_size [Integer] FFT window size (default: 2048)
+    # @param hop_length [Integer] Step size between frames (default: 512)
+    # @param sample_rate [Integer] Sampling rate of the audio signal (default: 22050 Hz)
+    # @param threshold [Float] Proportion of spectral energy to retain (default: 0.85)
+    # @return [Numo::DFloat] Spectral rolloff matrix (channels x frames)
+    def spectral_rolloff(samples, frame_size: 2048, hop_length: 512, sample_rate: 22_050, threshold: 0.85)
+      stft_matrix = stft(samples, frame_size: frame_size, hop_length: hop_length).abs
+      channels, _freqs_size, frames_size = stft_matrix.shape
+      freqs = frequency_bins(frame_size, sample_rate)
+
+      rolloff_matrix = Numo::DFloat.zeros(channels, frames_size)
+
+      frames_size.times do |frame_idx|
+        channels.times do |ch|
+          rolloff_matrix[ch, frame_idx] = rolloff_for_frame(
+            stft_matrix[ch, true, frame_idx], freqs, threshold
+          )
+        end
+      end
+
+      rolloff_matrix
+    end
+
+    # Convert frame indices to time in seconds.
+    #
+    # This method maps analysis frame indices (or total frame count) into
+    # corresponding time positions in seconds, similar to `librosa.frames_to_time`.
+    #
+    # @param frames [Integer, Numo::NArray] Either a single frame index,
+    #   or a Numo array of shape (n_channels, n_frames) from which the total
+    #   number of frames is inferred.
+    # @param hop_length [Integer] Number of audio samples between adjacent frames.
+    #   Defaults to 512.
+    # @param sample_rate [Integer] Sampling rate of the audio signal in Hz.
+    #   Defaults to 22,050 Hz.
+    #
+    # @return [Numo::DFloat] A 1-D Numo array of times (in seconds) corresponding
+    #   to each frame index. If `frames` is an Integer, the return value spans
+    #   from frame 0 up to `frames - 1`. If `frames` is a Numo array, the return
+    #   value spans the number of frames inferred from `frames.shape[1]`.
+    #
+    # @example Using total frame count
+    #   frames_to_time(100, hop_length: 512, sample_rate: 22050)
+    #   # => Numo::DFloat[0.0, 0.0232, ..., 2.3121]
+    #
+    # @example Using a spectrogram matrix
+    #   samples = Numo::DFloat.new(2, 500) # 2 channels, 500 frames
+    #   frames_to_time(samples, hop_length: 512, sample_rate: 22050)
+    #   # => Numo::DFloat[0.0, 0.0232, ..., 11.61]
+    #
+    def frames_to_time(frames, hop_length: 512, sample_rate: 22_050)
+      frames_size = frames.shape[1] unless frames.is_a?(Integer)
+      Numo::DFloat[0...frames_size] * hop_length / sample_rate.to_f
+    end
+
+    ##
+    # Computes the spectral flatness of an audio signal.
+    #
+    # Spectral flatness measures how noise-like a signal is, as opposed to being tone-like.
+    # A value closer to 1.0 indicates the spectrum is flat (similar to white noise),
+    # while values closer to 0.0 indicate a peaky spectrum (like a sine wave or harmonic-rich signal).
+    #
+    # @param samples [Numo::NArray]
+    #   The input audio samples (1D array).
+    #
+    # @param frame_size [Integer] (2048)
+    #   The size of each FFT window (frame). Larger sizes give better frequency
+    #   resolution but worse time resolution.
+    #
+    # @param hop_length [Integer] (512)
+    #   The number of samples to shift between consecutive FFT frames. Smaller values
+    #   provide more overlap and smoother results.
+    #
+    # @param amin [Float] (1e-10)
+    #   A small constant added for numerical stability, preventing log(0) or division by zero.
+    #
+    # @param power [Integer] (2)
+    #   The power to which the magnitude spectrum is raised. Typically 2 to work with
+    #   power spectrograms.
+    #
+    # @return [Numo::DFloat]
+    #   A 1D Numo::DFloat array containing the spectral flatness values for each frame.
+    #
+    # @example Compute spectral flatness for an audio clip
+    #   samples = Awaaz::Utils::Soundread.new("audio.wav").read
+    #   flatness = spectral_flatness(samples, frame_size: 1024, hop_length: 256)
+    #   puts flatness.shape
+    #
+    def spectral_flatness(samples, frame_size: 2048, hop_length: 512, amin: 1e-10, power: 2)
+      stft_matrix = stft(samples, frame_size: frame_size, hop_length: hop_length).abs
+      stft_matrix = Numo::DFloat.maximum(amin, stft_matrix**power)
+
+      gms = Numo::DFloat::Math.exp Numo::DFloat::Math.log(stft_matrix).mean(axis: -2)
+      ams = stft_matrix.mean(axis: -2)
+
+      gms / ams
+    end
+  end
+end

data/lib/awaaz/properties.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Awaaz gem
+module Awaaz
+  # Properties of audio
+  module Properties
+    # Calculates the duration (in seconds) of an audio signal given the number of samples and the sample rate.
+    #
+    # @param samples [Numo::NArray, Array, Object]
+    #   The audio samples. This can be a Numo::NArray, Array, or any object
+    #   that responds to `.shape` and returns a size array.
+    #
+    # @param sample_rate [Integer, Float]
+    #   The sampling rate (in Hz) of the audio signal.
+    #
+    # @return [Float]
+    #   The duration of the audio signal in seconds. Returns `0.0` if either
+    #   the number of samples or the sample rate is non-positive.
+    #
+    # @example
+    #   samples = Numo::DFloat.new(44100) # 1 second of audio at 44.1 kHz
+    #   Awaaz.duration(samples, 44100)
+    #   # => 1.0
+    #
+    # @note
+    #   The duration is computed as:
+    #     samples_count / sample_rate
+    #
+    # @see https://en.wikipedia.org/wiki/Sampling_(signal_processing)
+    def duration(samples, sample_rate)
+      samples_count = samples.shape.max
+      return 0.0 if samples_count <= 0 || sample_rate <= 0
+
+      samples_count / sample_rate.to_f
+    end
+  end
+end

data/lib/awaaz/utils/resample.rb

@@ -6,7 +6,7 @@ module Awaaz
     # Resample utilities for audio data represented as Numo::NArray.
     # Wraps the `libsamplerate` bindings provided by {Extensions::Samplerate}.
     #
-    # @note This module is intended for internal use, but `read_and_resample_numo`
+    # @note This module is intended for internal use, but `read_and_resample`
     #   is public for advanced users who need manual resampling.
     module Resample
       class << self
@@ -31,17 +31,19 @@ module Awaaz
         #
         # @example Resample 44.1kHz mono audio to 48kHz
         #   samples = Numo::SFloat.new(44100).rand
-        #   new_samples = Awaaz::Utils::Resample.read_and_resample_numo(samples, 44100, 48000)
-        def read_and_resample_numo(input_samples, input_rate, output_rate, sampling_option: :sinc_best_quality)
-          validate_inputs(input_samples, input_rate, output_rate)
+        #   new_samples = Awaaz::Utils::Resample.read_and_resample(samples, 44100, 48000)
+        def read_and_resample(input_samples, input_rate, output_rate, channels, sampling_option: :sinc_fastest)
+          return input_samples if input_rate == output_rate
+
+          validate_inputs(input_samples)
 
           ratio = calculate_ratio(input_rate, output_rate)
-          input_ptr, output_ptr, input_frames, output_frames = prepare_memory(input_samples, ratio)
+          input_ptr, output_ptr, input_frames, output_frames = prepare_memory(input_samples, ratio, channels)
 
           data = build_src_data(input_ptr, output_ptr, input_frames, output_frames, ratio)
-          perform_resampling(data, sampling_option)
+          perform_resampling(data, sampling_option, channels)
 
-          convert_to_numo(output_ptr, data[:output_frames_gen])
+          convert_to_numo(output_ptr, data[:output_frames_gen] * channels)
         end
 
         private
@@ -50,14 +52,12 @@ module Awaaz
         # Validates that the provided inputs are of the correct type and configuration.
         #
         # @param samples [Numo::NArray] The input samples.
-        # @param input_rate [Integer]
-        # @param output_rate [Integer]
         #
         # @raise [ArgumentError] If samples are not a Numo::SFloat array.
-        def validate_inputs(samples, input_rate, output_rate)
-          return if input_rate != output_rate && samples.is_a?(Numo::NArray)
+        def validate_inputs(samples)
+          return if samples.is_a?(Numo::NArray)
 
-          raise ArgumentError, "Input must be a Numo::SFloat array" unless samples.is_a?(Numo::NArray)
+          raise ArgumentError, "Input must be a Numo::SFloat array"
         end
 
         ##
@@ -82,14 +82,14 @@ module Awaaz
         # @param ratio [Float] The resampling ratio.
         #
         # @return [Array<FFI::MemoryPointer, FFI::MemoryPointer, Integer, Integer>]
-        def prepare_memory(input_samples, ratio)
-          input_frames = input_samples.size
+        def prepare_memory(input_samples, ratio, channels)
+          input_frames = input_samples.size / channels
           output_frames = (input_frames * ratio).to_i
 
-          input_ptr = FFI::MemoryPointer.new(:float, input_frames)
+          input_ptr = FFI::MemoryPointer.new(:float, input_samples.size)
           input_ptr.write_bytes(input_samples.to_string)
 
-          output_ptr = FFI::MemoryPointer.new(:float, output_frames)
+          output_ptr = FFI::MemoryPointer.new(:float, output_frames * channels)
 
           [input_ptr, output_ptr, input_frames, output_frames]
         end
@@ -122,8 +122,9 @@ module Awaaz
         # @param sampling_option [Symbol, Integer]
         #
         # @raise [Awaaz::ResampleError] If resampling fails.
-        def perform_resampling(data, sampling_option)
-          err = Extensions::Samplerate.src_simple(data, Extensions::Samplerate.resample_option(sampling_option), 1)
+        def perform_resampling(data, sampling_option, channels)
+          err = Extensions::Samplerate.src_simple(data, Extensions::Samplerate.resample_option(sampling_option),
+                                                  channels)
           raise Awaaz::ResampleError, "Resampling failed: #{Extensions::Samplerate.src_strerror(err)}" if err != 0
         end
 

data/lib/awaaz/utils/sound_config.rb

@@ -49,7 +49,16 @@ module Awaaz
       # @return [Boolean] +true+ if mono, otherwise +false+.
       #
       def mono
-        from_options(:mono) || false
+        from_options(:mono) || true
+      end
+
+      ##
+      # Resampling option
+      #
+      # @return [Symbol] default :linear
+      #
+      def resampling_option
+        from_options(:resampling_option) || :linear
       end
 
       ##

data/lib/awaaz/utils/soundread.rb

@@ -3,166 +3,142 @@
 module Awaaz
   module Utils
     ##
-    # A utility class for reading and optionally resampling audio files.
+    # A helper that mimics librosa.load using libsndfile via FFI.
     #
-    # This class supports reading `.wav` files using {Extensions::Soundfile}
-    # and can automatically resample them using {Utils::Resample}.
+    # - Always returns Float32 samples normalized in [-1.0, 1.0]
+    # - Preserves channel structure (returns shape `[channels, frames]`)
+    # - Returns `[data, channels, sr]` where:
+    #   * `data` = Numo::SFloat array (2D, shape: channels x frames)
+    #   * `channels` = Integer number of channels
+    #   * `sr` = sample rate (Integer)
     #
-    # @example Read and resample a WAV file
-    #   reader = Awaaz::Utils::Soundread.new("audio.wav", resample_options: { output_rate: 44100 })
-    #   samples, channels, rate = reader.read
-    #
-    # @note Currently, only `.wav` files are supported.
+    # @example
+    #   reader = Awaaz::Utils::Soundread.new("audio.wav")
+    #   data, channels, sr = reader.read
     #
     class Soundread
       ##
-      # Supported audio file extensions.
-      #
-      # @return [Array<String>] List of supported file extensions.
-      #
-      SUPPORTED_EXTENSIONS = %w[.wav].freeze
-
-      ##
-      # Creates a new Soundread instance.
+      # Initializes a Soundread instance.
       #
       # @param filename [String] Path to the audio file to read.
-      # @param resample_options [Hash] Options for resampling the audio.
-      #   - `:output_rate` [Integer] Output sample rate (default: `22050`)
-      #   - `:sampling_option` [Symbol] Resampling algorithm (default: `:sinc_fastest`)
+      # @param resampling_options [Hash] Optional resampling configuration.
       #
-      def initialize(filename, resample_options: default_resample_options)
+      def initialize(filename, **resampling_options)
         @filename = filename
-        @resample_options = resample_options || {}
+        @resampling_options = resampling_options
       end
 
       ##
-      # Reads the audio file, returning its samples and metadata.
+      # Reads the audio file, returning samples, number of channels, and sample rate.
       #
       # @return [Array<(Numo::SFloat, Integer, Integer)>]
-      #   A tuple containing:
-      #   - samples [Numo::SFloat] — Audio samples as a Numo array.
-      #   - channels [Integer] — Number of channels in the audio.
-      #   - output_rate [Integer] — Sample rate of the returned audio.
+      #   - data [Numo::SFloat] Audio samples, shape = `[channels, frames]`
+      #   - channels [Integer] Number of channels
+      #   - sr [Integer] Sample rate
       #
-      # @raise [ArgumentError] If the file extension is unsupported.
-      # @raise [Awaaz::AudioreadError] If the file cannot be opened.
+      # @raise [ArgumentError] If the file cannot be opened.
       #
       def read
-        validate_support
-        soundfile, sample_rate, frames, channels = open_file
-        samples = parse_soundfile(soundfile, frames, channels)
-        close_soundfile(soundfile)
+        info, sndfile = open_file
+        frames, channels, sr = extract_info(info)
+
+        buffer, read_frames = read_buffer(sndfile, frames, channels)
+        close_file(sndfile)
 
-        resample(samples, sample_rate, channels)
+        data = process_data(buffer, read_frames, channels)
+        [resample(data, sr, channels), channels, sr]
       end
 
       private
 
-      ##
-      # Default resampling options.
-      #
-      # @return [Hash] Default options with `:output_rate => 22050`.
-      #
-      def default_resample_options
-        { output_rate: 22_050 }
-      end
+      def resample(samples, sample_rate, channels)
+        validate_resampling_options
 
-      ##
-      # Ensures the file format is supported.
-      #
-      # @raise [ArgumentError] If the file extension is not in {SUPPORTED_EXTENSIONS}.
-      #
-      def validate_support
-        return if supported?
+        output_rate, sampling_option = @resampling_options.values_at(:output_rate, :sampling_rate)
+        sampling_option ||= :linear
 
-        raise ArgumentError, "File extension not supported. Supported files: #{SUPPORTED_EXTENSIONS.join(",")}"
+        return samples if output_rate == sample_rate || @resampling_options.empty?
+
+        Utils::Resample.read_and_resample(samples, sample_rate, output_rate, channels, sampling_option: sampling_option)
       end
 
-      ##
-      # Checks if the file extension is supported.
-      #
-      # @return [Boolean] `true` if supported, `false` otherwise.
-      #
-      def supported?
-        SUPPORTED_EXTENSIONS.include?(File.extname(@filename))
+      def validate_resampling_options
+        valid_options = %i[output_rate sampling_option]
+
+        @resampling_options.transform_keys!(&:to_sym)
+        @resampling_options.each_key do |key|
+          next if valid_options.include?(key)
+
+          raise ArgumentError, "Invalid option: #{key}. Available options: #{valid_options.join}"
+        end
       end
 
       ##
-      # Opens the audio file for reading.
+      # Opens the file and retrieves SF_INFO metadata.
       #
-      # @return [Array<(FFI::Pointer, Integer, Integer, Integer)>]
-      #   A tuple containing:
-      #   - soundfile [FFI::Pointer] — Pointer to the opened sound file.
-      #   - sample_rate [Integer] — Sample rate of the audio file.
-      #   - frames [Integer] — Number of frames in the file.
-      #   - channels [Integer] — Number of channels in the file.
+      # @return [Array<(Awaaz::Extensions::Soundfile::SF_INFO, FFI::Pointer)>]
       #
-      # @raise [Awaaz::AudioreadError] If the file cannot be opened.
+      # @raise [ArgumentError] If the file cannot be opened.
       #
       def open_file
-        info = Extensions::Soundfile::SF_INFO.new
-        sndfile = Extensions::Soundfile.sf_open(@filename, Extensions::Soundfile::SFM_READ, info.to_ptr)
+        info = Awaaz::Extensions::Soundfile::SF_INFO.new
+        sndfile = Awaaz::Extensions::Soundfile.sf_open(
+          @filename,
+          Awaaz::Extensions::Soundfile::SFM_READ,
+          info
+        )
 
-        raise Awaaz::AudioreadError, "Could not read the audio file" if sndfile.null?
+        raise ArgumentError, "Could not open file: #{@filename}" if sndfile.null?
 
-        sample_rate = info[:samplerate]
-        frames = info[:frames]
-        channels = info[:channels]
-        [sndfile, sample_rate, frames, channels]
+        [info, sndfile]
       end
 
       ##
-      # Reads the raw samples from the file and converts them into a Numo array.
+      # Extracts frames, channels, and sample rate from SF_INFO.
       #
-      # @param soundfile [FFI::Pointer] Open sound file pointer.
+      # @param info [Awaaz::Extensions::Soundfile::SF_INFO]
+      # @return [Array<(Integer, Integer, Integer)>] frames, channels, sr
+      #
+      def extract_info(info)
+        [info[:frames], info[:channels], info[:samplerate]]
+      end
+
+      ##
+      # Reads raw audio frames into a memory buffer.
+      #
+      # @param sndfile [FFI::Pointer] Opened sound file.
       # @param frames [Integer] Number of frames to read.
-      # @param channels [Integer] Number of channels in the file.
-      # @return [Numo::SFloat] The audio samples.
+      # @param channels [Integer] Number of channels.
       #
-      def parse_soundfile(soundfile, frames, channels)
+      # @return [Array<(FFI::MemoryPointer, Integer)>] buffer and number of read frames
+      #
+      def read_buffer(sndfile, frames, channels)
         buffer = FFI::MemoryPointer.new(:float, frames * channels)
-        read_frames = Extensions::Soundfile.sf_readf_float(soundfile, buffer, frames)
-        Numo::SFloat.cast(buffer.read_array_of_float(read_frames * channels))
+        read_frames = Awaaz::Extensions::Soundfile.sf_readf_float(sndfile, buffer, frames)
+        [buffer, read_frames]
       end
 
       ##
       # Closes the open sound file.
       #
-      # @param soundfile [FFI::Pointer] Open sound file pointer.
+      # @param sndfile [FFI::Pointer]
       # @return [void]
       #
-      def close_soundfile(soundfile)
-        Extensions::Soundfile.sf_close(soundfile)
+      def close_file(sndfile)
+        Awaaz::Extensions::Soundfile.sf_close(sndfile)
       end
 
       ##
-      # Resamples the audio if necessary.
+      # Converts the buffer into a Numo::SFloat array and reshapes to `[channels, frames]`.
       #
-      # @param samples [Numo::SFloat] The input samples.
-      # @param sample_rate [Integer] Original sample rate.
+      # @param buffer [FFI::MemoryPointer]
+      # @param read_frames [Integer] Number of frames read.
       # @param channels [Integer] Number of channels.
-      # @return [Array<(Numo::SFloat, Integer, Integer)>]
+      # @return [Numo::SFloat] Audio data of shape `[channels, frames]`.
       #
-      # @raise [ArgumentError] If an invalid resample option key is passed.
-      #
-      def resample(samples, sample_rate, channels)
-        valid_options = %i[output_rate sampling_option]
-
-        @resample_options.transform_keys!(&:to_sym)
-        @resample_options.each_key do |key|
-          next if valid_options.include?(key)
-
-          raise ArgumentError, "Invalid option: #{key}. Available options: #{valid_options.join}"
-        end
-
-        output_rate, sampling_option = @resample_options.values_at(:output_rate, :sampling_rate)
-        sampling_option ||= :sinc_fastest
-
-        [
-          Utils::Resample.read_and_resample_numo(samples, sample_rate, output_rate, sampling_option:),
-          channels,
-          output_rate
-        ]
+      def process_data(buffer, read_frames, channels)
+        data = Numo::SFloat.cast(buffer.read_array_of_float(read_frames * channels))
+        data.reshape(read_frames, channels).transpose
       end
     end
   end

data/lib/awaaz/utils/utils.rb

@@ -19,6 +19,7 @@ require_relative "soundread"
 require_relative "shell_command_builder"
 require_relative "via_shell"
 
+# Awaaz gem
 module Awaaz
   # The Utils module provides low-level helper components
   # for performing core audio-related operations in the Awaaz gem.

data/lib/awaaz/version.rb

@@ -2,5 +2,5 @@
 
 module Awaaz
   # Version the Awaaz gem.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/awaaz.rb

@@ -10,11 +10,11 @@
 # @see Awaaz::Decoders
 # @see Awaaz::Utils
 # @see Awaaz::Config
-module Awaaz
-end
-
+# @see Awaaz::Features
+# @see Awaaz::Properties
 require "ffi"
 require "numo/narray"
+require "numo/pocketfft"
 
 require_relative "awaaz/errors"
 require_relative "awaaz/extensions/extensions"
@@ -23,3 +23,10 @@ require_relative "awaaz/version"
 
 require_relative "awaaz/config"
 require_relative "awaaz/decoders/decoders"
+require_relative "awaaz/features"
+require_relative "awaaz/properties"
+
+module Awaaz
+  extend Features
+  extend Properties
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: awaaz
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Saad Azam
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 2025-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -37,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: numo-pocketfft
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: ruby-filemagic
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +93,8 @@ files:
 - lib/awaaz/extensions/extensions.rb
 - lib/awaaz/extensions/samplerate.rb
 - lib/awaaz/extensions/soundfile.rb
+- lib/awaaz/features.rb
+- lib/awaaz/properties.rb
 - lib/awaaz/utils/resample.rb
 - lib/awaaz/utils/shell_command_builder.rb
 - lib/awaaz/utils/sound_config.rb
@@ -95,6 +112,7 @@ metadata:
   source_code_uri: https://github.com/SadMadLad/awaaz
   changelog_uri: https://github.com/SadMadLad/awaaz/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -102,14 +120,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.4.2
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Audio Analysis with Ruby
 test_files: []