kuromusic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6bfa0bd38071a7eff140febd8dd6ecd0b306d36
+  data.tar.gz: a56453eb5f4890ded06656a5951d0efc8f053ce4
+SHA512:
+  metadata.gz: 66ba15156b082ecf6a7e34e06d7086764d61efe202eea111a6e0b7781790cbbeec82aba8678db014268933da90acc40508af64579bab8899cb55e6c686903b71
+  data.tar.gz: 99f38c4b27bfd4054f2ea1ced1feb5b4ec7f2c9fb3c5d393f786bda7bd6a3f9e008b775ad45e1e43d32a7f3994d618b88578c85274a5a73643130cf95c98c100

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kuromusic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 黒澤 預生
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# KuroMusic
+
+KuroMusic is midi controll library writed by ruby.
+
+##version
+0.0.1
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kuromusic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kuromusic
+
+## Usage
+
+you should require KuroMusic in your source code to use those method.
+```ruby:
+require "KuroMusic"
+```
+
+###generate melody automaticaly
+```ruby:
+DELTA_TIME = 480
+midi = Midi.new(DELTA_TIME, 2)
+melo = MelodyGenerater.new(DELTA_TIME, Scale::MAJOR).extend(MelodyGenerater::Rand)
+midi.tracks[0] = melo.cantus(10)
+midi.tracks[1] = melo.base(10)
+```
+
+###write midi file
+```ruby:
+Midi::IO.write("hoge3.mid", midi)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/kuromusic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/kuromusic.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kuromusic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kuromusic"
+  spec.version       = Kuromusic::VERSION
+  spec.authors       = ["黒澤 預生"]
+  spec.email         = ["yonamachan3@gmail.com"]
+  spec.summary       = %q{KuroMusic is midi controll library writed by ruby.}
+  spec.description   = %q{KuroMusic is midi controll library writed by ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/kuromusic/ChordProgressionGenerator.rb

@@ -0,0 +1,5 @@
+class ChordProgression
+  private
+    LERDAHF_MAP = [
+      'D#', 'F'
+    ]

data/lib/kuromusic/Event/EventType.rb

@@ -0,0 +1,17 @@
+class Event
+  module EventType
+    NULL = nil
+    NOTE = :NOTE
+    META = :META
+    module Note
+      NULL = nil
+      ON = :ON
+      OFF = :OFF
+      REST = :REST
+    end
+    module Meta
+      NULL = nil
+      SET_TEMPO = :SET_TEMPO
+    end
+  end
+end

data/lib/kuromusic/Event/MetaEvent.rb

@@ -0,0 +1,11 @@
+class Event
+  module Meta extend self
+    def set_tempo(bpm)
+      Event.new({
+        :type => EventType::META,
+        :method => EventType::Meta::SET_TEMPO,
+        :tempo => bpm
+      })
+    end
+  end
+end

data/lib/kuromusic/Event/NoteEvent.rb

@@ -0,0 +1,28 @@
+class Event
+  module Note extend self
+    def on(note, octave, velocity)
+      Event.new({
+        :type => EventType::NOTE,
+        :method => EventType::Note::ON,
+        :note => note,
+        :octave => octave,
+        :velocity => velocity
+      })
+    end
+    def off(note, octave)
+      Event.new({
+        :type => EventType::NOTE,
+        :method => EventType::Note::OFF,
+        :note => note,
+        :octave => octave
+      })
+    end
+    def rest(dur)
+      Event.new({
+        :type => EventType::NOTE,
+        :method => EventType::Note::REST,
+        :dur => dur
+      })
+    end
+  end
+end

data/lib/kuromusic/Event.rb

@@ -0,0 +1,11 @@
+require_relative "Event/EventType"
+require_relative "Event/NoteEvent"
+require_relative "Event/MetaEvent"
+
+class Event
+  attr_reader :args
+  private
+    def initialize(args)
+      @args = args
+    end
+end

data/lib/kuromusic/Generator/Random.rb

@@ -0,0 +1,53 @@
+class MelodyGenerater
+  module Rand
+    private
+      def fiber(octave, notes, num)
+        Fiber.new do |dur, velocity|
+          while true do
+            ons = (0..(num-1)).to_a.map{|item|
+              note = notes.sample
+              [Event::Note::rest(0), Event::Note::on(note, octave, velocity)]
+            }
+            offs = ons.each_with_index.map{|item, i|
+              if i == 0
+                [Event::Note::rest(dur), Event::Note::off(item[1].args[:note], octave)]
+              else
+                [Event::Note::rest(0), Event::Note::off(item[1].args[:note], octave)]
+              end
+            }
+            dur, velocity = Fiber.yield [ons, offs].flatten
+          end
+        end
+      end
+
+      def common(length, octave, _note_times, notes)
+        events = []
+        f = fiber(octave, notes, 2)
+        length.times {|i|
+          note_times = _note_times[0..(_note_times.length - 1)]
+          dur = note_times.sample
+          events.concat f.resume(dur, 100)
+          _sub = @measure - dur
+          note_times.reverse.each_with_index {|t, i|
+            times = note_times[0..(note_times.length - 1 - i)]
+            while _sub >= t do
+              dur = times.sample
+              events.concat f.resume(dur, 100)
+              _sub = _sub - dur
+            end
+          }
+        }
+        events
+      end
+
+    public
+      def base(length)
+        octave = 2
+        Track.new(common(length, octave, @note_times[4..5], @scale))
+      end
+      def cantus(length)
+        octave = 4
+        Track.new(common(length, octave, @note_times[1..3], @scale))
+      end
+  end
+end

data/lib/kuromusic/Generator/Schenker.rb

@@ -0,0 +1,63 @@
+class MelodyGenerater
+  module Schenker
+    MIDDLE = [7, 5, 4, 2, 2, 0]
+    BACK = [0, 5, 7, 0]
+
+    private
+      def fiber(octave, notes, num)
+        Fiber.new do |dur, velocity|
+          while true do
+            notes.each{|n|
+              ons = (0..(num-1)).to_a.map{|item|
+                _n = n + (2 * item)
+                octave = octave + _n / 12
+                number = _n % 12
+                note = Scale::number_to_code(number)
+                [Event::Note::rest(0), Event::Note::on(note, octave, velocity)]
+              }
+              offs = ons.each_with_index.map{|item, i|
+                if i == 0
+                  [Event::Note::rest(dur), Event::Note::off(item[1].args[:note], octave)]
+                else
+                  [Event::Note::rest(0), Event::Note::off(item[1].args[:note], octave)]
+                end
+              }
+              dur, velocity = Fiber.yield [ons, offs].flatten
+            }
+          end
+        end
+      end
+
+      def common(length, octave, _note_times, notes)
+        events = []
+        f = fiber(octave, notes, 2)
+        length.times {|i|
+          note_times = _note_times[0..(_note_times.length - 1)]
+          dur = note_times.sample
+          events.concat f.resume(dur, 100)
+          _sub = @measure - dur
+          note_times.reverse.each_with_index {|t, i|
+            times = note_times[0..(note_times.length - 1 - i)]
+            while _sub >= t do
+              note = @scale.sample
+              dur = times.sample
+              events.concat [Event::Note::rest(0), Event::Note::on(note, octave, 100), Event::Note::rest(dur), Event::Note::off(note, octave)]
+              _sub = _sub - dur
+            end
+          }
+        }
+        events
+      end
+
+    public
+      def base(length)
+        octave = 2
+        Track.new(common(length, octave, @note_times[4..5], BACK))
+      end
+
+      def cantus(length)
+        octave = 4
+        Track.new(common(length, octave, @note_times[2..3], MIDDLE))
+      end
+    end
+end

data/lib/kuromusic/IO/MIDI/MidiEvent.rb

@@ -0,0 +1,43 @@
+class Midi
+  private
+  module MidiEvent
+    private
+      def var_len n
+        n < 0x80 ? [n] : [(n>>7|0x80), n % 0x80]
+      end
+
+      def note_to_bin()
+        case @args[:method]
+        when Event::EventType::Note::REST
+          dur = var_len(@args[:dur])
+          return dur
+        when Event::EventType::Note::OFF
+          note_num = NOTE[@args[:note]] + @args[:octave] * OCTAVE_UNIT
+          return [0x80, note_num, 0]
+        when Event::EventType::Note::ON
+          note_num = NOTE[@args[:note]] + @args[:octave] * OCTAVE_UNIT
+          return [0x90, note_num, @args[:velocity]]
+        end
+      end
+
+      def meta_to_bin()
+        case @args[:method]
+        when Event::EventType::Meta::SET_TEMPO
+          tempo = 60000000 / @args[:tempo]
+          return [0, 0xff, 0x51, 0x03, tempo >> 16, tempo >> 8, tempo % 256]
+        end
+      end
+
+    public
+      NOTE = {"C"=>0, "C#"=>1, "D"=>2, "D#"=>3, "E"=>4, "F"=>5, "F#"=>6, "G"=>7, "G#"=>8, "A"=>9, "A#"=>10, "B"=>11}
+      OCTAVE_UNIT = 12
+
+      def to_bin()
+        if @args[:type] == Event::EventType::NOTE
+          return note_to_bin
+        elsif @args[:type] == Event::EventType::META
+          return meta_to_bin
+        end
+      end
+  end
+end

data/lib/kuromusic/IO/MIDI/MidiTrack.rb

@@ -0,0 +1,14 @@
+class Midi
+  private
+    module MidiTrack
+      def to_bin()
+        track = []
+        @events.each {|e|
+          e.extend(MidiEvent)
+          track.concat e.to_bin
+        }
+        tl = track.concat([0, 0xff, 0x02, 0]).size
+        result = [0x4d, 0x54, 0x72, 0x6b, tl >> 24, tl >> 16, tl >> 8, tl % 256].concat track
+      end
+    end
+end

data/lib/kuromusic/IO/MIDI.rb

@@ -0,0 +1,29 @@
+require_relative "MIDI/MidiEvent"
+require_relative "MIDI/MidiTrack"
+
+class Midi
+  module IO
+    public
+    def self.load(input_path)
+      tempo = 120
+      Midi.new(tempo)
+    end
+    def self.write(output_path, midi)
+      File.open(output_path, "wb") do |file|
+        track_num = midi.tracks.length
+        dtime = midi.dtime
+        file.write [0x4d, 0x54, 0x68, 0x64, 0, 0, 0, 6, 0, 1, track_num >> 8, track_num % 256, dtime >> 8, dtime % 256].pack('C*')
+        midi.tracks.each {|track|
+          track.extend(MidiTrack)
+          m = track.to_bin
+          track.each {|e|
+            #[e.args[:type], e.args[:method], e.args[:note], e.args[:octave], e.args[:dur], e.args[:velocity]]
+            p e.args
+          }
+          #p m
+          file.write m.pack('C*')
+        }
+      end
+    end
+  end
+end

data/lib/kuromusic/Key.rb

@@ -0,0 +1,3 @@
+class Key
+  
+end

data/lib/kuromusic/MIDI.rb

@@ -0,0 +1,16 @@
+require_relative "IO/MIDI.rb"
+require_relative "Track"
+
+class Midi
+  attr_reader :tracks, :dtime
+
+  def initialize()
+    @tracks = []
+    @dtime = 480
+  end
+
+  def initialize(dtime, track_num)
+    @tracks = Array.new(track_num, Track.new([]))
+    @dtime = dtime
+  end
+end

data/lib/kuromusic/MelodyGenerater.rb

@@ -0,0 +1,16 @@
+require_relative "Event"
+require_relative "Track"
+
+require_relative "Generator/Random"
+require_relative "Generator/Schenker"
+
+class MelodyGenerater
+  def initialize(dtime, scale, chord, key = nil)
+    @chord = chord
+    @dtime = dtime
+    @note_times = [dtime/8, dtime/4, dtime/2, dtime, dtime*2, dtime*4]
+    @scale = scale
+    @key = key
+    @measure = dtime * 4
+  end
+end

data/lib/kuromusic/Object.rb

@@ -0,0 +1,6 @@
+class Object
+  def error_puts(name, message)
+    STDERR.puts caller[1] + ": " + message + " for " + self.to_s + " (" + name + ")"
+    exit(1)
+  end
+end

data/lib/kuromusic/Scale.rb

@@ -0,0 +1,20 @@
+module Scale extend self
+  MAJOR = ["C", "D", "E", "F", "G", "A", "B"]
+  MINOR = ["C", "D", "D#", "F", "G", "G#", "B"]
+  PENTATONIC = ["C", "D", "E", "G", "A"]
+  WHOLE_TONE = ["C", "D", "E", "F#", "G#", "A#"]
+  OKINAWA = ["C", "E", "F", "G", "B"]
+  INDIAN = ["C", "C#", "E", "F#", "G", "A", "B"]
+  GYPSY = ["C", "C#", "E", "F", "G", "G#", "B"]
+  KUMOI = ["C", "D", "D#", "G", "A"]
+
+  def note_to_n(note)
+    map = {"C"=>0, "C#"=>1, "D"=>2, "D#"=>3, "E"=>4, "F"=>5, "F#"=>6, "G"=>7, "G#"=>8, "A"=>9, "A#"=>10, "B"=>11}
+    map[note]
+  end
+
+  def number_to_code(number)
+    map = {0=>"C", 1=>"C#", 2=>"D", 3=>"D#", 4=>"E", 5=>"F", 6=>"F#", 7=>"G", 8=>"G#", 9=>"A", 10=>"A#", 11=>"B"}
+    map[number]
+  end
+end

data/lib/kuromusic/Track.rb

@@ -0,0 +1,85 @@
+require_relative "Object"
+
+class Track < Object
+  def initialize(events = [])
+    @events = events
+  end
+
+  def [](index)
+    @events[index]
+  end
+
+  def []=(index, obj)
+    if obj.class.to_s == "Event"
+      @events[index] = obj
+    else
+      self.error_puts("ArgumentTypeError", "undefined method `+'")
+    end
+  end
+
+  def insert(index, *objs)
+    objs.each {|e|
+      if e.class.to_s != "Event"
+        self.error_puts("ArgumentTypeError", "undefined method `+'")
+      end
+    }
+    @events.insert(index, *objs)
+  end
+
+  def push(obj)
+    if obj.class.to_s == "Event"
+      @events.push(obj)
+    else
+      self.error_puts("ArgumentTypeError", "undefined method `+'")
+    end
+    self
+  end
+
+  def unshift(obj)
+    if obj.class.to_s == "Event"
+      @events.unshift(obj)
+    else
+      self.error_puts("ArgumentTypeError", "undefined method `+'")
+    end
+    self
+  end
+
+  def each()
+    @events.each {|e|
+      yield(e)
+    }
+  end
+
+  def each_with_index()
+    @events.each {|e|
+      yield(e)
+    }
+  end
+
+  def map()
+    result = @events.map {|e|
+      yield(e)
+    }
+    Track.new(result)
+  end
+
+  def map!()
+    @events.map! {|e|
+      yield(e)
+    }
+  end
+
+  def +(other)
+    tmp = []
+    if other.class.to_s == "Track"
+      tmp.push(@events)
+      other.each{|e|
+        tmp.push(e)
+      }
+      tmp.flatten!
+    else
+      self.error_puts("ArgumentTypeError", "undefined method `+'")
+    end
+    Track.new(tmp)
+  end
+end

