teek 0.1.2 → 0.1.4

data/sample/optcarrot/vendor/optcarrot/driver.rb

@@ -1,144 +0,0 @@
-module Optcarrot
-  # A manager class for drivers (user frontend)
-  module Driver
-    DRIVER_DB = {
-      video: { none: :Video },
-      audio: { none: :Audio },
-      input: { none: :Input },
-    }
-
-    module_function
-
-    def load(conf)
-      video = load_each(conf, :video, conf.video).new(conf)
-      audio = load_each(conf, :audio, conf.audio).new(conf)
-      input = load_each(conf, :input, conf.input).new(conf, video)
-      return video, audio, input
-    end
-
-    def load_each(conf, type, name)
-      if name
-        klass = DRIVER_DB[type][name]
-        raise "unknown #{ type } driver: #{ name }" unless klass
-        require_relative "driver/#{ name }_#{ type }" unless name == :none
-        conf.debug("`#{ name }' #{ type } driver is selected")
-        Optcarrot.const_get(klass)
-      else
-        selected = nil
-        DRIVER_DB[type].each_key do |n|
-          begin
-            selected = load_each(conf, type, n)
-            break
-          rescue LoadError
-            conf.debug("fail to use `#{ n }' #{ type } driver")
-          end
-        end
-        selected
-      end
-    end
-  end
-
-  # A base class of video output driver
-  class Video
-    WIDTH = 256
-    TV_WIDTH = 292
-    HEIGHT = 224
-
-    def initialize(conf)
-      @conf = conf
-      @palette_rgb = @conf.nestopia_palette ? Palette.nestopia_palette : Palette.defacto_palette
-      @palette = [*0..4096] # dummy palette
-      init
-    end
-
-    attr_reader :palette
-
-    def init
-      @times = []
-    end
-
-    def dispose
-    end
-
-    def tick(_output)
-      @times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      @times.shift if @times.size > 10
-      @times.size < 2 ? 0 : ((@times.last - @times.first) / (@times.size - 1)) ** -1
-    end
-
-    def change_window_size(_scale)
-    end
-
-    def on_resize(_width, _height)
-    end
-  end
-
-  # A base class of audio output driver
-  class Audio
-    PACK_FORMAT = { 8 => "c*", 16 => "v*" }
-    BUFFER_IN_FRAME = 3 # keep audio buffer during this number of frames
-
-    def initialize(conf)
-      @conf = conf
-      @rate = conf.audio_sample_rate
-      @bits = conf.audio_bit_depth
-      raise "sample bits must be 8 or 16" unless @bits == 8 || @bits == 16
-      @pack_format = PACK_FORMAT[@bits]
-
-      init
-    end
-
-    def spec
-      return @rate, @bits
-    end
-
-    def init
-    end
-
-    def dispose
-    end
-
-    def tick(_output)
-    end
-  end
-
-  # A base class of input driver
-  class Input
-    def initialize(conf, video)
-      @conf = conf
-      @video = video
-      init
-    end
-
-    def init
-    end
-
-    def dispose
-    end
-
-    def tick(_frame, _pads)
-    end
-
-    def event(pads, type, code, player)
-      case code
-      when :start  then pads.send(type, player, Pad::START)
-      when :select then pads.send(type, player, Pad::SELECT)
-      when :a      then pads.send(type, player, Pad::A)
-      when :b      then pads.send(type, player, Pad::B)
-      when :right  then pads.send(type, player, Pad::RIGHT)
-      when :left   then pads.send(type, player, Pad::LEFT)
-      when :down   then pads.send(type, player, Pad::DOWN)
-      when :up     then pads.send(type, player, Pad::UP)
-      else
-        return if type != :keydown
-        case code
-        when :screen_x1   then @video.change_window_size(1)
-        when :screen_x2   then @video.change_window_size(2)
-        when :screen_x3   then @video.change_window_size(3)
-        when :screen_full then @video.change_window_size(nil)
-        when :quit        then exit
-        end
-      end
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/mapper/cnrom.rb

