ruby_dsp 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c72440d5d1ce22c2665cb7b467e3f57433994b12e7ce2b35b046b2a2056382b
-  data.tar.gz: bd624dbf28ce1f45e1569b767cd24ea4fe56dafc47e9544c0369ddb4ae41ee20
+  metadata.gz: 0c8994eadc28b1923b14a4979f435f18973a83afb09e73d77f709b2f4cef81b8
+  data.tar.gz: 1516af206f7b1010f871729f00fd5427b522baacbef2fc516090dc0759f4e1b3
 SHA512:
-  metadata.gz: 79b8573dfa3bb57cfd4af2b2a8af7b4e1d72094fcf869a3c103c1aa3fc7dfa9d06150a297ac351e6a8475f695a92d7273731855ac6a3d02a0d0874e1d83bc190
-  data.tar.gz: 2f9cc438c960788df93214f7edd870917043c215ef9a7c7006dcdedc8254ffdc25a641f9316493cfb90b3e8b7d37e76e6bfe6cc404a2ab2278b342735bf3e6c0
+  metadata.gz: f34843f736e5454ed4130d98f2cce6ff62dac04d250291222ce31201f4a4f9f986bfdeb413d1c2c89fab55dc1dceb094dd6b062bb7e1b978c020698f2f0d0f10
+  data.tar.gz: f801c956425c34f6092d40cb3c820c22025aac7aa7a5d9916efd6f8048cccee42a04cebd4b808db7b27940a7360430369ad194dba1f765f313c0ac8aa30a9e6f

data/README.md

