ramekin 0.0.5b

data/lib/ramekin/renderer.rb

@@ -0,0 +1,288 @@
+module Ramekin
+  class Renderer
+    include Error::Helpers
+
+    def self.render(fname, track, &b)
+      new(fname, track).render(&b)
+    end
+
+    def initialize(filename, track)
+      @filename = File.basename(filename)
+      @track = track
+
+      @channel = 0
+      @tick = 0
+      @octave = 4
+      @volume = 0xFF
+
+      # TODO: add @smwxxx special instruments and automatically
+      # optimize out unused sfx samples
+      @instrument_index = {}
+
+      (0...30).each do |i|
+        @instrument_index[i.to_s] = i
+      end
+
+      @instrument_index['smwflute'] = 0
+      @instrument_index['smwstring'] = 1
+      @instrument_index['smwglock'] = 2
+      @instrument_index['smwmarimba'] = 3
+      @instrument_index['smwcello'] = 4
+      @instrument_index['smwsteelguitar'] = 5
+      @instrument_index['smwtrumpet'] = 6
+      @instrument_index['smwsteeldrum'] = 7
+      @instrument_index['smwacousticbass'] = 8
+      @instrument_index['smwpiano'] = 9
+      @instrument_index['smwsnare'] = 10
+      @instrument_index['smwstring2'] = 11
+      @instrument_index['smwbongo'] = 12
+      @instrument_index['smwep'] = 13
+      @instrument_index['smwslapbass'] = 14
+      @instrument_index['smworchhit'] = 15
+      @instrument_index['smwharp'] = 16
+      @instrument_index['smwdistguitar'] = 17
+      @instrument_index['smwkick'] = 21
+      @instrument_index['smwhat'] = 22
+      @instrument_index['smwshaker'] = 23
+      @instrument_index['smwwoodblock'] = 24
+      @instrument_index['smwhiwoodblock'] = 25
+      @instrument_index['smwdrums'] = 28
+      @instrument_index['smwpower'] = 29
+
+      # optional default octaves for instrument switching
+      @default_octaves = Hash.new(4)
+    end
+
+    def render(&b)
+      return render_string unless block_given?
+
+      render_preamble(&b)
+
+      @track.channels.each { |c| render_channel(c, &b) }
+    end
+
+    def render_preamble(&b)
+      m = @track.meta
+      yield "#SPC\n{\n"
+      yield "  #title #{m.title.value.inspect}\n" if m.title
+      yield "  #author #{m.author.value.inspect}\n" if m.author
+      yield "  #game #{m.game.value.inspect}\n" if m.game
+      yield "  #comment #{m.comment.value.inspect}\n" if m.comment
+      yield "}\n\n"
+
+      yield "; generated from #{@filename} by Ramekin\n"
+      yield "; https://codeberg.org/jneen/ramekin\n\n"
+
+      # TODO
+      yield "#amk 2\n\n"
+
+      if m.instruments.any?
+        yield "#path #{@filename.chomp('.rmk').inspect}\n"
+        yield "#samples {\n"
+        m.sample_groups.each do |group|
+          yield "  ##{group.value}\n"
+        end
+
+        m.instruments.map(&:sample_name).sort.uniq.each do |sample|
+          yield "  #{sample.inspect}\n"
+        end
+        yield "}\n\n"
+
+        yield "#instruments {\n"
+        m.instruments.each_with_index do |inst, i|
+          @instrument_index[inst.name.value] = 30 + i
+          @default_octaves[inst.name.value] = inst.octave
+          yield "  #{inst.to_amk}\n"
+        end
+        yield "}\n\n"
+      end
+
+      yield "t#{tempo_of(m.tempo)} ; main tempo (0-60)\n" if m.tempo
+      yield "w#{m.volume.value} ; main volume (0-255)\n" if m.volume
+      yield "l16"
+      # binding.pry
+    end
+
+    def tempo_of(el)
+      case el.type
+      when :t then el.value
+      when :bpm then (el.value.to_i * 256 / 625.0).round
+      end
+    end
+
+    def next!
+      if @peek
+        return @peek.tap { @peek = nil }
+      end
+
+      @current_channel.next
+    end
+
+    def peek
+      @peek ||= @current_channel.next
+    end
+
+    def render_channel(channel, &b)
+      @tick = 0
+      yield "\n\n"
+      @current_channel = channel.each
+      loop do
+        @current = el = next!
+
+        case el
+        when NoteEvent
+          old_tick = @tick
+          @tick += el.ticks
+          if (old_tick-1) / 192 != (@tick-1) / 192
+            yield "\n"
+          end
+          yield el.to_amk(@octave)
+          @octave = el.octave unless el.rest?
+        when MacroDefinition
+          # pass
+        when LegatoStart, LegatoLastNote
+          yield el.to_amk
+        when Instrument
+          yield "@#{@instrument_index[el.name.value]}"
+        when Token
+          render_token(el, &b)
+        else
+          error! "unexpected element type #{el.inspect}"
+        end
+      end
+    end
+
+    def render_token(token, &b)
+      case token.type
+      when :t, :bpm
+        yield "t#{tempo_of(token)}"
+      when :directive
+        render_directive(token, &b)
+      when :channel
+        yield "##{token.value}\n\n"
+      when :hex
+        yield "$#{token.value.downcase} "
+      when :slash
+        yield "\n/\n"
+        # reset tick counter for newlines
+        @tick = 0
+      when :transpose
+        interval = token.value.to_i
+
+        if interval < 0
+          interval = 0x80 - interval
+        end
+
+        yield sprintf("$fa$02$%02x", token.value.to_i)
+      when :instrument
+        case token.value
+        when /\A\d+\z/ then yield "@#{token.value}"
+        else
+          @octave = nil
+          unless @instrument_index.key?(token.value)
+            error! "undeclared instrument @#{token.value}"
+          end
+
+          yield "@#{@instrument_index[token.value]}"
+        end
+      when :v
+        yield "v#{token.values.compact.join(',')}"
+        @volume = token.values[0].to_i
+      when :relv
+        relvol, duration = token.values
+        yield "v#{[@volume + relvol.to_i, duration].compact.join(',')}"
+      when :adsr
+        vals = token.value.split(',').map { |x| x.to_i(16) }
+        error! 'invalid #adsr, expected 4 arguments' unless vals.size == 4
+
+        a, d, s, r = vals
+        error! 'invalid attack (must be 0-F)' unless (0..15).include?(a)
+        error! 'invalid decay (must be 0-7)' unless (0..7).include?(d)
+        error! 'invalid sustain (must be 0-7)' unless (0..7).include?(s)
+        error! 'invalid release (must be 0-1F)' unless (0..31).include?(r)
+
+        yield sprintf("$ed$%02x$%02x", (7-d) * 16 + (15-a), s * 32 + (31-r))
+      when :y
+        yield "y#{token.value}"
+      when :rely
+        token.value =~ /\A([LRC])(\d*)\z/
+        pan = case $1
+        when 'L' then 10 + $2.to_i
+        when 'R' then 10 - $2.to_i
+        when 'C' then 10
+        end
+
+        yield "y#{pan}"
+
+      when :p
+        # it's free aram
+        if token.value == '0,0'
+          yield '$df'
+        else
+          yield "p#{token.value} "
+        end
+      when :superloop
+        yield " [[ "
+      when :loop
+        if token.value
+          yield " (#{token.value})[ "
+        else
+          yield " [ "
+        end
+      when :loop_end
+        yield " ]#{token.value} "
+      when :loop_call
+        yield " (#{token.values[0]})#{token.values[1]} "
+      when :star
+        yield "*#{token.value}"
+      when :superloop_end
+        yield " ]]#{token.value} "
+      when :amp
+        yield '&'
+
+      # triplets are handled in NoteAggregator
+      when :lbrace, :rbrace
+        # pass
+      when :rbrace
+        yield '}'
+
+      else
+        error! "unexpected token type: #{token.type}"
+      end
+    end
+
+    def render_directive(token)
+      case token.value
+      when 'SPC'
+        # pass
+      when 'bend'
+        note = next!
+
+        error! '#bend must be followed by a note' unless NoteEvent === note
+        error! 'cannot #bend to a rest' if note.rest?
+
+        ticks = sprintf("%02x", note.ticks)
+        yield "$dd$#{ticks}$#{ticks}#{note.octave_amk}#{note.note.value}"
+
+        case peek
+        when NoteEvent
+          peek.extensions.concat(note.extensions)
+        else
+          yield "^=#{note.ticks}"
+        end
+
+        @octave = note.octave
+      when 'legato'
+        yield '$f4$01'
+      else
+        error! "unexpected directive ##{token.value}"
+      end
+    end
+
+    def render_string
+      out = StringIO.new
+      render { |chunk| out << chunk }
+      out.string
+    end
+  end
+end

