midicraft 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16ace114f5cd1b7cdd6c19a11306ffc4c0cc07071928723b0dd9f1f6bcc3570c
+  data.tar.gz: 8a37bab27004fcc2e4626affa8b95c7eaa9d046ad7c0bcb90bd857b94a815b68
+SHA512:
+  metadata.gz: c4f8ba38d6a306ac82a68aa81e4fd99d3347dfec6e41571f69264dbdd7e86585aa596763b018577a643223b6cacf81fb664da8846abc8d7003b4f46f0910c23d
+  data.tar.gz: 8df895ffb4e1de6422684bac09b0d4bc36007b1310149eef5b6e8a903a0dbc78f0f0367178e08148484057941c2d353bdf2fd2ef352cbbebe60ed286ab9c5f34

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-03-07
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+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,332 @@
+# Midicraft
+
+Midicraft is a pure Ruby library for building, reading, and writing Standard MIDI Files (SMF). It provides a high-level DSL for authoring new sequences, note-name and duration helpers, and low-level event access for parsed MIDI data.
+
+## Highlights
+
+- Build new sequences with `Midicraft.build`
+- Read and write SMF format 0 and format 1
+- Use note names like `"C4"`, `:c4`, and `"Db3"` instead of raw MIDI numbers
+- Resolve durations from symbols, shorthand strings, floats, or raw ticks
+- Work with GM program names and CC names
+- Convert sequences between format 0 and format 1
+- Inspect playback time, measure positions, tempo, and time signature data
+- Swap reader/writer implementations with `reader_class` and `writer_class`
+- Parse and write note, controller, program, pitch bend, SysEx, system common, realtime, and meta events
+
+## Installation
+
+Midicraft requires Ruby 3.1 or newer.
+
+```bash
+bundle add midicraft
+```
+
+Or install it directly:
+
+```bash
+gem install midicraft
+```
+
+## Quick Start
+
+### Build a MIDI file from scratch
+
+```ruby
+require "midicraft"
+
+seq = Midicraft.build(tempo: 120, time_signature: [4, 4]) do
+  track "Melody", instrument: :acoustic_grand_piano, channel: 0 do
+    note "C4", velocity: 100, duration: :quarter
+    note "E4", velocity: 100, duration: :quarter
+    note "G4", velocity: 100, duration: :quarter
+    note "C5", velocity: 100, duration: :half
+    rest :quarter
+    chord ["C4", "E4", "G4"], velocity: 80, duration: :whole
+  end
+
+  track "Bass", instrument: :acoustic_bass, channel: 1 do
+    note "C2", velocity: 90, duration: :half
+    note "G2", velocity: 90, duration: :half
+    note "C2", velocity: 90, duration: :whole
+  end
+end
+
+seq.write("output.mid")
+```
+
+### Read and inspect an existing MIDI file
+
+`Midicraft.read` exposes imported MIDI as low-level events such as `NoteOn` and `NoteOff`.
+
+```ruby
+require "midicraft"
+
+seq = Midicraft.read("input.mid")
+
+seq.tracks.each do |track|
+  puts "Track: #{track.name || "(unnamed)"}"
+
+  track.events.grep(Midicraft::Events::NoteOn).each do |event|
+    duration = event.off ? (event.off.absolute_time - event.absolute_time) : nil
+    duration_label = duration ? duration.to_s : "open"
+
+    puts "  #{Midicraft.note_name(event.pitch)} " \
+         "ch=#{event.channel} vel=#{event.velocity} " \
+         "start=#{event.absolute_time} dur=#{duration_label}"
+  end
+end
+```
+
+### Transform authored notes non-destructively
+
+`track.notes` works on tracks that already contain `Midicraft::Events::Note` objects, such as tracks created with the DSL.
+
+```ruby
+require "midicraft"
+
+seq = Midicraft.build do
+  track "Lead", instrument: :electric_guitar_clean, channel: 0 do
+    note "C4", duration: :quarter
+    note "E4", duration: :quarter
+    note "G4", duration: :quarter
+  end
+end
+
+lead = seq.tracks.find { |track| track.name == "Lead" }
+
+edited = lead.transform do |track|
+  track.notes.transpose!(12)
+  track.notes.quantize!(:sixteenth, ppqn: seq.ppqn)
+  track.notes.velocity_scale!(0.9)
+end
+
+edited.events.each { |event| puts event }
+```
+
+## Data Model
+
+Midicraft uses two related note representations:
+
+| Workflow | Track contents | Best API |
+| --- | --- | --- |
+| Authoring with `Midicraft.build` or manual `Events::Note` objects | `Midicraft::Events::Note` | `track.notes`, `Midicraft::NoteCollection`, DSL helpers |
+| Reading an existing MIDI file with `Midicraft.read` | `Midicraft::Events::NoteOn`, `NoteOff`, and other raw events | `track.events` |
+
+Important details:
+
+- `track.notes` only returns existing `Midicraft::Events::Note` objects.
+- Imported MIDI is represented as low-level events, not automatically collapsed into `Events::Note`.
+- Parsed note pairs are linked through `NoteOn#off` and `NoteOff#on` when matching note-off events are found.
+- Track-level operations such as `quantize` work on the full event list; note-collection transforms apply only to tracks that already contain `Events::Note`.
+- `Midicraft.build` creates a format 1 sequence with a meta track at index 0 for tempo and time signature events.
+
+## DSL
+
+The builder DSL is the easiest way to author new material:
+
+```ruby
+Midicraft.build(tempo: 140, ppqn: 480, time_signature: [3, 4]) do
+  track "Lead", instrument: :electric_guitar_clean, channel: 0 do
+    note "C4", velocity: 100, duration: :quarter
+    chord ["C4", "E4", "G4"], velocity: 80, duration: :half
+    rest :quarter
+    control :volume, 100
+    control :pan, 64
+    pitch_bend 8192
+    program :electric_guitar_clean
+    repeat 4 do
+      note "C4", duration: :eighth
+    end
+    at_tick 1920 do
+      note "G4", duration: :quarter
+    end
+    at_bar 3, beat: 1 do
+      note "A4", duration: :quarter
+    end
+    velocity 60 do
+      note "B4", duration: :quarter
+    end
+  end
+end
+```
+
+Available builder methods:
+
+- `track(name = nil, instrument: nil, channel: nil)`
+- `note(pitch, velocity: 100, duration: :quarter)`
+- `chord(pitches, velocity: 100, duration: :quarter)`
+- `rest(duration)`
+- `control(number_or_name, value)`
+- `pitch_bend(value)`
+- `program(name_or_number)`
+- `repeat(count) { ... }`
+- `at_tick(tick) { ... }`
+- `at_bar(bar, beat: 1) { ... }`
+- `velocity(value) { ... }`
+
+## Duration Values
+
+Durations accept several input styles:
+
+| Type | Examples |
+| --- | --- |
+| Symbol | `:whole`, `:half`, `:quarter`, `:eighth`, `:sixteenth` |
+| Dotted symbol | `:dotted_quarter`, `:dotted_eighth` |
+| Triplet symbol | `:quarter_triplet`, `:eighth_triplet` |
+| String shorthand | `"1n"`, `"4n"`, `"8n"`, `"4n."`, `"4nt"` |
+| Integer | Raw tick value such as `480` |
+| Float | Quarter-note multiplier such as `1.0`, `0.5`, or `4.0` |
+
+You can also use sequence helpers when you need explicit conversions:
+
+```ruby
+seq.note_to_length("dotted quarter triplet") #=> 1.0
+seq.note_to_delta("eighth")                  #=> 240 when ppqn is 480
+seq.length_to_delta(0.5)                     #=> 240 when ppqn is 480
+```
+
+## Core API
+
+### Top-level helpers
+
+- `Midicraft.read(path_or_io) { |current, total| ... }`
+- `Midicraft.build(tempo: 120, ppqn: 480, time_signature: [4, 4])`
+- `Midicraft.note_number("C4")`
+- `Midicraft.note_name(60)`
+
+### `Midicraft::Sequence`
+
+Useful sequence methods include:
+
+- `tempo`, `tempo=`, `bpm`
+- `time_signature`, `time_signature=`
+- `name`, `name=`
+- `duration_ticks`, `duration_seconds`
+- `pulses_to_seconds`
+- `note_to_length`, `note_to_delta`, `length_to_delta`
+- `get_measures`
+- `to_format0`, `to_format1`
+- `write(path_or_io, running_status: false, note_off_as_note_on_zero: false, midi_format: nil)`
+
+Example:
+
+```ruby
+seq = Midicraft.build(tempo: 128) do
+  track "Piano", channel: 0 do
+    note "C4", duration: :quarter
+  end
+end
+
+puts seq.duration_seconds
+puts seq.get_measures.to_mbt(seq.tracks.last.notes.first)
+
+seq.write("format0.mid", midi_format: 0)
+```
+
+### `Midicraft::Track`
+
+Useful track methods include:
+
+- `add(event)` / `<<`
+- `remove(event)`
+- `merge(other_track_or_events)`
+- `quantize(length_or_note)` for in-place event quantization
+- `transform { |copy| ... }` for non-destructive track edits
+- `name`, `name=`
+- `instrument`, `instrument=`
+- `instrument_name`, `instrument_name=`
+- `notes`
+
+### `Midicraft::NoteCollection`
+
+`track.notes` returns a `Midicraft::NoteCollection` when the track contains `Events::Note` objects.
+
+- `transpose(n)` / `transpose!(n)`
+- `quantize(grid, ppqn: 480)` / `quantize!(grid, ppqn: 480)`
+- `velocity_scale(factor)` / `velocity_scale!(factor)`
+- `humanize(timing: 10, velocity: 10)`
+- `legato(overlap: 0)`
+- `filter { |note| ... }`
+- `in_range(low, high)`
+- `on_channel(channel)`
+
+## Notes, Frequencies, and Constants
+
+Midicraft includes helpers beyond raw SMF parsing:
+
+```ruby
+Midicraft::NoteUtil.frequency("A4")          #=> 440.0
+Midicraft::NoteUtil.from_frequency(261.63)   #=> 60
+
+Midicraft::Constants::GM.program_number(:violin)  #=> 40
+Midicraft::Constants::GM.program_name(40)         #=> :violin
+Midicraft::Constants::GM.drum_note(:closed_hi_hat)
+
+Midicraft::Constants::CC.number_for(:sustain) #=> 64
+Midicraft::Constants::CC.name_for(64)         #=> :sustain
+Midicraft::Constants::CC::VOLUME              #=> 7
+```
+
+## I/O Classes and Callbacks
+
+`Sequence#read` supports a progress block with the default reader:
+
+```ruby
+seq = Midicraft.read("input.mid") do |current, total|
+  puts "Read track #{current}/#{total}"
+end
+```
+
+For write progress callbacks, use `Midicraft::IO::SeqWriter` as the sequence writer:
+
+```ruby
+seq = Midicraft.build do
+  track "Lead", channel: 0 do
+    note "C4", duration: :quarter
+  end
+end
+
+seq.writer_class = Midicraft::IO::SeqWriter
+
+seq.write(
+  "output.mid",
+  midi_format: 0,
+  running_status: true,
+  note_off_as_note_on_zero: true
+) do |track, total, index|
+  label = track ? (track.name || "(unnamed)") : "start"
+  puts "Write #{index}/#{total}: #{label}"
+end
+```
+
+You can also replace `reader_class` or `writer_class` with compatible custom classes if you need different parsing or writing behavior.
+
+## Examples
+
+The repository includes small example scripts:
+
+- `bundle exec ruby examples/from_scratch.rb`
+- `bundle exec ruby examples/dsl_demo.rb`
+- `bundle exec ruby examples/read_and_print.rb input.mid`
+
+## Development
+
+Install dependencies and run the test suite:
+
+```bash
+bundle install
+bundle exec rake spec
+```
+
+Generate API docs with YARD:
+
+```bash
+bundle exec rake yard
+```
+
+`bundle exec rake` runs the default task, which is the spec suite.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "yard"
+require "yard/rake/yardoc_task"
+
+RSpec::Core::RakeTask.new(:spec)
+YARD::Rake::YardocTask.new(:yard)
+
+task default: :spec