@@ -1,14 +0,0 @@
-module Optcarrot
-  # CNROM mapper: http://wiki.nesdev.com/w/index.php/CNROM
-  class CNROM < ROM
-    MAPPER_DB[0x03] = self
-
-    def reset
-      @cpu.add_mappings(0x8000..0xffff, @prg_ref, @chr_ram ? nil : method(:poke_8000))
-    end
-
-    def poke_8000(_addr, data)
-      @chr_ref.replace(@chr_banks[data & 3])
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/mapper/mmc1.rb

@@ -1,105 +0,0 @@
-module Optcarrot
-  # MMC1 mapper: http://wiki.nesdev.com/w/index.php/MMC1
-  class MMC1 < ROM
-    MAPPER_DB[0x01] = self
-
-    NMT_MODE = [:first, :second, :vertical, :horizontal]
-    PRG_MODE = [:conseq, :conseq, :fix_first, :fix_last]
-    CHR_MODE = [:conseq, :noconseq]
-
-    def init
-      @nmt_mode = @prg_mode = @chr_mode = nil
-      @prg_bank = @chr_bank_0 = @chr_bank_1 = 0
-    end
-
-    def reset
-      @shift = @shift_count = 0
-
-      @chr_banks = @chr_banks.flatten.each_slice(0x1000).to_a
-
-      @wrk_readable = @wrk_writable = true
-      @cpu.add_mappings(0x6000..0x7fff, method(:peek_6000), method(:poke_6000))
-      @cpu.add_mappings(0x8000..0xffff, @prg_ref, method(:poke_prg))
-
-      update_nmt(:horizontal)
-      update_prg(:fix_last, 0, 0)
-      update_chr(:conseq, 0, 0)
-    end
-
-    def poke_prg(addr, val)
-      if val[7] == 1
-        @shift = @shift_count = 0
-      else
-        @shift |= val[0] << @shift_count
-        @shift_count += 1
-        if @shift_count == 0x05
-          case (addr >> 13) & 0x3
-          when 0 # control
-            nmt_mode = NMT_MODE[@shift      & 3]
-            prg_mode = PRG_MODE[@shift >> 2 & 3]
-            chr_mode = CHR_MODE[@shift >> 4 & 1]
-            update_nmt(nmt_mode)
-            update_prg(prg_mode, @prg_bank, @chr_bank_0)
-            update_chr(chr_mode, @chr_bank_0, @chr_bank_1)
-          when 1 # change chr_bank_0
-            # update_prg might modify @chr_bank_0 and prevent updating chr bank,
-            # so keep current value.
-            bak_chr_bank_0 = @chr_bank_0
-            update_prg(@prg_mode, @prg_bank, @shift)
-            @chr_bank_0 = bak_chr_bank_0
-            update_chr(@chr_mode, @shift, @chr_bank_1)
-          when 2 # change chr_bank_1
-            update_chr(@chr_mode, @chr_bank_0, @shift)
-          when 3 # change png_bank
-            update_prg(@prg_mode, @shift, @chr_bank_0)
-          end
-          @shift = @shift_count = 0
-        end
-      end
-    end
-
-    def update_nmt(nmt_mode)
-      return if @nmt_mode == nmt_mode
-      @nmt_mode = nmt_mode
-      @ppu.nametables = @nmt_mode
-    end
-
-    def update_prg(prg_mode, prg_bank, chr_bank_0)
-      return if prg_mode == @prg_mode && prg_bank == @prg_bank && chr_bank_0 == @chr_bank_0
-      @prg_mode, @prg_bank, @chr_bank_0 = prg_mode, prg_bank, chr_bank_0
-
-      high_bit = chr_bank_0 & (0x10 & (@prg_banks.size - 1))
-      prg_bank_ex = ((@prg_bank & 0x0f) | high_bit) & (@prg_banks.size - 1)
-      case @prg_mode
-      when :conseq
-        lower = prg_bank_ex & ~1
-        upper = lower + 1
-      when :fix_first
-        lower = 0
-        upper = prg_bank_ex
-      when :fix_last
-        lower = prg_bank_ex
-        upper = ((@prg_banks.size - 1) & 0x0f) | high_bit
-      end
-      @prg_ref[0x8000, 0x4000] = @prg_banks[lower]
-      @prg_ref[0xc000, 0x4000] = @prg_banks[upper]
-    end
-
-    def update_chr(chr_mode, chr_bank_0, chr_bank_1)
-      return if chr_mode == @chr_mode && chr_bank_0 == @chr_bank_0 && chr_bank_1 == @chr_bank_1
-      @chr_mode, @chr_bank_0, @chr_bank_1 = chr_mode, chr_bank_0, chr_bank_1
-      return if @chr_ram
-
-      @ppu.update(0)
-      if @chr_mode == :conseq
-        lower = @chr_bank_0 & 0x1e
-        upper = lower + 1
-      else
-        lower = @chr_bank_0
-        upper = @chr_bank_1
-      end
-      @chr_ref[0x0000, 0x1000] = @chr_banks[lower]
-      @chr_ref[0x1000, 0x1000] = @chr_banks[upper]
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/mapper/mmc3.rb