@@ -1,4 +1,4 @@
-# RubyDSP | [Documentation](https://www.rubydoc.info/gems/ruby_dsp/0.0.5)
+# RubyDSP | [Documentation](https://www.rubydoc.info/gems/ruby_dsp/0.0.6)
 
 [![Ruby CI](https://github.com/cichrrad/rubyDSP/actions/workflows/test.yml/badge.svg)](https://github.com/cichrrad/rubyDSP/actions/workflows/test.yml)
 
@@ -8,7 +8,7 @@
 
 ---
 
-**RubyDSP** is an audio processing and DSP Ruby gem. Ultimately, it aims to be `librosa`-wannabe for Ruby in some far utopian future which might never come. It uses C++ under the hood, utilizing [miniaudio](https://miniaud.io/) and [Rice](https://github.com/jasonroelofs/rice). 
+**RubyDSP** is an audio processing/synthesis and DSP Ruby gem made mostly for fun. It uses C++ under the hood, utilizing [miniaudio](https://miniaud.io/) and [Rice](https://github.com/jasonroelofs/rice). 
 
 I made this gem to try [Rice](https://github.com/jasonroelofs/rice), as I would like to be able to bring some C++ speed to Ruby, oh my beloved....
 
@@ -16,7 +16,12 @@ I made this gem to try [Rice](https://github.com/jasonroelofs/rice), as I would
 
 * **Fast:** Basically all of the code is written in C++. While not extremely optimized currently, it still absolutely shreds native Ruby.
 
+* **Fluent API:** Mutating methods return `self`, allowing for beautiful, highly readable method chaining (e.g., `track.to_mono!.normalize!.fade_in!(0.5)`).
+
+* **Audio Synthesis & Sequencing:** Build multitrack, polyphonic audio from scratch using a (very limited) set of built-in mathematically generated waveforms (sine, square, sawtooth, and white noise).
+
 * **Format Agnostic Loading:** Automatically decodes standard audio formats (WAV, MP3, FLAC) via `miniaudio`.
+
 > **Note:** While the loading of these formats is supported, `miniaudio` encodes only in `.wav`. While other encodings might be considered in the future, they would require more dependencies and thus are not available right now.
 
 * **Zero-Dependency Native Build:** No need to install `ffmpeg` or `libsndfile` on your system.
@@ -29,24 +34,28 @@ Add this line to your application's `Gemfile`:
 
 ```ruby
 gem 'ruby_dsp'
+
 ```
 
 And then execute:
 
 ```bash
 $ bundle install
+
 ```
 
 Or install it yourself directly via:
 
 ```bash
 $ gem install ruby_dsp
+
 ```
+
 *(Note: Installing this gem requires a modern C++ compiler, as it builds the native extensions directly on your machine upon installation. It requires Ruby 3.0+).*
 
-## Quick Start
+## Quick Start: Audio Processing
 
-Here is a quick look at what you can do with a loaded `AudioTrack`:
+Here is a quick look at what you can do with a loaded `AudioTrack`. Thanks to the fluent API, you can process audio in a single readable chain:
 
 ```ruby
 require 'ruby_dsp'
@@ -57,32 +66,63 @@ track = RubyDSP::AudioTrack.new("raw_vocals.wav")
 puts track 
 # => ['raw_vocals.wav', 12.450s duration, 2 channel(s), 48000Hz sample rate]
 
-# Do stuff!
-track.to_mono!                   # Averages channels into mono
-track.resample!(44100)           # Linearly resamples to target rate
-track.trim_silence!(-60.0)       # Strips leading/trailing silence below -60dB
-
-# Edit & Manipulate
-track.normalize!(-1.0)           # Scales audio to target peak dBFS
-track.fade_in!(0.5)              # Adds a 0.5s linear fade-in
-track.fade_out!(0.5)             # Adds a 0.5s linear fade-out
-track.pad!(1.0, 1.0)             # Pads 1s of silence to both head and tail
-track.pad_to_duration!(15.0)     # Centers audio evenly into a 15s window
-
-# Analysis & Math
+# Process, edit, and save in one chain
+track.to_mono!                       # Averages channels into mono
+     .resample!(44100)               # Linearly resamples to target rate
+     .trim_silence!(-60.0)           # Strips leading/trailing silence below -60dB
+     .normalize!(-1.0)               # Scales audio to target peak dBFS
+     .pad_to_duration!(15.0)         # Centers audio evenly into a 15s window
+     .fade_in!(0.5)                  # Adds a 0.5s linear fade-in
+     .fade_out!(0.5)                 # Adds a 0.5s linear fade-out
+     .save_track("processed.wav")    # Export the final result
+
+# Analysis & Math (Still works!)
 puts "Peak Amp: #{track.peak_amp}"
 puts "Overall RMS: #{track.rms}"
 puts "Overall ZCR: #{track.zcr}"
 
 # You can also get framed analysis for time-series data:
-# framed_rms_data = track.framed_rms(2048, 512) also works
 framed_rms_data = track.framed_rms(frame_length: 2048, hop_length: 512)
 
+```
+
+## Quick Start: Synthesis & Sequencing
+
+Initialize an empty track and generate your own jam using `add_wave!`:
+
+```ruby
+require 'ruby_dsp'
+
+# Create a blank canvas (Mono, 44.1kHz)
+track = RubyDSP::AudioTrack.new("", 1, 44100)
+
+track.add_wave!("sine", 261.63, 3.0, 0.0)
+     .add_wave!("sine", 329.63, 3.0, 1.0)
+     .add_wave!("sine", 392.00, 3.0, 2.0)
+
+# Polish and export
+track.normalize!(-30.0)  # This goes a long way for your hearing
+     .fade_out!(0.5)     # Smooth tail
+     .save_track("c_major_chord.wav")
 
-# Save the results
-track.save_track("processed_vocals.wav")
 ```
 
+### Demos
+
+> You can find scripts for these in `/demo` directory. Outputs were converted from `.wav` to `.mp4` to trick Github to show it in this README.
+
+#### **TWINKLE**
+
+* <video src="./demo/twinkle_twinkle.mp4" controls title="Twinkle"></video>
+
+#### **TETRIS**
+
+* <video src="./demo/tetris_theme.mp4" controls title="Tetris"></video>
+
+#### **SUPER MARIO BROS**
+
+* <video src="./demo/mario_intro.mp4" controls title="SMB"></video>
+
 ## Development
 
 If you want to clone the repo and work on C++ guts, start with:
@@ -96,4 +136,5 @@ If you want to clone the repo and work on C++ guts, start with:
 The gem is available as open source under the terms of the **MIT License**.
 
 ---
+
 > Cheers! - RC

data/ext/ruby_dsp/ruby_dsp.cpp

@@ -7,6 +7,7 @@
 #include <sstream>
 #include <iomanip>
 #include <algorithm>
+#include <cstdlib>
 
 #define MINIAUDIO_IMPLEMENTATION
 #include "vendor/miniaudio.h"
@@ -35,6 +36,17 @@ struct AudioTrack
 
     AudioTrack(std::string f, unsigned int target_channels = 0, unsigned int target_sample_rate = 0) : filename(f)
     {
+
+        // empty constructor
+        if (filename.empty())
+        {
+            sample_rate = target_sample_rate > 0 ? target_sample_rate : 44100;
+            channels = target_channels > 0 ? target_channels : 1;
+            is_mono = (channels == 1);
+            sample_count = 0;
+            return;
+        }
+
         ma_decoder decoder;
         ma_result result;
 
@@ -163,11 +175,11 @@ struct AudioTrack
         return max_val;
     }
 
-    bool to_mono_bang()
+    AudioTrack &to_mono_bang()
     {
         if (is_mono)
         {
-            return false; // no-op
+            return *this; // no-op
         }
 
         if (channels < 1)
@@ -196,14 +208,14 @@ struct AudioTrack
         channels = 1;
         is_mono = true;
         sample_count = samples.size();
-        return true;
+        return *this;
     }
 
-    bool resample_bang(unsigned int target_rate = 0)
+    AudioTrack &resample_bang(unsigned int target_rate = 0)
     {
         if (target_rate == 0 || target_rate == sample_rate)
         {
-            return false; // no-op
+            return *this; // no-op
         }
 
         // TODO: add better, linear will have to do for now
@@ -252,7 +264,7 @@ struct AudioTrack
         sample_rate = target_rate;
         sample_count = samples.size();
 
-        return true;
+        return *this;
     }
 
     std::vector<float> rms()
@@ -532,10 +544,10 @@ struct AudioTrack
         return {start_sample, end_sample};
     }
 
-    bool trim_silence_bang(float threshold_db = -60.0f, unsigned int frame_length = 2048, unsigned int hop_length = 512)
+    AudioTrack &trim_silence_bang(float threshold_db = -60.0f, unsigned int frame_length = 2048, unsigned int hop_length = 512)
     {
         if (samples.empty())
-            return false;
+            return *this;
 
         std::vector<unsigned long long> bounds = silence_bounds(threshold_db, frame_length, hop_length);
         unsigned long long start_sample = bounds[0];
@@ -545,14 +557,14 @@ struct AudioTrack
 
         // No-op checks
         if (start_sample == 0 && end_sample >= per_channel_samples)
-            return false;
+            return *this;
 
         // If the file is entirely silent, clear everything
         if (start_sample == 0 && end_sample == 0)
         {
             samples.clear();
             sample_count = 0;
-            return true;
+            return *this;
         }
 
         // Slice the interleaved sample array
@@ -563,17 +575,17 @@ struct AudioTrack
         samples = std::move(trimmed_samples);
         sample_count = samples.size();
 
-        return true;
+        return *this;
     }
 
-    bool normalize_bang(float target_db = -1.0f)
+    AudioTrack &normalize_bang(float target_db = -1.0f)
     {
         if (samples.empty())
-            return false;
+            return *this;
 
         float current_peak = peak_amplitude();
         if (current_peak <= 0.0f)
-            return false; // silent track, nothing to scale
+            return *this; // silent track, nothing to scale
 
         // convert target dB to a linear multiplier
         float target_linear = std::pow(10.0f, target_db / 20.0f);
@@ -581,20 +593,20 @@ struct AudioTrack
 
         // already at the target peak -- do nothing
         if (std::abs(scale_factor - 1.0f) < 1e-5f)
-            return false;
+            return *this;
 
         for (auto &sample : samples)
         {
             sample *= scale_factor;
         }
 
-        return true;
+        return *this;
     }
 
-    bool fade_in_bang(float duration_sec)
+    AudioTrack &fade_in_bang(float duration_sec)
     {
         if (samples.empty() || duration_sec <= 0.0f)
-            return false;
+            return *this;
 
         unsigned long long fade_frames = (unsigned long long)(duration_sec * sample_rate);
         unsigned long long total_frames = sample_count / channels;
@@ -611,13 +623,13 @@ struct AudioTrack
                 samples[i * channels + c] *= multiplier;
             }
         }
-        return true;
+        return *this;
     }
 
-    bool fade_out_bang(float duration_sec)
+    AudioTrack &fade_out_bang(float duration_sec)
     {
         if (samples.empty() || duration_sec <= 0.0f)
-            return false;
+            return *this;
 
         unsigned long long fade_frames = (unsigned long long)(duration_sec * sample_rate);
         unsigned long long total_frames = sample_count / channels;
@@ -636,13 +648,13 @@ struct AudioTrack
                 samples[frame_idx * channels + c] *= multiplier;
             }
         }
-        return true;
+        return *this;
     }
 
-    bool pad_bang(float head_sec = 0.0f, float tail_sec = 0.0f)
+    AudioTrack &pad_bang(float head_sec = 0.0f, float tail_sec = 0.0f)
     {
         if (head_sec <= 0.0f && tail_sec <= 0.0f)
-            return false;
+            return *this;
 
         unsigned long long head_frames = (unsigned long long)(head_sec * sample_rate);
         unsigned long long tail_frames = (unsigned long long)(tail_sec * sample_rate);
@@ -664,20 +676,20 @@ struct AudioTrack
 
         sample_count = samples.size();
 
-        return true;
+        return *this;
     }
 
-    bool pad_to_duration_bang(float target_duration_sec)
+    AudioTrack &pad_to_duration_bang(float target_duration_sec)
     {
         if (target_duration_sec <= 0.0f)
-            return false;
+            return *this;
 
         unsigned long long current_frames = sample_count / channels;
         unsigned long long target_frames = (unsigned long long)(target_duration_sec * sample_rate);
 
         // track is already long enough, do nothing
         if (target_frames <= current_frames)
-            return false;
+            return *this;
 
         unsigned long long diff_frames = target_frames - current_frames;
 
@@ -702,7 +714,66 @@ struct AudioTrack
 
         sample_count = samples.size();
 
-        return true;
+        return *this;
+    }
+
+    AudioTrack &add_wave_bang(std::string wave_type, float frequency, float duration_sec, float start_sec = -1.0f, float amplitude = 1.0f)
+    {
+        if (duration_sec <= 0.0f)
+            return *this;
+
+        // If no start time is provided (-1.0), append to the very end of the track
+        if (start_sec < 0.0f)
+        {
+            start_sec = duration();
+        }
+
+        unsigned long long start_sample = (unsigned long long)(start_sec * sample_rate);
+        unsigned long long wave_samples = (unsigned long long)(duration_sec * sample_rate);
+        unsigned long long end_sample = start_sample + wave_samples;
+
+        // Dynamically grow the track if this wave pushes past the current end
+        unsigned long long required_samples = end_sample * channels;
+        if (required_samples > samples.size())
+        {
+            samples.resize(required_samples, 0.0f);
+            sample_count = samples.size();
+        }
+
+        // Generate and MIX the wave
+        for (unsigned long long i = 0; i < wave_samples; ++i)
+        {
+            float t = (float)i / sample_rate; // Time in seconds
+            float sample_val = 0.0f;
+
+            if (wave_type == "sine")
+            {
+                sample_val = std::sin(2.0f * M_PI * frequency * t);
+            }
+            else if (wave_type == "square")
+            {
+                sample_val = std::sin(2.0f * M_PI * frequency * t) >= 0.0f ? 1.0f : -1.0f;
+            }
+            else if (wave_type == "sawtooth")
+            {
+                sample_val = 2.0f * std::fmod(t * frequency, 1.0f) - 1.0f;
+            }
+            else if (wave_type == "noise")
+            {
+                sample_val = ((float)std::rand() / RAND_MAX) * 2.0f - 1.0f;
+            }
+
+            sample_val *= amplitude;
+
+            // Mix into all channels at the correct offset
+            unsigned long long current_idx = start_sample + i;
+            for (int c = 0; c < channels; ++c)
+            {
+                samples[current_idx * channels + c] += sample_val;
+            }
+        }
+
+        return *this;
     }
 
     std::string to_s()
@@ -727,7 +798,7 @@ extern "C"
     Module rb_mRubyDSP = define_module("RubyDSP");
     Data_Type<AudioTrack> rb_cAudioTrack = define_class_under<AudioTrack>(rb_mRubyDSP, "AudioTrack")
                                                .define_constructor(Constructor<AudioTrack, std::string, unsigned int, unsigned int>(),
-                                                                   Arg("file_name") = (std::string) "default.wav",
+                                                                   Arg("file_name") = (std::string) "",
                                                                    Arg("target_channels") = (unsigned int)0,
                                                                    Arg("target_sample_rate") = (unsigned int)0)
                                                // attributes
@@ -773,5 +844,11 @@ extern "C"
                                                               Arg("tail_sec") = 0.0f)
                                                .define_method("pad_to_duration!", &AudioTrack::pad_to_duration_bang,
                                                               Arg("target_duration_sec"))