data/lib/midicraft/constants/cc.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Midicraft
+  module Constants
+    module CC
+      NUMBERS = {
+        bank_select: 0,
+        modulation: 1,
+        breath_controller: 2,
+        foot_controller: 4,
+        portamento_time: 5,
+        data_entry: 6,
+        volume: 7,
+        balance: 8,
+        pan: 10,
+        expression: 11,
+        effect_control_1: 12,
+        effect_control_2: 13,
+        general_purpose_1: 16,
+        general_purpose_2: 17,
+        general_purpose_3: 18,
+        general_purpose_4: 19,
+        sustain: 64,
+        portamento: 65,
+        sostenuto: 66,
+        soft_pedal: 67,
+        legato_footswitch: 68,
+        hold_2: 69,
+        sound_variation: 70,
+        timbre: 71,
+        release_time: 72,
+        attack_time: 73,
+        brightness: 74,
+        decay_time: 75,
+        vibrato_rate: 76,
+        vibrato_depth: 77,
+        vibrato_delay: 78,
+        reverb: 91,
+        tremolo: 92,
+        chorus: 93,
+        detune: 94,
+        phaser: 95,
+        data_increment: 96,
+        data_decrement: 97,
+        nrpn_lsb: 98,
+        nrpn_msb: 99,
+        rpn_lsb: 100,
+        rpn_msb: 101,
+        all_sound_off: 120,
+        reset_all_controllers: 121,
+        local_control: 122,
+        all_notes_off: 123,
+        omni_off: 124,
+        omni_on: 125,
+        mono_on: 126,
+        poly_on: 127
+      }.freeze
+
+      NUMBERS.each do |name, number|
+        const_set(name.to_s.upcase, number)
+      end
+
+      CC_NAMES = NUMBERS.invert.freeze
+
+      module_function
+
+      def number_for(name)
+        NUMBERS.fetch(name) { raise ArgumentError, "Unknown CC name: #{name.inspect}" }
+      end
+
+      def name_for(number)
+        CC_NAMES[number]
+      end
+    end
+  end
+end