@@ -1,153 +0,0 @@
-module Optcarrot
-  # MMC3 mapper: http://wiki.nesdev.com/w/index.php/MMC3
-  class MMC3 < ROM
-    MAPPER_DB[0x04] = self
-
-    def init(rev = :B) # rev = :A or :B or :C
-      @persistant = rev != :A
-
-      @prg_banks = @prg_banks.flatten.each_slice(0x2000).to_a
-      @prg_bank_swap = false
-
-      @chr_banks = @chr_banks.flatten.each_slice(0x0400).to_a
-      @chr_bank_mapping = [nil] * 8
-      @chr_bank_swap = false
-    end
-
-    def reset
-      @wrk_readable = true
-      @wrk_writable = false
-
-      poke_a000 = @mirroring != :FourScreen ? method(:poke_a000) : nil
-      @cpu.add_mappings(0x6000..0x7fff, method(:peek_6000), method(:poke_6000))
-      @cpu.add_mappings(0x8000.step(0x9fff, 2), @prg_ref, method(:poke_8000))
-      @cpu.add_mappings(0x8001.step(0x9fff, 2), @prg_ref, method(:poke_8001))
-      @cpu.add_mappings(0xa000.step(0xbfff, 2), @prg_ref, poke_a000)
-      @cpu.add_mappings(0xa001.step(0xbfff, 2), @prg_ref, method(:poke_a001))
-      @cpu.add_mappings(0xc000.step(0xdfff, 2), @prg_ref, method(:poke_c000))
-      @cpu.add_mappings(0xc001.step(0xdfff, 2), @prg_ref, method(:poke_c001))
-      @cpu.add_mappings(0xe000.step(0xffff, 2), @prg_ref, method(:poke_e000))
-      @cpu.add_mappings(0xe001.step(0xffff, 2), @prg_ref, method(:poke_e001))
-
-      update_prg(0x8000, 0)
-      update_prg(0xa000, 1)
-      update_prg(0xc000, -2)
-      update_prg(0xe000, -1)
-      8.times {|i| update_chr(i * 0x400, i) }
-
-      @clock = 0
-      @hold = PPU::RP2C02_CC * 16
-      @ppu.monitor_a12_rising_edge(self)
-      @cpu.ppu_sync = true
-
-      @count = 0
-      @latch = 0
-      @reload = false
-      @enabled = false
-    end
-
-    # prg_bank_swap = F T
-    # 0x8000..0x9fff: 0 2
-    # 0xa000..0xbfff: 1 1
-    # 0xc000..0xdfff: 2 0
-    # 0xe000..0xffff: 3 3
-    def update_prg(addr, bank)
-      bank %= @prg_banks.size
-      addr ^= 0x4000 if @prg_bank_swap && addr[13] == 0
-      @prg_ref[addr, 0x2000] = @prg_banks[bank]
-    end
-
-    def update_chr(addr, bank)
-      return if @chr_ram
-      idx = addr / 0x400
-      bank %= @chr_banks.size
-      return if @chr_bank_mapping[idx] == bank
-      addr ^= 0x1000 if @chr_bank_swap
-      @ppu.update(0)
-      @chr_ref[addr, 0x400] = @chr_banks[bank]
-      @chr_bank_mapping[idx] = bank
-    end
-
-    def poke_8000(_addr, data)
-      @reg_select = data & 7
-      prg_bank_swap = data[6] == 1
-      chr_bank_swap = data[7] == 1
-
-      if prg_bank_swap != @prg_bank_swap
-        @prg_bank_swap = prg_bank_swap
-        @prg_ref[0x8000, 0x2000], @prg_ref[0xc000, 0x2000] = @prg_ref[0xc000, 0x2000], @prg_ref[0x8000, 0x2000]
-      end
-
-      if chr_bank_swap != @chr_bank_swap
-        @chr_bank_swap = chr_bank_swap
-        unless @chr_ram
-          @ppu.update(0)
-          @chr_ref.rotate!(0x1000)
-          @chr_bank_mapping.rotate!(4)
-        end
-      end
-    end
-
-    def poke_8001(_addr, data)
-      if @reg_select < 6
-        if @reg_select < 2
-          update_chr(@reg_select * 0x0800, data & 0xfe)
-          update_chr(@reg_select * 0x0800 + 0x0400, data | 0x01)
-        else
-          update_chr((@reg_select - 2) * 0x0400 + 0x1000, data)
-        end
-      else
-        update_prg((@reg_select - 6) * 0x2000 + 0x8000, data & 0x3f)
-      end
-    end
-
-    def poke_a000(_addr, data)
-      @ppu.nametables = data[0] == 1 ? :horizontal : :vertical
-    end
-
-    def poke_a001(_addr, data)
-      @wrk_readable = data[7] == 1
-      @wrk_writable = data[6] == 0 && @wrk_readable
-    end
-
-    def poke_c000(_addr, data)
-      @ppu.update(0)
-      @latch = data
-    end
-
-    def poke_c001(_addr, _data)
-      @ppu.update(0)
-      @reload = true
-    end
-
-    def poke_e000(_addr, _data)
-      @ppu.update(0)
-      @enabled = false
-      @cpu.clear_irq(CPU::IRQ_EXT)
-    end
-
-    def poke_e001(_addr, _data)
-      @ppu.update(0)
-      @enabled = true
-    end
-
-    def vsync
-      @clock = @clock > @cpu.next_frame_clock ? @clock - @cpu.next_frame_clock : 0
-    end
-
-    def a12_signaled(cycle)
-      clk, @clock = @clock, cycle + @hold
-      return if cycle < clk
-      flag = @persistant || @count > 0
-      if @reload
-        @reload = false
-        @count = @latch
-      elsif @count == 0
-        @count = @latch
-      else
-        @count -= 1
-      end
-      @cpu.do_irq(CPU::IRQ_EXT, cycle) if flag && @count == 0 && @enabled
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/mapper/uxrom.rb