+                                               .define_method("add_wave!", &AudioTrack::add_wave_bang,
+                                                              Arg("wave_type"),
+                                                              Arg("frequency"),
+                                                              Arg("duration_sec"),
+                                                              Arg("start_sec") = -1.0f,
+                                                              Arg("amplitude") = 1.0f)
                                                .define_method("to_s", &AudioTrack::to_s);
 }

data/lib/ruby_dsp/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RubyDSP
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/ruby_dsp.gemspec

@@ -5,8 +5,8 @@ require_relative 'lib/ruby_dsp/version'
 Gem::Specification.new do |s|
   s.name        = 'ruby_dsp'
   s.version     = RubyDSP::VERSION
-  s.summary     = 'A fast, zero-dependency audio/DSP gem (WIP hobby project) using C++.'
-  s.description = 'RubyDSP is a hobby project exploring C++ extensions via Rice to bring faster audio processing to Ruby. Powered by miniaudio, it features a zero-dependency build and supports basic format-agnostic loading (WAV, MP3, FLAC), WAV export, and time-domain manipulation (resampling, padding, fades, RMS). It is very much in early development, so expect API changes and absolutely no warranties!' # rubocop:disable Layout/LineLength
+  s.summary     = 'A fast, zero-dependency audio processing and synthesis hobby gem built on Rice and miniaudio (C++).'
+  s.description = 'RubyDSP is a small gem for rudimentary audio processing, DSP, and synthesis. It aims to have basically zero dependencies (AND WARRANTIES)! See Documentation for more.' # rubocop:disable Layout/LineLength
   s.authors     = ['Radek C.']
   s.email       = 'cichrrad@cvut.cz'
   s.homepage    = 'https://github.com/cichrrad/rubyDSP'

