zappa 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9392a71ab4fbaf850daa6ff3a3166f16ccbcb23d
-  data.tar.gz: 33ea67e02179e8afeddf795844f306a43f5a1705
+  metadata.gz: d6e03448367486a910dea3a2c86dfc92df6b044e
+  data.tar.gz: 06bdff101d6c5e26d05c82998168fdae9937a962
 SHA512:
-  metadata.gz: c262b0d9416d09bf225b10bbcbfce69e759de1b8740adeda12a588f3f0dbac1226f3be55c1995f8afcee4059999916e2c42ee2014da7e4dab56e07bb0ba953cc
-  data.tar.gz: 5d64cdb5a2334858c12f53ac8e0459f26c7e213bea352a4ea635b3f1e5e8cd063ad7c466586e65dd2af9add0671a97d35faf02e7c95ea5173e2098181e20a2e5
+  metadata.gz: 205f8539cbe777d690ef19fd22d2418b881c97e4ac8232911132eb0e203da922dcba6082cea7c0f797a0e8dac37a173a1692e1ee0071e751e9bc64ebbe06e102
+  data.tar.gz: 848718e138c6248e49be8da334c948cfd0e97735a8bcbeda45d24043fe18bdb45d4e19236c06dcd27235a59e301c4fbaea50305dbefe588f10f5dc393fefddd5

data/Gemfile

@@ -2,7 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in zappa.gemspec
 gemspec
-
-group :test do
-  gem 'rspec'
-end

data/README.md

@@ -1,4 +1,6 @@
 # Zappa