data/lib/ramekin/sample_pack.rb

@@ -0,0 +1,296 @@
+require 'uri'
+require 'open-uri'
+require 'json'
+
+module Ramekin
+  class APIEndpoint
+    BASE = 'https://www.smwcentral.net/ajax.php'
+
+    def initialize(**params)
+      @params = {}
+      params.each { |k, v| self[k] = v }
+    end
+
+    def self.get!(**params)
+      resp = URI.open(new(**params).to_uri)
+      binding.pry unless resp.status == %w(200 OK)
+      JSON.parse(resp.read)
+    end
+
+    def []=(k, v)
+      case v
+      when Hash
+        v.each do |subk, subv|
+          self["#{k}[#{subk}]"] = subv
+        end
+      when Array
+        v.each_with_index do |subv, i|
+          self["#{k}[#{i}]"] = subv
+        end
+      when String, Numeric
+        @params[k] = v
+      end
+    end
+
+    def to_uri
+      URI(BASE).tap do |uri|
+        uri.query = URI.encode_www_form(@params)
+      end
+    end
+
+    def to_s
+      to_uri.to_s
+    end
+  end
+
+  REPO_DIR = File.expand_path('~/.ramekin')
+  FileUtils.mkdir_p(REPO_DIR)
+
+  class SamplePack
+    def self.smwc_each(&b)
+      params = { a: 'getsectionlist', s: 'brrsamples' }
+      page = APIEndpoint.get!(**params)
+      page['data'].each { |e| yield new(e) }
+
+      (2..page['last_page']).each do |n|
+        page = APIEndpoint.get!(n: n, **params)
+        page['data'].each { |e| yield new(e) }
+      end
+    end
+
+    def self.find(name)
+      each do |pack|
+        return pack if pack.name == name
+      end
+
+      return nil
+    end
+
+    extend Enumerable
+    def self.each(&b)
+      return enum_for(:each) unless block_given?
+
+      Dir.chdir Ramekin.config.packages_dir do
+        Dir.entries('.').sort.each do |subd|
+          next unless /\A\d+\z/ =~ subd
+          Dir.chdir(subd) do
+            yield new(JSON.load_file(".meta.json"))
+          end
+        end
+      end
+    end
+
+    def initialize(data)
+      @meta = data
+    end
+
+    def name
+      @meta['name'] or raise 'no name'
+    end
+
+    def id
+      @meta['id'].to_i or raise 'no id'
+    end
+
+    def url
+      "https://www.smwcentral.net/?p=section&a=details&id=#{id}"
+    end
+
+    def authors
+      (@meta['authors'] || []).map { |a| a && a['name'] }.compact
+    end
+
+    def find(path)
+      path = path.chomp('.brr')
+      File.join(prefix_dir, "#{path}.brr")
+    end
+
+    def tunings_for(path)
+      rel = Pathname.new(find(path)).relative_path_from(dir).to_s
+      (tunings[rel] || []).map(&:last)
+    end
+
+    def download_url
+      @meta['download_url'] or raise 'no download_url'
+    end
+
+    def shortest_prefix(paths)
+      paths = paths.map { |x| x.split('/') }.sort_by(&:size)
+
+      prefix = []
+      loop do
+        break if paths[0].empty?
+        init = paths.map(&:shift).uniq
+        break if init.size > 1
+        prefix << init[0]
+      end
+
+      prefix.join('/')
+    end
+
+    TUNING_RE = %r(
+      "(.*?[.]brr)" \s*
+        [$](\h\h) \s*
+        [$](\h\h) \s*
+        [$](\h\h) \s*
+        [$](\h\h) \s*
+        [$](\h\h)
+    )x
+
+    def find_tunings(name_re)
+      raw = []
+      Dir.glob('**/*.txt').sort.each do |entry|
+        next unless File.basename(entry).downcase =~ name_re
+
+        contents = File.read(entry, encoding: 'binary')
+
+        contents.gsub!(/;.*$/, '')
+        # windows paths...
+        contents.gsub!(/\\/, '/')
+
+        # contents.scan /#path\s*"(.*?)"/ do |(path)|
+        #   paths << path
+        # end
+
+        contents.scan TUNING_RE do |(path, *hexes)|
+          raw << [entry, path, hexes]
+        end
+      end
+
+      out = Hash.new {|h,k| h[k] = []}
+      raw.each do |tuning_path, name, hexes|
+        out[File.basename(name).downcase] << [tuning_path, name, hexes]
+      end
+
+      out
+    end
+
+    def index_packs
+      paths = []
+      raw_tunings = []
+
+      patterns_tunings = find_tunings(/\A!patterns[.]txt\z/)
+      other_tunings = find_tunings(/\Atuning/)
+      misc_tunings = find_tunings(//)
+
+      @brrs = Dir.glob('**/*.brr')
+      @brrs.sort!
+      @brrs.uniq!
+      @prefix = shortest_prefix(@brrs.map(&File.method(:dirname)))
+
+      @tunings = {}
+      @brrs.each do |brr|
+        base = File.basename(brr).downcase
+        next if base == 'empty.brr'
+
+        candidates = patterns_tunings[base]
+        candidates = other_tunings[base] if candidates.empty?
+        candidates = misc_tunings[base] if candidates.empty?
+
+        candidates = candidates.uniq { |_,_,h| h }
+
+        # if there is more than one candidate, prioritize the one that's closest
+        if candidates.size >= 2
+          candidates.sort_by! { |path, _, _| -shortest_prefix([brr, path]).size }
+        end
+
+        @tunings[brr] = candidates.map { |p, _, h| [p, h] }
+      end
+
+      File.write('.index.json', JSON.dump(
+        prefix: @prefix,
+        brrs: @brrs,
+        tunings: @tunings,
+      ))
+
+      @cached_index = nil
+    end
+
+    def cached_index
+      @cached_index ||= JSON.load_file("#{dir}/.index.json")
+    end
+
+    def prefix
+      cached_index['prefix']
+    end
+
+    def unprefix(path)
+      Pathname.new(dir).join(path).relative_path_from(prefix_dir).to_s
+    end
+
+    def unprefixed_brrs
+      brrs.map(&method(:unprefix))
+    end
+
+    def brrs
+      cached_index['brrs']
+    end
+
+    def tunings
+      cached_index['tunings']
+    end
+
+    def prefix_dir
+      File.join(dir, prefix)
+    end
+
+    def self.download_all!
+      smwc_each(&:download)
+      each(&:index_packs)
+    end
+
+    def needs_download?
+      return true unless exists?
+      @meta['time'] > cached_json['time']
+    end
+
+    def cached_json
+      @cached_json ||= JSON.load_file(meta_file)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def exists?
+      File.exist?(meta_file) && !!cached_json && !!cached_json['id']
+    end
+
+    def meta_file
+      "#{dir}/.meta.json"
+    end
+
+    def dir
+      "#{Ramekin.config.packages_dir}/#{id}"
+    end
+
+    def download
+      unless needs_download?
+        $stderr.puts "skipping: #{name}:#{id}"
+        return
+      end
+
+      download!
+    end
+
+    def download!
+      $stderr.puts "downloading to #{dir}"
+      FileUtils.rm_rf(dir, secure: true)
+      FileUtils.mkdir_p(dir)
+
+      Dir.chdir(dir) do
+        zip = URI.open(download_url).read
+        Zip::File.open_buffer(zip).each do |entry|
+          # look of disapproval
+          next if entry.directory?
+          next if entry.name =~ /__MACOSX/
+          next unless File.expand_path(name).start_with?(File.expand_path('.'))
+
+          $stderr.puts " -> #{entry.name}"
+          FileUtils.mkdir_p(File.dirname(entry.name))
+          entry.extract(entry.name)
+        end
+      end
+
+      File.write(meta_file, JSON.dump(@meta))
+    end
+  end
+end

data/lib/ramekin/spc_player.rb

@@ -0,0 +1,122 @@
+module Ramekin
+  module SPCPlayer
+    def self.make_instance
+      config = Ramekin.config.spc_player
+      unless config == '__auto__'
+        return CustomSPCPlayer.new(File.expand_path(config, HOME))
+      end
+
+      return WindowsSPCPlayer.new if Ramekin.config.windows?
+      NormalSPCPlayer.new
+    end
+
+    def self.instance(*a)
+      @instance ||= make_instance
+    end
+
+    class SPCPlayer
+      include Util
+
+      def setup_ok?
+        true
+      end
+
+      def setup!
+        # pass
+      end
+
+    end
+
+    class WindowsSPCPlayer < SPCPlayer
+      def initialize
+        @spcplay_dir = "#{HOME}/spcplay"
+        @smwc_url = "https://dl.smwcentral.net/35673/spcplay-2.20.1.8272.zip"
+      end
+
+      def setup_ok?
+        File.exist?("#@spcplay_dir/spcplay.exe")
+      end
+
+      def play(fname)
+        fname = File.expand_path(fname)
+        Dir.chdir(@spcplay_dir) do
+          sys "spcplay.exe", fname
+        end
+      end
+
+      def setup!
+        return if setup_ok?
+
+        FileUtils.mkdir_p(@spcplay_dir)
+
+        Dir.chdir @spcplay_dir do
+          $stderr.puts "extracting spcplay from #@smwc_url"
+          $stderr.puts "into #$spcplay_dir"
+          zip = URI.open(@smwc_url).read
+          unpack_zip_here(zip) do |entry|
+            $stderr.puts "  -> #{entry}"
+          end
+        end
+      end
+    end
+
+    class NormalSPCPlayer < SPCPlayer
+      def play(fname)
+        sys "#@spct_dir/spct", 'play', fname
+      end
+
+      def render(fname, outfile, seconds=nil)
+        args = ["#@spct_dir/spct", 'render', fname, outfile]
+        args.concat(['-s', seconds.to_s]) if seconds
+        sys(*args)
+      end
+
+      def initialize
+        @spct_dir = "#{HOME}/spct"
+      end
+
+      def setup_ok?
+        executable?("#@spct_dir/spct")
+      end
+
+      def setup!
+        return if setup_ok?
+
+        clear_dir(@spct_dir, remake: false)
+
+        Dir.chdir(HOME) do
+          sys git, 'clone', '--recursive', 'https://codeberg.org/jneen/spct'
+        end
+
+        Dir.chdir(@spct_dir) do
+          sys(make)
+        end
+      end
+    end
+
+    class CustomSPCPlayer < SPCPlayer
+      def initialize(path)
+        @path = Ramekin.config.expand(path)
+      end
+
+      def render(fname, outfile, seconds=nil)
+        unless File.basename(@path, '.exe') == 'spct'
+          $stderr.puts "WAV rendering is only supported for spct."
+          exit 1
+        end
+
+        args = [@path, 'render', fname, outfile]
+        args.concat(['-s', seconds.to_s]) if seconds
+        sys(*args)
+      end
+
+      def play(fname)
+        if File.basename(@path, '.exe') == 'spct'
+          sys @path, 'play', fname
+        else
+          sys @path, fname
+        end
+      end
+    end
+  end
+end