data/stubs/ruby_dsp/audio_track.rb

@@ -21,13 +21,16 @@ module RubyDSP
     # @return [Integer] number of samples in `samples`
     attr_reader :sample_count
 
-    # Initializes a new AudioTrack and decodes the given file.
+    # Initializes a new AudioTrack.
     #
-    # @param file_name [String] Path to the audio file.
-    # @param target_channels [Integer] Optional. Force a specific number of channels (0 = original).
-    # @param target_sample_rate [Integer] Optional. Force a specific sample rate (0 = original).
-    # @raise [RuntimeError] if the file cannot be processed or read.
-    def initialize(file_name = 'default.wav', target_channels = 0, target_sample_rate = 0)
+    # Decodes the given file using miniaudio. If `file_name` is an empty string `""`,
+    # it initializes an empty, blank audio canvas for synthesis and sequencing.
+    #
+    # @param file_name [String] Path to the audio file, or `""` for a blank track.
+    # @param target_channels [Integer] Optional. Force a specific number of channels (Defaults to 1 for blank tracks).
+    # @param target_sample_rate [Integer] Optional. Force a specific sample rate (Defaults to 44100 for blank tracks).
+    # @raise [RuntimeError] if a file is provided but cannot be processed or read.
+    def initialize(file_name = '', target_channels = 0, target_sample_rate = 0)
     end
 
     # Saves the audio track to disk.