data/lib/midicraft/constants/gm.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Midicraft
+  module Constants
+    module GM
+      PATCHES = {
+        # Piano
+        acoustic_grand_piano: 0, bright_acoustic_piano: 1, electric_grand_piano: 2,
+        honky_tonk_piano: 3, electric_piano_1: 4, electric_piano_2: 5,
+        harpsichord: 6, clavinet: 7,
+        # Chromatic Percussion
+        celesta: 8, glockenspiel: 9, music_box: 10, vibraphone: 11,
+        marimba: 12, xylophone: 13, tubular_bells: 14, dulcimer: 15,
+        # Organ
+        drawbar_organ: 16, percussive_organ: 17, rock_organ: 18, church_organ: 19,
+        reed_organ: 20, accordion: 21, harmonica: 22, tango_accordion: 23,
+        # Guitar
+        acoustic_guitar_nylon: 24, acoustic_guitar_steel: 25,
+        electric_guitar_jazz: 26, electric_guitar_clean: 27,
+        electric_guitar_muted: 28, overdriven_guitar: 29,
+        distortion_guitar: 30, guitar_harmonics: 31,
+        # Bass
+        acoustic_bass: 32, electric_bass_finger: 33, electric_bass_pick: 34,
+        fretless_bass: 35, slap_bass_1: 36, slap_bass_2: 37,
+        synth_bass_1: 38, synth_bass_2: 39,
+        # Strings
+        violin: 40, viola: 41, cello: 42, contrabass: 43,
+        tremolo_strings: 44, pizzicato_strings: 45,
+        orchestral_harp: 46, timpani: 47,
+        # Ensemble
+        string_ensemble_1: 48, string_ensemble_2: 49,
+        synth_strings_1: 50, synth_strings_2: 51,
+        choir_aahs: 52, voice_oohs: 53, synth_choir: 54, orchestra_hit: 55,
+        # Brass
+        trumpet: 56, trombone: 57, tuba: 58, muted_trumpet: 59,
+        french_horn: 60, brass_section: 61, synth_brass_1: 62, synth_brass_2: 63,
+        # Reed
+        soprano_sax: 64, alto_sax: 65, tenor_sax: 66, baritone_sax: 67,
+        oboe: 68, english_horn: 69, bassoon: 70, clarinet: 71,
+        # Pipe
+        piccolo: 72, flute: 73, recorder: 74, pan_flute: 75,
+        blown_bottle: 76, shakuhachi: 77, whistle: 78, ocarina: 79,
+        # Synth Lead
+        lead_1_square: 80, lead_2_sawtooth: 81, lead_3_calliope: 82,
+        lead_4_chiff: 83, lead_5_charang: 84, lead_6_voice: 85,
+        lead_7_fifths: 86, lead_8_bass_lead: 87,
+        # Synth Pad
+        pad_1_new_age: 88, pad_2_warm: 89, pad_3_polysynth: 90,
+        pad_4_choir: 91, pad_5_bowed: 92, pad_6_metallic: 93,
+        pad_7_halo: 94, pad_8_sweep: 95,
+        # Synth Effects
+        fx_1_rain: 96, fx_2_soundtrack: 97, fx_3_crystal: 98,
+        fx_4_atmosphere: 99, fx_5_brightness: 100, fx_6_goblins: 101,
+        fx_7_echoes: 102, fx_8_sci_fi: 103,
+        # Ethnic
+        sitar: 104, banjo: 105, shamisen: 106, koto: 107,
+        kalimba: 108, bag_pipe: 109, fiddle: 110, shanai: 111,
+        # Percussive
+        tinkle_bell: 112, agogo: 113, steel_drums: 114, woodblock: 115,
+        taiko_drum: 116, melodic_tom: 117, synth_drum: 118, reverse_cymbal: 119,
+        # Sound Effects
+        guitar_fret_noise: 120, breath_noise: 121, seashore: 122,
+        bird_tweet: 123, telephone_ring: 124, helicopter: 125,
+        applause: 126, gunshot: 127
+      }.freeze
+
+      PATCH_NAMES = PATCHES.invert.freeze
+
+      DRUM_MAP = {
+        bass_drum_2: 35, bass_drum_1: 36, side_stick: 37, snare_drum_1: 38,
+        hand_clap: 39, snare_drum_2: 40, low_floor_tom: 41, closed_hi_hat: 42,
+        high_floor_tom: 43, pedal_hi_hat: 44, low_tom: 45, open_hi_hat: 46,
+        low_mid_tom: 47, hi_mid_tom: 48, crash_cymbal_1: 49, high_tom: 50,
+        ride_cymbal_1: 51, chinese_cymbal: 52, ride_bell: 53, tambourine: 54,
+        splash_cymbal: 55, cowbell: 56, crash_cymbal_2: 57, vibraslap: 58,
+        ride_cymbal_2: 59, hi_bongo: 60, low_bongo: 61, mute_hi_conga: 62,
+        open_hi_conga: 63, low_conga: 64, high_timbale: 65, low_timbale: 66,
+        high_agogo: 67, low_agogo: 68, cabasa: 69, maracas: 70,
+        short_whistle: 71, long_whistle: 72, short_guiro: 73, long_guiro: 74,
+        claves: 75, hi_wood_block: 76, low_wood_block: 77,
+        mute_cuica: 78, open_cuica: 79, mute_triangle: 80, open_triangle: 81
+      }.freeze
+
+      DRUM_NAMES = DRUM_MAP.invert.freeze
+
+      module_function
+
+      def program_number(name)
+        PATCHES.fetch(name) { raise ArgumentError, "Unknown GM patch: #{name.inspect}" }
+      end
+
+      def program_name(number)
+        PATCH_NAMES.fetch(number) { raise ArgumentError, "Unknown GM program number: #{number}" }
+      end
+
+      def drum_note(name)
+        DRUM_MAP.fetch(name) { raise ArgumentError, "Unknown drum: #{name.inspect}" }
+      end
+
+      def drum_name(number)
+        DRUM_NAMES.fetch(number) { raise ArgumentError, "Unknown drum note number: #{number}" }
+      end
+    end
+  end
+end

