muse 0.0.4

data/lib/muse/config/adsr.rb

@@ -0,0 +1,9 @@
+module Muse
+  module Config
+    class << self
+      def default(input)
+        Math.cos(2* Math::PI*input).to_f
+      end
+    end
+  end
+end

data/lib/muse/config/chords.rb

@@ -0,0 +1,30 @@
+module Muse
+  module Config
+    class << self
+
+      # major
+      def _CM(options={})
+        add_to_stream chord(%w(c2 e2 g2), options)
+      end
+
+      def _FM(options={})
+        add_to_stream chord(%w(f2 a2 c3), options)
+      end
+
+      # minor
+      def _Dm(options={})
+        add_to_stream chord(%w(d2 f2 a2), options)
+      end
+
+      # dominant 7th
+      def _C7(options={})
+        add_to_stream chord(%w(c2 e2 g2 ais2), options)
+      end
+
+      def _BbM(options={})
+        add_to_stream chord(%w(ais2 d3 f3), options)
+      end
+
+    end
+  end
+end

data/lib/muse/config.rb

@@ -0,0 +1 @@
+Dir["#{File.dirname(__FILE__)}/config/*.rb"].each{|f| require f }

data/lib/muse/version.rb

@@ -0,0 +1,3 @@
+module Muse
+  VERSION = "0.0.4"
+end

data/lib/muse/wav.rb

@@ -0,0 +1,79 @@
+require 'bindata'
+
+module Muse
+  class RiffChunk < BinData::Record
+    int32be :chunk_id
+    int32le :chunk_size
+    int32be :format  
+  end
+
+  class FormatChunk < BinData::Record
+    int32be :chunk_id
+    int32le :chunk_size
+    int16le :audio_format
+    int16le :num_channels
+    int32le :sample_rate
+    int32le :byte_rate
+    int16le :block_align
+    int16le :bits_per_sample  
+  end
+
+  class DataChunk < BinData::Record
+    int32be :chunk_id
+    int32le :chunk_size  
+    array :stream do
+      int16le :left
+      int16le :right
+    end
+  end
+
+  class WavFormat < BinData::Record
+    riff_chunk   :riff_chunk
+    format_chunk :format_chunk
+    data_chunk   :data_chunk
+  end
+
+  class Wav
+    SAMPLE_RATE = 44100
+    attr :wav, :file, :sample_rate, :format_chunk, :riff_chunk, :data_chunk
+    
+    def initialize(filename)
+      @sample_rate = SAMPLE_RATE
+      @file = File.open(filename, "wb")
+
+      @riff_chunk = RiffChunk.new
+      @riff_chunk.chunk_id = "RIFF".unpack("N").first
+      @riff_chunk.format = "WAVE".unpack("N").first
+
+      @format_chunk = FormatChunk.new
+      @format_chunk.chunk_id = "fmt ".unpack("N").first
+      @format_chunk.chunk_size = 16
+      @format_chunk.audio_format = 1
+      @format_chunk.num_channels = 2
+      @format_chunk.bits_per_sample = 16
+      @format_chunk.sample_rate =  @sample_rate
+      @format_chunk.byte_rate = @format_chunk.sample_rate * @format_chunk.num_channels * @format_chunk.bits_per_sample/2
+      @format_chunk.block_align = @format_chunk.num_channels * @format_chunk.bits_per_sample/2
+      @data_chunk = DataChunk.new
+      @data_chunk.chunk_id = "data".unpack("N").first
+    end
+
+    def write(stream_data)
+      stream_data.each_with_index do |s,i|
+        @data_chunk.stream[i].left = s[0]
+        @data_chunk.stream[i].right = s[1]
+      end
+      @data_chunk.chunk_size = stream_data.length * @format_chunk.num_channels * @format_chunk.bits_per_sample/8
+      @riff_chunk.chunk_size = 36 + @data_chunk.chunk_size
+      @wav = WavFormat.new
+      @wav.riff_chunk = @riff_chunk
+      @wav.format_chunk = @format_chunk
+      @wav.data_chunk = @data_chunk
+      @wav.write(@file)
+    end
+
+    def close
+      @file.close
+    end
+  end
+end

data/lib/muse.rb