@@ -68,7 +71,7 @@ module RubyDSP
 
     # Destructively converts the track to mono by averaging the channels.
     #
-    # @return [Boolean] true if conversion happened, false if already mono.
+    # @return [AudioTrack] self for method chaining.
     # @raise [RuntimeError] if channel count is invalid.
     def to_mono!
     end
@@ -76,7 +79,7 @@ module RubyDSP
     # Destructively resamples the track to the target rate using linear resampling.
     #
     # @param target_rate [Integer] The new sample rate in Hz.
-    # @return [Boolean] true if resampling happened, false if the rate was unchanged.
+    # @return [AudioTrack] self for method chaining.
     # @raise [RuntimeError] if the resampler fails to initialize or process.
     def resample!(target_rate = 0)
     end
@@ -126,42 +129,56 @@ module RubyDSP
     # @param threshold_db [Float] The threshold in decibels below the peak RMS to consider as silence. Default is -60.0.
     # @param frame_length [Integer] The number of samples per frame. Default is 2048.
     # @param hop_length [Integer] The number of samples to advance each frame. Default is 512.
-    # @return [Boolean] true if the track was trimmed, false if no trimming occurred.
+    # @return [AudioTrack] self for method chaining.
     def trim_silence!(threshold_db = -60.0, frame_length = 2048, hop_length = 512)
     end
 
     # Normalizes the audio track to a specific peak decibel level.
     # @param target_db [Float] The target peak amplitude in dBFS. Defaults to -10.0.