@@ -1,14 +0,0 @@
-module Optcarrot
-  # UxROM mapper: http://wiki.nesdev.com/w/index.php/UxROM
-  class UxROM < ROM
-    MAPPER_DB[0x02] = self
-
-    def reset
-      @cpu.add_mappings(0x8000..0xffff, @prg_ref, method(:poke_8000))
-    end
-
-    def poke_8000(_addr, data)
-      @prg_ref[0x8000, 0x4000] = @prg_banks[data & 7]
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/nes.rb

@@ -1,105 +0,0 @@
-module Optcarrot
-  FOREVER_CLOCK = 0xffffffff
-  RP2A03_CC = 12
-
-  # NES emulation main
-  class NES
-    FPS = 60
-
-    def initialize(conf = ARGV)
-      @conf = Config.new(conf)
-
-      @video, @audio, @input = Driver.load(@conf)
-
-      @cpu =            CPU.new(@conf)
-      @apu = @cpu.apu = APU.new(@conf, @cpu, *@audio.spec)
-      @ppu = @cpu.ppu = PPU.new(@conf, @cpu, @video.palette)
-      @rom  = ROM.load(@conf, @cpu, @ppu)
-      @pads = Pads.new(@conf, @cpu, @apu)
-
-      @frame = 0
-      @frame_target = @conf.frames == 0 ? nil : @conf.frames
-      @fps_history = [] if save_fps_history?
-    end
-
-    def inspect
-      "#<#{ self.class }>"
-    end
-
-    attr_reader :fps, :video, :audio, :input, :cpu, :ppu, :apu
-
-    def reset
-      @cpu.reset
-      @apu.reset
-      @ppu.reset
-      @rom.reset
-      @pads.reset
-      @cpu.boot
-      @rom.load_battery
-    end
-
-    def step
-      @ppu.setup_frame
-      @cpu.run
-      @ppu.vsync
-      @apu.vsync
-      @cpu.vsync
-      @rom.vsync
-
-      @input.tick(@frame, @pads)
-      @fps = @video.tick(@ppu.output_pixels)
-      @fps_history << @fps if save_fps_history?
-      @audio.tick(@apu.output)
-
-      @frame += 1
-      @conf.info("frame #{ @frame }") if @conf.loglevel >= 2
-    end
-
-    def dispose
-      if @fps
-        @conf.info("fps: %.2f (in the last 10 frames)" % @fps)
-        if @conf.print_fps_history
-          puts "frame,fps-history"
-          @fps_history.each_with_index {|fps, frame| puts "#{ frame },#{ fps }" }
-        end
-        if @conf.print_p95fps
-          puts "p95 fps: #{ @fps_history.sort[(@fps_history.length * 0.05).floor] }"
-        end
-        puts "fps: #{ @fps }" if @conf.print_fps
-      end
-      if @conf.print_video_checksum && @video.instance_of?(Video)
-        puts "checksum: #{ @ppu.output_pixels.pack("C*").sum }"
-      end
-      @video.dispose
-      @audio.dispose
-      @input.dispose
-      @rom.save_battery
-      @ppu.dispose
-    end
-
-    def run
-      reset
-
-      if @conf.stackprof_mode
-        require "stackprof"
-        out = @conf.stackprof_output.sub("MODE", @conf.stackprof_mode)
-        StackProf.start(mode: @conf.stackprof_mode.to_sym, out: out, raw: true)
-      end
-
-      step until @frame == @frame_target
-
-      if @conf.stackprof_mode
-        StackProf.stop
-        StackProf.results
-      end
-    ensure
-      dispose
-    end
-
-    private
-
-    def save_fps_history?
-      @conf.print_fps_history || @conf.print_p95fps
-    end
-  end
-end