@@ -0,0 +1,149 @@
+require "muse/wav"
+require "muse/config"
+
+module Muse
+  class Song
+    attr :wav_file, :bars
+
+    def self.record(name, &block)
+      puts "Start recording song named #{name}.wav"
+      @wav_file = Wav.new(name + ".wav")
+      @bars = {}
+      puts "Processing ..."
+      instance_eval &block
+      save
+      puts "done."
+    end
+
+    class Bar
+      attr :bpm, :beats, :adsr
+      attr_accessor :stream
+      
+      NOTES = %w(_ a ais b c cis d dis e f fis g gis)
+      FREQUENCIES = {
+        :a2   => -24, :ais2 => -23, :b2   => -22,  :c3   => -21, :cis3 => -20, 
+        :d3   => -19, :dis3 => -18, :e3   => -17,  :f3   => -16, :fis3 => -15, 
+        :g3   => -14, :gis3 => -13, :a3   => -12,  :ais3 => -11, :b3   => -10, 
+        :c4   => -9,  :cis4 => -8,  :d4   => -7,   :dis4 => -6,  :e4   => -5,  
+        :f4   => -4,  :fis4 => -3,  :g4   => -2,   :gis4 => -1,  :a4   => 0,
+        :ais4 => 1,   :b4   => 2,   :c5   => 3,    :cis5 => 4,   :d5   => 5, 
+        :dis5 => 6,   :e5   => 7,   :f5   => 8,    :fis5 => 9,   :g5   => 10,   
+        :gis5 => 11,  :a5   => 12,  :ais5 => 13,   :b5   => 14,  :c6   => 15,
+        :cis6 => 16,  :d6   => 17,  :dis6 => 18,   :e6   => 19,  :f6   => 20,
+        :fis6 => 21,  :g6   => 22,  :gis6 => 23
+      }
+
+      def initialize(id, options={})
+        @bpm = options[:bpm] || 120
+        @beats = (options[:b] || 1).to_f
+        @adsr = options[:adsr] || 'default'
+        @stream = []
+      end
+
+      def notes(&block)
+        instance_eval &block
+      end    
+
+      def frequency_of(step)
+        440.0*(2**(step.to_f/12.0))
+      end
+
+      def chord(notes,options={})
+        puts "chord with #{notes}"
+        triad =[]
+        notes.each do |name|
+          if name.start_with? *NOTES
+            octave = name[name.length-1].to_i
+            note = octave > 0 ? name.chop : name
+            octave = 3 if octave == 0
+            triad << note_data(note, octave, options)
+          end
+        end
+        triad.transpose.map {|x| x.transpose.map {|y| y.reduce(:+)}}   
+      end
+
+      def note_data(note, octave=3, options={})
+        stream = []
+        if options
+          beats  = options[:b].nil?  ? (@beats || 1) : options[:b].to_f
+          volume = (options[:v].nil? ? 10 : options[:v].to_i) * 1000
+          adsr = options[:a].nil? ? @adsr : 'default'
+        else
+          beats, volume, adsr = (@beats || 1), 10000, 'default'
+        end
+        puts "[#{note}] -> beats : #{beats}, :octave : #{octave}"
+        duration = ((60 * Wav::SAMPLE_RATE * beats)/@bpm)/Wav::SAMPLE_RATE.to_f
+        note_frequency = note + octave.to_s
+        unless note == '_'
+          freq = frequency_of(FREQUENCIES[note_frequency.to_sym])
+        else
+          freq = 0
+        end      
+        (0.0..duration.to_f).step(1.0/Wav::SAMPLE_RATE) do |i|
+          x = (Config.send(adsr.to_sym,i) * volume * Math.sin(2 * Math::PI * freq * i)).to_i
+          stream << [x,x]
+        end  
+        return stream           
+      end
+
+      def truncate_stream_by(num)
+        num.times {@stream.pop}
+      end
+
+      def add_to_stream(str)
+        @stream += str
+      end
+
+      def method_missing(name, *args, &block)
+        name = name.to_s
+        if name.start_with? *NOTES   
+          if name.split('_').length > 1
+            notes = name.split('_')
+            add_to_stream chord(notes, args[0])
+          else
+            octave = name[name.length-1].to_i
+            note = octave > 0 ? name.chop : name
+            octave = 3 if octave == 0
+            add_to_stream note_data(note, octave, args[0])
+          end
+        end
+      end
+    end
+
+    private
+    class << self
+      def bar(id, options={})
+        puts "bar #{id}"
+        unless @bars[id]
+          @bars[id] = []
+        end
+        @bars[id] << Bar.new(id, options)
+        @bars[id].last
+      end
+      
+      def right_size(bars)
+        container = []
+        min_bar = bars.min_by {|x| x.stream.length}
+        bars.map do |bar|
+          bar.truncate_stream_by(bar.stream.length - min_bar.stream.length)
+          bar
+        end
+      end
+
+      def save
+        puts "Saving music file"
+        stream = []
+        @bars.each do |id, item|
+          container = []
+          item = right_size item
+          item.each do |i|
+            container << i.stream
+          end
+          stream += container.transpose.map {|x| x.transpose.map {|y| y.reduce(:+)}}   
+        end
+        @wav_file.write(stream)
+        @wav_file.close
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: muse
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Chang Sau Sheong
+- Ng Tze Yang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &2168647260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2168647260
+description: Muse is a complete music creation package including writing and up to
+  creating WAV files
+email:
+- sausheong@gmail.com
+- ngty77@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/muse/config/adsr.rb
+- lib/muse/config/chords.rb
+- lib/muse/config.rb
+- lib/muse/version.rb
+- lib/muse/wav.rb
+- lib/muse.rb
+homepage: https://github.com/sausheong/muse
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Muse is a Ruby DSL for making music
+test_files: []