data/lib/midicraft/dsl/sequence_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Midicraft
+  module DSL
+    class SequenceBuilder
+      def initialize(sequence)
+        @sequence = sequence
+      end
+
+      def track(name = nil, instrument: nil, channel: nil, &block)
+        track = @sequence.add_track(name: name)
+        track.channel = channel
+        track.instrument = instrument if instrument
+
+        if block
+          builder = TrackBuilder.new(track, ppqn: @sequence.ppqn)
+          builder.instance_eval(&block)
+        end
+
+        track
+      end
+    end
+  end
+end

data/lib/midicraft/dsl/track_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Midicraft
+  module DSL
+    class TrackBuilder
+      def initialize(track, ppqn:)
+        @track = track
+        @ppqn = ppqn
+        @cursor = 0
+        @default_velocity = 100
+      end
+
+      def note(pitch, velocity: nil, duration: :quarter)
+        vel = velocity || @default_velocity
+        dur = Duration.resolve(duration, @ppqn)
+        n = Events::Note.new(pitch, velocity: vel, channel: @track.channel || 0,
+                                    duration: dur, start_time: @cursor)
+        @track.add(n)
+        @cursor += dur
+      end
+
+      def chord(pitches, velocity: nil, duration: :quarter)
+        vel = velocity || @default_velocity
+        dur = Duration.resolve(duration, @ppqn)
+        pitches.each do |pitch|
+          n = Events::Note.new(pitch, velocity: vel, channel: @track.channel || 0,
+                                      duration: dur, start_time: @cursor)
+          @track.add(n)
+        end
+        @cursor += dur
+      end
+
+      def rest(duration)
+        @cursor += Duration.resolve(duration, @ppqn)
+      end
+
+      def control(name, value)
+        cc = Events::ControlChange.new(
+          channel: @track.channel || 0,
+          number: name,
+          value: value,
+          absolute_time: @cursor
+        )
+        @track.add(cc)
+      end
+
+      def pitch_bend(value)
+        pb = Events::PitchBend.new(
+          channel: @track.channel || 0,
+          value: value,
+          absolute_time: @cursor
+        )
+        @track.add(pb)
+      end
+
+      def program(name_or_number)
+        pc = Events::ProgramChange.new(
+          channel: @track.channel || 0,
+          program: name_or_number,
+          absolute_time: @cursor
+        )
+        @track.add(pc)
+      end
+
+      def repeat(times, &block)
+        times.times do
+          instance_eval(&block)
+        end
+      end
+
+      def at_tick(tick, &block)
+        saved = @cursor
+        @cursor = tick
+        instance_eval(&block)
+        @cursor = saved
+      end
+
+      def at_bar(bar, beat: 1, &block)
+        ts = find_time_signature
+        numerator = ts ? ts[0] : 4
+        denominator = ts ? ts[1] : 4
+        beats_per_bar = numerator * (4.0 / denominator)
+        ticks_per_beat = @ppqn * (4.0 / denominator)
+        tick = ((bar - 1) * beats_per_bar * @ppqn * (4.0 / denominator) / (4.0 / denominator)).to_i
+        tick = ((bar - 1) * numerator + (beat - 1)) * ticks_per_beat
+        at_tick(tick.to_i, &block)
+      end
+
+      def velocity(v, &block)
+        saved = @default_velocity
+        @default_velocity = v
+        instance_eval(&block)
+        @default_velocity = saved
+      end
+
+      private
+
+      def find_time_signature
+        @track.sequence&.time_signature
+      end
+    end
+  end
+end