data/sample/optcarrot/vendor/optcarrot/opt.rb

@@ -1,168 +0,0 @@
-module Optcarrot
-  # dirty methods manipulating and generating methods...
-  module CodeOptimizationHelper
-    def initialize(loglevel, enabled_opts)
-      @loglevel = loglevel
-      options = self.class::OPTIONS
-      opts = {}
-      enabled_opts ||= [:all]
-      default =
-        (enabled_opts == [:all] || enabled_opts != [] && enabled_opts.all? {|opt| opt.to_s.start_with?("-") })
-      options.each {|opt| opts[opt] = default }
-      (enabled_opts - [:none, :all]).each do |opt|
-        val = true
-        if opt.to_s.start_with?("-")
-          opt = opt.to_s[1..-1].to_sym
-          val = false
-        end
-        raise "unknown optimization: `#{ opt }'" unless options.include?(opt)
-        opts[opt] = val
-      end
-      options.each {|opt| instance_variable_set(:"@#{ opt }", opts[opt]) }
-    end
-
-    def depends(opt, depended_opt)
-      if instance_variable_get(:"@#{ opt }") && !instance_variable_get(:"@#{ depended_opt }")
-        raise "`#{ opt }' depends upon `#{ depended_opt }'"
-      end
-    end
-
-    def gen(*codes)
-      codes.map {|code| code.to_s.chomp }.join("\n") + "\n"
-    end
-
-    # change indent
-    def indent(i, code)
-      if i > 0
-        code.gsub(/^(.+)$/) { " " * i + $1 }
-      elsif i < 0
-        code.gsub(/^ {#{ -i }}/, "")
-      else
-        code
-      end
-    end
-
-    # generate a branch
-    def branch(cond, code1, code2)
-      gen(
-        "if #{ cond }",
-        indent(2, code1),
-        "else",
-        indent(2, code2),
-        "end",
-      )
-    end
-
-    MethodDef = Struct.new(:params, :body)
-
-    METHOD_DEFINITIONS_RE = /
-      ^(\ +)def\s+(\w+)(?:\((.*)\))?\n
-      ^((?:\1\ +.*\n|\n)*)
-      ^\1end$
-    /x
-    # extract all method definitions
-    def parse_method_definitions(file)
-      src = File.read(file)
-      mdefs = {}
-      src.scan(METHOD_DEFINITIONS_RE) do |indent, meth, params, body|
-        body = indent(-indent.size - 2, body)
-
-        # noramlize: break `when ... then`
-        body = body.gsub(/^( *)when +(.*?) +then +(.*)/) { $1 + "when #{ $2 }\n" + $1 + "  " + $3 }
-
-        # normalize: return unless
-        body = "if " + $1 + indent(2, $') + "end\n" if body =~ /\Areturn unless (.*)/
-
-        # normalize: if modifier -> if statement
-        nil while body.gsub!(/^( *)((?!#)\S.*) ((?:if|unless) .*\n)/) { indent($1.size, gen($3, "  " + $2, "end")) }
-
-        mdefs[meth.to_sym] = MethodDef[params ? params.split(", ") : nil, body]
-      end
-      mdefs
-    end
-
-    # inline method calls with no arguments
-    def expand_methods(code, mdefs, meths = mdefs.keys)
-      code.gsub(/^( *)\b(#{ meths * "|" })\b(?:\((.*?)\))?\n/) do
-        indent, meth, args = $1, $2, $3
-        body = mdefs[meth.to_sym]
-        body = body.body if body.is_a?(MethodDef)
-        if args
-          mdefs[meth.to_sym].params.zip(args.split(", ")) do |param, arg|
-            body = replace_var(body, param, arg)
-          end
-        end
-        indent(indent.size, body)
-      end
-    end
-
-    def expand_inline_methods(code, meth, mdef)
-      code.gsub(/\b#{ meth }\b(?:\(((?:@?\w+, )*@?\w+)\))?/) do
-        args = $1
-        b = "(#{ mdef.body.chomp.gsub(/ *#.*/, "").gsub("\n", "; ") })"
-        if args
-          mdef.params.zip(args.split(", ")) do |param, arg|
-            b = replace_var(b, param, arg)
-          end
-        end
-        b
-      end
-    end
-
-    def replace_var(code, var, bool)
-      re = var.start_with?("@") ? /#{ var }\b/ : /\b#{ var }\b/
-      code.gsub(re) { bool }
-    end
-
-    def replace_cond_var(code, var, bool)
-      code.gsub(/(if|unless)\s#{ var }\b/) { $1 + " " + bool }
-    end
-
-    TRIVIAL_BRANCH_RE = /
-      ^(\ *)(if|unless)\ (true|false)\n
-      ^((?:\1\ +.*\n|\n)*)
-       (?:
-         \1else\n
-         ((?:\1\ +.*\n|\n)*)
-       )?
-      ^\1end\n
-    /x
-    # remove "if true" or "if false"
-    def remove_trivial_branches(code)
-      code = code.dup
-      nil while
-        code.gsub!(TRIVIAL_BRANCH_RE) do
-          if ($2 == "if") == ($3 == "true")
-            indent(-2, $4)
-          else
-            $5 ? indent(-2, $5) : ""
-          end
-        end
-      code
-    end
-
-    # replace instance variables with temporal local variables
-    # CAUTION: the instance variable must not be accessed out of CPU#run
-    def localize_instance_variables(code, ivars = code.scan(/@\w+/).uniq.sort)
-      ivars = ivars.map {|ivar| ivar.to_s[1..-1] }
-
-      inits, finals = [], []
-      ivars.each do |ivar|
-        lvar = "__#{ ivar }__"
-        inits << "#{ lvar } = @#{ ivar }"
-        finals << "@#{ ivar } = #{ lvar }"
-      end
-
-      code = code.gsub(/@(#{ ivars * "|" })\b/) { "__#{ $1 }__" }
-
-      gen(
-        "begin",
-        indent(2, inits.join("\n")),
-        indent(2, code),
-        "ensure",
-        indent(2, finals.join("\n")),
-        "end",
-      )
-    end
-  end
-end