data/lib/kuromusic/version.rb

@@ -0,0 +1,3 @@
+module Kuromusic
+  VERSION = "0.0.1"
+end

data/lib/kuromusic.rb

@@ -0,0 +1,4 @@
+require "kuromusic/version"
+require_relative "kuromusic/MIDI"
+require_relative "kuromusic/Scale"
+require_relative "kuromusic/MelodyGenerater"

data/lib/sample/main.rb

@@ -0,0 +1,17 @@
+require_relative "../KuroMusic"
+
+DELTA_TIME = 480
+midi = Midi.new(DELTA_TIME, 2)
+melo = MelodyGenerater.new(DELTA_TIME, Scale::MAJOR, []).extend(MelodyGenerater::Schenker)
+
+a_can = melo.cantus(5).unshift(Event::Meta::set_tempo(171))
+b_can = melo.cantus(5)#.unshift(Event::Meta::set_tempo(140))
+s_can = melo.cantus(10)#.unshift(Event::Meta::set_tempo(190))
+
+a_bas = melo.base(5).unshift(Event::Meta::set_tempo(171))
+b_bas = melo.base(5)#.unshift(Event::Meta::set_tempo(140))
+s_bas = melo.base(10)#.unshift(Event::Meta::set_tempo(190))
+
+midi.tracks[0] = a_can + b_can + s_can + a_can + b_can + s_can + a_can
+midi.tracks[1] = a_bas + b_bas + s_bas + a_bas + b_bas + s_bas + a_bas
+Midi::IO.write("../../hoge3.mid", midi)

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: kuromusic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- "黒澤 預生"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: KuroMusic is midi controll library writed by ruby.
+email:
+- yonamachan3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kuromusic.gemspec
+- lib/kuromusic.rb
+- lib/kuromusic/ChordProgressionGenerator.rb
+- lib/kuromusic/Event.rb
+- lib/kuromusic/Event/EventType.rb
+- lib/kuromusic/Event/MetaEvent.rb
+- lib/kuromusic/Event/NoteEvent.rb
+- lib/kuromusic/Generator/Random.rb
+- lib/kuromusic/Generator/Schenker.rb
+- lib/kuromusic/IO/MIDI.rb
+- lib/kuromusic/IO/MIDI/MidiEvent.rb
+- lib/kuromusic/IO/MIDI/MidiTrack.rb
+- lib/kuromusic/Key.rb
+- lib/kuromusic/MIDI.rb
+- lib/kuromusic/MelodyGenerater.rb
+- lib/kuromusic/Object.rb
+- lib/kuromusic/Scale.rb
+- lib/kuromusic/Track.rb
+- lib/kuromusic/version.rb
+- lib/sample/main.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: KuroMusic is midi controll library writed by ruby.
+test_files: []