-    # @return [Boolean] true if the track was altered, false if it was already at the target or silent.
+    # @return [AudioTrack] self for method chaining.
     def normalize!(target_db = -10.0)
     end
 
     # Applies a linear fade-in to the beginning of the audio track.
     # @param duration_sec [Float] The length of the fade-in in seconds.
-    # @return [Boolean] true if the fade was applied, false if the track is empty or duration is <= 0.
+    # @return [AudioTrack] self for method chaining.
     def fade_in!(duration_sec)
     end
 
     # Applies a linear fade-out to the end of the audio track.
     # @param duration_sec [Float] The length of the fade-out in seconds.
-    # @return [Boolean] true if the fade was applied, false if the track is empty or duration is <= 0.
+    # @return [AudioTrack] self for method chaining.
     def fade_out!(duration_sec)
     end
 
     # Pads the audio track with digital silence (0.0) at the beginning and/or end.
     # @param head_sec [Float] Seconds of silence to add to the beginning. Defaults to 0.0.
     # @param tail_sec [Float] Seconds of silence to add to the end. Defaults to 0.0.
-    # @return [Boolean] true if padding was added, false otherwise.
+    # @return [AudioTrack] self for method chaining.
     def pad!(head_sec = 0.0, tail_sec = 0.0)
     end
 
     # Pads the audio track with digital silence so that it reaches an exact target duration.
     # The padding is distributed evenly to both the head and the tail, effectively centering the audio.
     # @param target_duration_sec [Float] The desired total length of the track in seconds.
-    # @return [Boolean] true if padding was added, false if the track is already longer than the target.
+    # @return [AudioTrack] self for method chaining.
     def pad_to_duration!(target_duration_sec)
     end
 
+    # Generates and mixes a mathematical waveform into the track.
+    #
+    # Dynamically resizes the track if the wave extends past the current duration.
+    # If a wave overlaps with existing audio data, it is mixed (added) together, allowing for polyphony.
+    #
+    # @param wave_type [String] The shape of the waveform (`"sine"`, `"square"`, `"sawtooth"`, `"noise"`).
+    # @param frequency [Float] The frequency of the wave in Hz (e.g., 440.0).
+    # @param duration_sec [Float] The length of the generated wave in seconds.
+    # @param start_sec [Float] The timestamp in seconds to start the wave. Defaults to -1.0 (appends to the end).
+    # @param amplitude [Float] The peak amplitude of the wave. Defaults to 1.0.
+    # @return [AudioTrack] self for method chaining.
+    def add_wave!(wave_type, frequency, duration_sec, start_sec = -1.0, amplitude = 1.0)
+    end
+
     # @return [String] a formatted summary of the track.
     def to_s
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_dsp
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Radek C.
@@ -135,11 +135,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: RubyDSP is a hobby project exploring C++ extensions via Rice to bring
-  faster audio processing to Ruby. Powered by miniaudio, it features a zero-dependency
-  build and supports basic format-agnostic loading (WAV, MP3, FLAC), WAV export, and
-  time-domain manipulation (resampling, padding, fades, RMS). It is very much in early
-  development, so expect API changes and absolutely no warranties!
+description: RubyDSP is a small gem for rudimentary audio processing, DSP, and synthesis.
+  It aims to have basically zero dependencies (AND WARRANTIES)! See Documentation
+  for more.
 email: cichrrad@cvut.cz
 executables: []
 extensions:
@@ -179,5 +177,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.3
 specification_version: 4
-summary: A fast, zero-dependency audio/DSP gem (WIP hobby project) using C++.
+summary: A fast, zero-dependency audio processing and synthesis hobby gem built on
+  Rice and miniaudio (C++).
 test_files: []