+[![Circle CI](https://circleci.com/gh/varunsrin/zappa/tree/dev.svg?style=svg)](https://circleci.com/gh/varunsrin/zappa/tree/dev)
+[![Coverage Status](https://coveralls.io/repos/varunsrin/zappa/badge.svg?branch=dev)](https://coveralls.io/r/varunsrin/zappa?branch=dev)
 
 Zappa is a high level audio manipulation library for Ruby, inspired by pydub.
 
@@ -21,9 +23,10 @@ Or install it yourself as:
     $ gem install zappa
 
 ## Usage
+At the core of Zappa is the Clip, an immutable audio unit.
 
-At the core of Zappa is the Clip, an immutable audio unit. Import a wav file
-into a clip:
+### Importing
+Import a wav file into a clip:
 
     require 'zappa'
         
@@ -33,6 +36,19 @@ into a clip:
 The clip will create a safe copy of the wav before you can edit it. Remember,
 clips are immutable so any destructive operations return a new clip.
 
+
+### Generators
+
+Alternatively, you can generate your own sounds from scratch: 
+
+    generator = Zappa::Generator.new
+    clip = generator.generate('sine', 1000, 1)
+
+This will create a 1000 Hz sine wave that is 1 second long.
+
+
+### Editing Clips
+
 You can slice clips into smaller chunks:
 
     slice_a = clip.slice(0, 1000)    # clip containing 1st second
@@ -42,9 +58,20 @@ You can also join clips:
 
     joined_clip = slice_a + slice_b  # clip containing 1st and 3rd seconds
 
+
+### Signal Processing
+
+Amplify or attenuate clips with the following syntax:
+    
+    louder_clip = joined_clip + 2
+    louder_clip = joined_clip.amplify(2)
+
+
+### Export
+
 Once you're done editing a clip, you can export it:
 
-    joined_clip.export('output.wav')
+    louder_clip.export('output.wav')
 
 That's it for now. DSP tools are coming soon!
 

data/ROADMAP.md

@@ -14,9 +14,6 @@
 0.3 - DSP - Basic
 ----------------
 - Amplify signals by DB
-- Calculate RMS
-- Calculate Max
-- Normalize
 - Phase Invert
 
 
@@ -60,3 +57,4 @@ Release - 1.0 Basic DSP Platform
 - DSP: Compressor
 - DSP: Remove Silence
 - DSP: Limiter
+- DSP: Normalize

data/lib/zappa.rb

@@ -2,3 +2,5 @@ require 'zappa/version'
 require 'zappa/clip'
 require 'zappa/wave'
 require 'zappa/errors'
+require 'zappa/processor'
+require 'zappa/generator'

data/lib/zappa/clip.rb

@@ -1,18 +1,19 @@
 require 'tempfile'
 require 'open3'
-require 'pry'
+require 'zappa/processor'
 
 module Zappa
   class Clip
     attr_accessor :wav, :cache
 
-    def initialize(wav=nil)
+    def initialize(wav = nil)
       if wav
         @wav = wav
       else
         @wav = Wave.new
       end
       @cache = nil
+      @processor = Processor.new
     end
 
     def from_file(path)
@@ -28,26 +29,49 @@ module Zappa
       end
     end
 
-    def slice(from, to)
-      slice_samples(ms_to_samples(from), ms_to_samples(to))
+    def slice(pos, len)
+      slice_samples(ms_to_samples(pos), ms_to_samples(len))
     end
 
-    def slice_samples(from, to)
-      fail 'invalid index' if from < 0 || to > @wav.sample_count
-      fail 'negative range' if from >= to
-      from *= @wav.frame_size
-      to *= @wav.frame_size
-      length = (to - from)
-      slice = @wav.data.byteslice(from, length)
+    def slice_samples(pos, len)
+      fail 'invalid index' if pos < 0 || (pos + len) > @wav.sample_count
+      slice = @wav.samples[pos, len]
       clone(slice)
     end
 
     def +(other)
-      fail 'format mismatch' unless @wav.format == other.wav.format 
-      w = Wave.new()
-      w.format = @wav.format
-      w.update_data(@wav.data + other.wav.data)
-      Clip.new(w)
+      return amplify(other) if other.class == Fixnum
+
+      if other.class == Zappa::Clip
+        fail 'format mismatch' unless @wav.format == other.wav.format
+        w = Wave.new
+        w.format = @wav.format
+        samples = []
+        samples += @wav.samples if @wav.samples
+        samples += other.wav.samples if other.wav.samples
+        w.set_samples(samples)
+        return Clip.new(w)
+      end
+
+      fail "cannot add Zappa::Clip to #{other.class}"
+    end
+
+    # Processor Wrappers
+
+    def normalize(headroom)
+      clone(@processor.normalize(@wav.samples, headroom))
+    end
+
+    def compress(ratio = 2.0, threshold = - 20.0)
+      clone(@processor.compress(@wav.samples, ratio, threshold))
+    end
+
+    def amplify(db)
+      clone(@processor.amplify(@wav.samples, db))
+    end
+
+    def invert
+      clone(@processor.invert(@wav.samples))
     end
 
     private
@@ -58,7 +82,7 @@ module Zappa
 
     def persist_cache
       tmp = Tempfile.new('zappa')
-      @cache = tmp.path 
+      @cache = tmp.path
       File.write(@cache, @wav.pack)
     end
 
@@ -70,10 +94,10 @@ module Zappa
       destination
     end
 
-    def clone(data = nil)
+    def clone(samples = nil)
       clone = Clip.new
       clone.wav = Marshal.load(Marshal.dump(@wav))
-      clone.wav.update_data(data) if data
+      clone.wav.set_samples(samples) if samples
       clone
     end
   end

data/lib/zappa/generator.rb

@@ -0,0 +1,56 @@
+module Zappa
+  class Generator
+    attr_accessor :sample_rate, :channels, :bit_depth
+
+    def initialize(sample_rate = 44_100, channels = 2, bit_depth = 16)
+      @sample_rate = sample_rate
+      @channels = channels
+      @bit_depth = bit_depth
+      @max_amplitude = ((2**bit_depth) / 2) - 1
+    end
+
+    def generate(type, frequency, length)
+      types = %w(sine square sawtooth white_noise)
+      fail "Cannot generate #{type} wave" unless types.include?(type)
+
+      samples = []
+      wave_pos = 0.0
+      wave_delta = frequency.to_f / @sample_rate.to_f
+      num_samples = (length * @sample_rate).round
+
+      num_samples.times do  |i|
+        wave_value = send(type, wave_pos)
+        abs_value = (wave_value * @max_amplitude).round
+        samples[i] = [abs_value] * @channels
+        wave_pos += wave_delta
+        wave_pos -= 1.0 if wave_pos >= 1.0
+        # TODO: - account for skips >= 2.0
+      end
+      clip_from_samples(samples)
+    end
+
+    private
+
+    def clip_from_samples(samples)
+      wave = Zappa::Wave.new
+      wave.set_samples(samples)
+      Zappa::Clip.new(wave)
+    end
+
+    def sine(position)
+      Math.sin(position * 2 * Math::PI)
+    end
+
+    def square(position)
+      position < 0.5 ? 1 : -1
+    end
+
+    def sawtooth(position)
+      2 * (position - (0.5 + position).floor)
+    end
+
+    def white_noise(_position)
+      rand(-1.0..1.0)
+    end
+  end
+end

data/lib/zappa/processor.rb

@@ -0,0 +1,62 @@
+module Zappa
+  class Processor
+    def normalize(samples, headroom)
+      fail 'headroom cannot be positive' if headroom > 0.0
+      curr_peak = max_sample(samples)
+      targ_peak = 32_768 * db_to_float(headroom)  # calculate this constants
+      ratio = (targ_peak / curr_peak)
+      mul_samples(samples, ratio)
+    end
+
+    def amplify(samples, db) # fix order
+      mul_samples(samples, db_to_float(db))
+    end
+
+    def invert(samples)
+      mul_samples(samples, -1)
+    end
+
+    def compress(samples, ratio, threshold)
+      threshold_value = 32_768 * db_to_float(threshold) # calc this somehow
+      samples.each do |f|
+        f.map! do |s|
+          if s.abs > threshold_value
+            s += (threshold_value - s) / ratio if s > 0
+            s -= (s + threshold_value) / ratio if s < 0
+          end
+          s.round
+        end
+      end
+      samples
+    end
+
+    private
+
+    def mul_samples(samples, factor)
+      samples.map { |f| mul_frame(f, factor) }
+    end
+
+    def mul_frame(frame, factor)
+      frame.map { |s| clip((s * factor).round) }
+    end
+
+    def clip(value, max = 32_768)
+      return max if value > max
+      return -max if value < (-max)
+      value
+    end
+
+    def max_sample(samples)
+      curr_max = 0
+      samples.each do |f|
+        f.each { |s| curr_max = s.abs if s.abs > curr_max }
+      end
+      curr_max
+    end
+
+    # convert db values to floats
+    def db_to_float(db)
+      10**(db / 20)
+    end
+  end
+end

data/lib/zappa/version.rb

@@ -1,3 +1,3 @@
 module Zappa
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/zappa/wave.rb

@@ -1,21 +1,22 @@
 require 'zappa/wave/format'
 require 'zappa/wave/riff_header'
-require 'zappa/wave/sub_chunk'
+require 'zappa/wave/sub_chunk_header'
+require 'zappa/wave/wave_data'
 
 # WAV Spec: http://soundfile.sapp.org/doc/WaveFormat/
 
 module Zappa
   class Wave
-    attr_accessor :header, :format
+    attr_accessor :header, :format, :wave_data
 
     def initialize
       @header = RiffHeader.new
       @format = Format.new
-      @wave_data = SubChunk.new
+      @wave_data = WaveData.new
     end
 
-    def data
-      @wave_data.data
+    def samples
+      @wave_data.samples
     end
 
     def data_size
@@ -31,44 +32,62 @@ module Zappa
     end
 
     def ==(other)
-      other.data == data
-    end
-
-    def update_data(new_data)
-      @wave_data.chunk_id = 'data'
-      new_size = new_data.bytesize
-      @header.chunk_size += (new_size - @wave_data.chunk_size) 
-      @wave_data.chunk_size = new_size
-      @wave_data.data = new_data
+      other.wave_data == wave_data
     end
 
     def pack
-      pack = @header.pack + @format.pack + @wave_data.pack
+      pack = @header.pack + @format.pack
+      pack += @wave_data.chunk_id
+      pack += [@wave_data.chunk_size].pack('V')
+      pack += pack_samples(@wave_data.samples)
+      pack
     end
 
     def unpack(source)
-      begin
-        file = File.open(path_to(source), 'rb')
-      rescue
-        fail 'Unable to open WAV file'
-      else
-        data_found = false
-        @header = RiffHeader.new(file)
-        @format = Format.new(file)
-        while !data_found
-          s = SubChunk.new(file)
-          if s.chunk_id == 'data'
-            @wave_data = s
-            data_found = true
-          end
+      file = File.open(path_to(source), 'rb')
+    rescue
+      raise 'Unable to open WAV file'
+    else
+      @header = RiffHeader.new(file)
+      @format = Format.new(file)
+      while sc_header = file.read(8)
+        s = SubChunkHeader.new(sc_header)
+        if s.chunk_id == 'data'
+          unpack_samples(file)
+        else
+          file.read(s.chunk_size)
         end
       end
     end
 
-    def path_to(source)
+    def set_samples(samples)
+      samples_change = (samples.size - @wave_data.samples.size)
+      size_change = samples_change * @format.channels * 2
+      @header.chunk_size += size_change
+      @wave_data.set_samples(samples)
+    end
+
+    def path_to(source) # Private method?
       return source if source.class == String
       return source.path if source.class == File
       fail 'cannot unpack type: ' + source.class.to_s
     end
+
+    private
+
+    def pack_samples(samples)
+      pack_str = 's' * @format.channels
+      samples.map { |f| f.pack(pack_str) }.join
+    end
+
+    def unpack_samples(file)
+      samples = []
+      size = @format.bits_per_sample / 8
+      ch = @format.channels
+      while (frame_data = file.read(size * ch))
+        samples << frame_data.unpack('s' * ch)
+      end
+      @wave_data.set_samples(samples)
+    end
   end
 end

data/lib/zappa/wave/format.rb

@@ -11,7 +11,7 @@ module Zappa
         @chunk_size      = FMT_SIZE
         @audio_format    = 1
         @channels        = 2
-        @sample_rate     = 44100
+        @sample_rate     = 44_100
         @byte_rate       = 176_400
         @block_align     = 4
         @bits_per_sample = 16
@@ -46,4 +46,4 @@ module Zappa
       @bits_per_sample = data.byteslice(14..15).unpack('v').first
     end
   end
-end
+end

data/lib/zappa/wave/sub_chunk_header.rb

@@ -0,0 +1,24 @@
+module Zappa
+  class SubChunkHeader
+    attr_accessor :chunk_id, :chunk_size
+
+    def initialize(data = nil)
+      @chunk_id = nil
+      @chunk_size = 0
+      unpack(data) if data
+    end
+
+    def pack
+      @chunk_id + [@chunk_size].pack('V')
+    end
+
+    def unpack(data)
+      @chunk_id = data.byteslice(0, 4)
+      @chunk_size = data.byteslice(4, 4).unpack('V').first
+    end
+
+    def ==(other)
+      other.chunk_size == @chunk_size && other.chunk_id = @chunk_id
+    end
+  end
+end

data/lib/zappa/wave/wave_data.rb

@@ -0,0 +1,21 @@
+module Zappa
+  class WaveData
+    attr_reader :samples, :chunk_id, :chunk_size
+
+    def initialize
+      @chunk_id = 'data'
+      @chunk_size = 0
+      @samples = []
+    end
+
+    def set_samples(samples)
+      @samples = samples
+      frame_size = samples[1].size
+      @chunk_size = @samples.size * frame_size * 2
+    end
+
+    def ==(other)
+      other.chunk_size == @chunk_size && other.chunk_id == @chunk_id
+    end
+  end
+end

data/spec/clip_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 require 'tempfile'
 
 WAV_IN  = 'spec/audio/basic-5s.wav'
-WAV_IN_DATA_SIZE = 882000
+WAV_IN_DATA_SIZE = 882_000
 
 describe Zappa::Clip do
-  before :each do
+  before do
     subject.from_file(WAV_IN)
   end
 
@@ -44,10 +44,9 @@ describe Zappa::Clip do
     end
 
     it 'exports the clip correctly' do
-      subject.from_file(WAV_IN)
       export_wav = Zappa::Wave.new
       export_wav.unpack(File.open(@tmp.path, 'rb'))
-      expect(subject.wav).to eq(export_wav)
+      expect(subject.wav == export_wav).to eq(true)
     end
 
     it 'raises error for invalid path' do
@@ -59,19 +58,15 @@ describe Zappa::Clip do
 
   describe '#slice_samples' do
     before :each do
-      @slice = subject.slice_samples(4, 8)
-    end
-
-    it 'fails if the beginning is larger than the end' do
-      expect { subject.slice_samples(5,2) }.to raise_error(RuntimeError)
+      @slice = subject.slice_samples(4, 4)
     end
 
     it 'fails if the beginning is negative' do
-      expect { subject.slice_samples(-1,2) }.to raise_error(RuntimeError)
+      expect { subject.slice_samples(-1, 2) }.to raise_error(RuntimeError)
     end
 
-    it 'fails if the end is larger than the total size' do
-      expect { subject.slice_samples(WAV_IN_DATA_SIZE,WAV_IN_DATA_SIZE+1) }
+    it 'fails if the length exceeds the wave\'s length' do
+      expect { subject.slice_samples(1, WAV_IN_DATA_SIZE) }
         .to raise_error(RuntimeError)
     end
 
@@ -101,15 +96,35 @@ describe Zappa::Clip do
   end
 
   describe '#+' do
-    it 'combines the audio clips' do
-      combined = subject + subject
-      expect(combined.wav.data_size).to be(WAV_IN_DATA_SIZE * 2)
-    end
-
-    it 'fails if the wave formats are different' do
-      sub_copy =  Marshal.load(Marshal.dump(subject))
-      sub_copy.wav.format.sample_rate = 22000
-      expect { subject + sub_copy }.to raise_error(RuntimeError)
+    context 'concatenation' do
+      it 'adds two audio clips together' do
+        combined_clip = subject + subject
+        expect(combined_clip.wav.data_size).to be(WAV_IN_DATA_SIZE * 2)
+      end
+
+      it 'adds audio clip to empty clip' do
+        new_clip = Zappa::Clip.new
+        combined_clip = subject + new_clip
+        expect(combined_clip.wav.data_size).to be(WAV_IN_DATA_SIZE)
+      end
+
+      it 'fails if the wave formats are different' do
+        subject_copy =  Marshal.load(Marshal.dump(subject))
+        subject_copy.wav.format.sample_rate = 22_000
+        expect { subject + subject_copy }.to raise_error(RuntimeError)
+      end
+
+      it 'fails if added to a non-wave object' do
+        non_wave = Object.new
+        expect { subject + non_wave }.to raise_error(RuntimeError)
+      end
+    end
+
+    context 'amplification' do
+      it 'amplifies clip when added to integer' do
+        expect(subject).to receive(:amplify).with(2)
+        subject + 2
+      end
     end
   end
 end

data/spec/generator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Zappa::Generator do
+  let(:subject) { Zappa::Generator.new(44_100, 1, 16) }
+  let(:sine_path) { 'spec/audio/sine-1000hz.wav' }
+
+  describe '#generate' do
+    it 'raises an error for unknown types' do
+      expect { subject.generate('circle', 1000, 0.01) }
+        .to raise_error
+    end
+
+    it 'generates a 1000 Hz sine wave' do
+      file = File.open(sine_path, 'rb')
+      orig_wav = Zappa::Wave.new
+      orig_wav.unpack(file)
+
+      gen_clip = subject.generate('sine', 1000, 0.01)
+      expect(orig_wav).to eq(gen_clip.wav)
+    end
+
+    # generated sawtooth, square waves have slightly diff values
+    # from audacity generated waves. why?
+    pending 'generates a 1000 Hz sawtooth wave'
+    pending 'generates a 1000 Hz square wave'
+  end
+end

data/spec/processor_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Zappa::Processor do
+  let(:subject) { Zappa::Processor.new }
+  let(:samples) { [[0, -1], [24_000, -24_000]] }
+  let(:max_val) { 32_768 }
+  let(:min_val) { -32_768 }
+
+  describe '#amplify' do
+    let(:double_factor) { 6.020599913279623 } # double_factor db == 2x linear
+
+    before do
+      @amplified = subject.amplify(samples, double_factor)
+    end
+
+    it 'doubles sample values' do
+      expect(@amplified[0]).to eq(samples[0].collect { |s| s * 2 })
+    end
+
+    it 'does not let sample values go over the maximum value' do
+      expect(@amplified[1][0]).to eq(max_val)
+    end
+
+    it 'does not let sample values go under the minimum value' do
+      expect(@amplified[1][1]).to eq(min_val)
+    end
+  end
+
+  describe '#invert' do
+    it 'inverts all sample values' do
+      inverted = subject.invert(samples)
+      expect(inverted).to eq([[0, 1], [-24_000, 24_000]])
+    end
+  end
+
+  describe '#normalize' do
+    it 'normalizes all sample values' do
+      normalized = subject.normalize(samples, -0.1)
+      expect(normalized).to eq([[0, -1], [32_393, -32_393]])
+    end
+  end
+
+  describe '#compressor' do
+    before do
+      @compressed = subject.compress(samples, 4.0, -20.0)
+    end
+
+    it 'does not affect values below the threshold' do
+      expect(@compressed[0]).to eq([0, -1])
+    end
+
+    it 'affects values above the threshold according to the ratio' do
+      expect(@compressed[1]).to eq([18_819, -18_819])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,12 @@
 require 'bundler/setup'
 Bundler.setup
 
+require 'coveralls'
+Coveralls.wear!
+
 require 'zappa'
 
-RSpec.configure do |config|
+RSpec.configure do |_config|
   # config
 end
 

data/spec/wave/format_spec.rb

@@ -8,12 +8,12 @@ describe Zappa::Format do
   it 'unpacks and packs each format chunk correctly' do
     src = File.read(wav_path)
     src_fmt = src.byteslice(src_offset, fmt_size)
-    
+
     file = File.open(wav_path, 'rb')
     file.read(src_offset)
     fmt = Zappa::Format.new(file)
     pck_fmt = fmt.pack.force_encoding('UTF-8')
-    
+
     expect(src_fmt).to eq(pck_fmt)
   end
 end

data/spec/wave/riff_header_spec.rb

@@ -10,7 +10,7 @@ describe Zappa::RiffHeader do
     file = File.open(wav_path, 'rb')
     subject.unpack(file)
     pck_header = subject.pack
-    
+
     expect(src_header).to eq(pck_header)
   end
-end
+end

data/spec/wave/sub_chunk_header_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Zappa::SubChunkHeader do
+  OFFSET = 36
+
+  before :each do
+    file = File.read('spec/audio/basic-5s.wav')
+    @sc_header = file.byteslice(OFFSET, 8)
+    subject.unpack(@sc_header)
+  end
+
+  it 'unpacks subchunk data correctly' do
+    expect(subject.chunk_id).to eq('data')
+    expect(subject.chunk_size).to eq(882_000)
+  end
+
+  it 'packs subchunk data into a string' do
+    expect(subject.pack).to eq(@sc_header)
+  end
+end

data/spec/wave/wave_data_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Zappa::WaveData do
+  before :each do
+    @samples = [[7, 5], [1, 3], [4, 4]]
+    @dummy_samples = [[1, 2], [3, 4]]
+    subject.set_samples(@samples)
+  end
+
+  describe 'set samples' do
+    before :each do
+      subject.set_samples(@dummy_samples)
+    end
+
+    it 'recalculates size correctly' do
+      expect(subject.chunk_size).to eq(8)
+    end
+
+    it 'replaces existing samples with new samples' do
+      expect(subject.samples).to eq(@dummy_samples)
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal if the data is equal' do
+      d = Zappa::WaveData.new
+      d.set_samples(@samples)
+      expect(subject).to eq(d)
+    end
+
+    it 'is not equal if the data is not equal' do
+      d = Zappa::WaveData.new
+      d.set_samples(@dummy_samples)
+      expect(subject).not_to eq(d)
+    end
+  end
+end

data/spec/wave_spec.rb

@@ -4,16 +4,20 @@ require 'tempfile'
 describe Zappa::Wave do
   let(:wav_path) { 'spec/audio/basic-5s.wav' }
   let(:empty_path) { 'does-not-exist.wav' }
-  let(:wav_data_size) { 882000 }
-  let(:wav_def_fmt) { { audio_format: 1,
-                        channels: 2,
-                        sample_rate: 44_100,
-                        byte_rate: 176_400,
-                        block_align: 4,
-                        bits_per_sample: 16 } }
-  let(:wav_def_hdr) { { chunk_id: 'RIFF',
-                        chunk_size: 40,
-                        format: 'WAVE' } }
+  let(:wav_data_size) { 882_000 }
+  let(:wav_def_fmt) do
+    { audio_format: 1,
+      channels: 2,
+      sample_rate: 44_100,
+      byte_rate: 176_400,
+      block_align: 4,
+      bits_per_sample: 16 }
+  end
+  let(:wav_def_hdr) do
+    { chunk_id: 'RIFF',
+      chunk_size: 40,
+      format: 'WAVE' }
+  end
 
   before :each do
     @file = File.open(wav_path, 'rb')
@@ -26,44 +30,43 @@ describe Zappa::Wave do
       w = Zappa::Wave.new
       wav_def_hdr.each { |h| expect(h[1]).to eq(w.header.send(h[0])) }
       wav_def_fmt.each { |h| expect(h[1]).to eq(w.format.send(h[0])) }
-      expect(w.data).to eq(nil)
       expect(w.data_size).to eq(0)
+      expect(w.samples).to eq([])
     end
   end
 
-  describe '#update_data' do
-    let (:slice_length) { 4 }
-
+  describe 'unpacks and packs wave data' do
     before :each do
-      @new_data = @wav.data.byteslice(0, slice_length)
-      @wav.update_data(@new_data)
+      @packed = @wav.pack
+      @file_data = File.read(wav_path)
     end
 
-    it 'updates the wav data correctly' do
-      expect(@wav.data).to eq(@new_data)
+    it 'does not alter the format' do
+      packed_fmt = @packed.byteslice(8, 8)
+      fmt = @file_data.byteslice(8, 8)
+      expect(packed_fmt).to eq(fmt)
     end
 
-    it 'updates header data correctly' do
-      expect(@wav.header.chunk_size).to eq(40)
-      expect(@wav.data_size).to eq(slice_length)
+    it 'does not alter the wave data' do
+      packed_data = @packed.byteslice(16, wav_data_size - 16).force_encoding('UTF-8')
+      data = @file_data.byteslice(16, wav_data_size - 16)
+      expect(packed_data).to eq(data)
     end
   end
 
-  describe '#pack' do
-    it 'packs all sub-chunks into a string' do
-      expect(@wav.pack.bytesize).to eq(@file.size)
+  describe '#set_samples' do
+    let (:samples) { [[3, 1], [3, 1]] }
+
+    before :each do
+      @wav.set_samples(samples)
     end
-  end
 
-  describe '#unpack' do
-    it 'reads format headers correctly' do
-      wav_def_fmt.each do |h|  
-        expect(h[1]).to eq(@wav.format.send(h[0]))
-      end
+    it 'updates the header correctly' do
+      expect(@wav.header.chunk_size).to eq(44)
     end
 
-    it 'reads data size correctly' do
-      expect(@wav.data_size).to eq(wav_data_size)
+    it 'updates the wave data correctly' do
+      expect(@wav.samples).to eq(samples)
     end
   end
 
@@ -82,7 +85,7 @@ describe Zappa::Wave do
     end
 
     it 'is not equal to a wave with different data' do
-      @new_wave.update_data('')
+      @new_wave.set_samples([3, 1])
       expect(@wav).not_to eq(@new_wave)
     end
   end

data/zappa.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'coveralls'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zappa
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Varun Srinivasan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-20 00:00:00.000000000 Z
+date: 2015-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Zappa is a DSP toolbox for manipulating audio files.
 email:
 - varunsrin@gmail.com
@@ -85,17 +99,24 @@ files:
 - lib/zappa.rb
 - lib/zappa/clip.rb
 - lib/zappa/errors.rb
+- lib/zappa/generator.rb
+- lib/zappa/processor.rb
 - lib/zappa/version.rb
 - lib/zappa/wave.rb
 - lib/zappa/wave/format.rb
 - lib/zappa/wave/riff_header.rb
-- lib/zappa/wave/sub_chunk.rb
+- lib/zappa/wave/sub_chunk_header.rb
+- lib/zappa/wave/wave_data.rb
 - spec/audio/basic-5s.wav
+- spec/audio/sine-1000hz.wav
 - spec/clip_spec.rb
+- spec/generator_spec.rb
+- spec/processor_spec.rb
 - spec/spec_helper.rb
 - spec/wave/format_spec.rb
 - spec/wave/riff_header_spec.rb
-- spec/wave/sub_chunk_spec.rb
+- spec/wave/sub_chunk_header_spec.rb
+- spec/wave/wave_data_spec.rb
 - spec/wave_spec.rb
 - zappa.gemspec
 homepage: ''
@@ -124,9 +145,13 @@ specification_version: 4
 summary: Ruby gem for manipulating audio files.
 test_files:
 - spec/audio/basic-5s.wav
+- spec/audio/sine-1000hz.wav
 - spec/clip_spec.rb
+- spec/generator_spec.rb
+- spec/processor_spec.rb
 - spec/spec_helper.rb
 - spec/wave/format_spec.rb
 - spec/wave/riff_header_spec.rb
-- spec/wave/sub_chunk_spec.rb
+- spec/wave/sub_chunk_header_spec.rb
+- spec/wave/wave_data_spec.rb
 - spec/wave_spec.rb

data/lib/zappa/wave/sub_chunk.rb

@@ -1,29 +0,0 @@
-module Zappa
-  class SubChunk
-    attr_accessor :chunk_id, :chunk_size, :data
-
-    def initialize(file = nil)
-      if file.nil?
-        @chunk_size = 0
-        @data = nil
-      else
-        @chunk_id = file.read(4)
-        @chunk_size = file.read(4).unpack('V').first
-        @data = file.read(@chunk_size)
-      end
-    end
-
-    def update(data)
-      @chunk_size = data.bytesize
-      @data = data
-    end
-
-    def pack
-      @chunk_id + [@chunk_size].pack('V') + @data
-    end
-
-    def ==(other)
-      other.data == data && other.chunk_id = chunk_id
-    end
-  end
-end

data/spec/wave/sub_chunk_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Zappa::SubChunk do
-  OFFSET = 36
-
-  before do
-    wav_path = 'spec/audio/basic-5s.wav'
-    file = File.open(wav_path, 'rb')
-    file.read(OFFSET)
-    @pck = Zappa::SubChunk.new(file).pack
-    @src = File.read(wav_path)
-  end
-
-  it 'unpacks and packs chunk_id correctly' do
-    src_id = @src.byteslice(OFFSET, 4)
-    pck_id = @pck.byteslice(0, 4)
-    expect(src_id).to eq(pck_id)
-  end
-
-  it 'unpacks and packs data correctly' do
-    src_size = @src.byteslice(OFFSET + 4, 4).unpack('V')
-    pck_size = @pck.byteslice(4, 24).unpack('V')
-    expect(src_size).to eq(pck_size)
-
-    src_data = @src.byteslice(OFFSET + 8, src_size[0])
-    pck_data = @pck.byteslice(8, pck_size[0]).force_encoding('UTF-8')
-    expect(src_data).to eq(pck_data)
-  end
-end