rubyboy 1.1.0 → 1.3.0

data/lib/rubyboy/apu_channels/channel4.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Rubyboy
+  module ApuChannels
+    class Channel4
+      attr_accessor :enabled, :wave_duty_position
+
+      WAVE_DUTY = [
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], # 12.5%
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], # 25%
+        [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], # 50%
+        [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]  # 75%
+      ].freeze
+
+      def initialize
+        @cycles = 0
+        @frequency = 0
+        @frequency_timer = 0
+        @wave_duty_position = 0
+
+        @enabled = false
+        @dac_enabled = false
+        @length_enabled = false
+        @is_upwards = false
+        @is_decrementing = false
+        @sweep_enabled = false
+        @sweep_period = 0
+        @sweep_shift = 0
+        @period = 0
+        @period_timer = 0
+        @current_volume = 0
+        @initial_volume = 0
+        @shadow_frequency = 0
+        @sweep_timer = 0
+        @length_timer = 0
+        @wave_duty_pattern = 0
+
+        @lfsr = 0x7fff
+        @width_mode = false
+        @shift_amount = 0
+        @divisor_code = 0
+      end
+
+      def step(cycles)
+        @cycles += cycles
+
+        return if @cycles < @frequency_timer
+
+        @cycles -= @frequency_timer
+        @frequency_timer = [8, @divisor_code << 4].max << @shift_amount
+
+        xor = (@lfsr & 0x01) ^ ((@lfsr & 0b10) >> 1)
+        @lfsr = (@lfsr >> 1) | (xor << 14)
+        return unless @width_mode
+
+        @lfsr &= ~(1 << 6)
+        @lfsr |= xor << 6
+      end
+
+      def step_fs(fs)
+        length if fs & 0x01 == 0
+        envelope if fs == 7
+      end
+
+      def length
+        return unless @length_enabled && @length_timer > 0
+
+        @length_timer -= 1
+        @enabled &= @length_timer > 0
+      end
+
+      def envelope
+        return if @period == 0
+
+        @period_timer -= 1 if @period_timer > 0
+
+        return if @period_timer != 0
+
+        @period_timer = @period
+
+        if @current_volume < 15 && @is_upwards
+          @current_volume += 1
+        elsif @current_volume > 0 && !@is_upwards
+          @current_volume -= 1
+        end
+      end
+
+      def calculate_frequency
+        if @is_decrementing
+          if @shadow_frequency >= (@shadow_frequency >> @sweep_shift)
+            @shadow_frequency - (@shadow_frequency >> @sweep_shift)
+          else
+            0
+          end
+        else
+          [0x3ff, @shadow_frequency + (@shadow_frequency >> @sweep_shift)].min
+        end
+      end
+
+      def dac_output
+        return 0.0 unless @dac_enabled && @enabled
+
+        ret = (@lfsr & 0x01) * @current_volume
+        (ret / 7.5) - 1.0
+      end
+
+      def read_nr4x(x)
+        case x
+        when 0 then 0xff
+        when 1 then 0xff
+        when 2 then (@initial_volume << 4) | (@is_upwards ? 0x08 : 0x00) | @period
+        when 3 then (@shift_amount << 4) | (@width_mode ? 0x08 : 0x00) | @divisor_code
+        when 4 then (@length_enabled ? 0x40 : 0x00) | 0xbf
+        else 0xff
+        end
+      end
+
+      def write_nr4x(x, val)
+        case x
+        when 0
+          # nop
+        when 1
+          @length_timer = 64 - (val & 0x3f)
+        when 2
+          @is_upwards = (val & 0x08) > 0
+          @initial_volume = val >> 4
+          @period = val & 0x07
+          @dac_enabled = val & 0xf8 > 0
+          @enabled &= @dac_enabled
+        when 3
+          @shift_amount = (val >> 4) & 0x0f
+          @width_mode = (val & 0x08) > 0
+          @divisor_code = val & 0x07
+        when 4
+          @length_enabled = (val & 0x40) > 0
+          @length_timer = 64 if @length_timer == 0
+          return unless (val & 0x80) > 0
+
+          @enabled = true if @dac_enabled
+
+          @lfsr = 0x7fff
+          @period_timer = @period
+          @current_volume = @initial_volume
+        end
+      end
+    end
+  end
+end

data/lib/rubyboy/audio.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rubyboy/sdl'
+
+module Rubyboy
+  class Audio
+    SAMPLE_RATE = 48000
+    SAMPLES = 512
+
+    def initialize
+      SDL.InitSubSystem(SDL::INIT_AUDIO)
+
+      desired = SDL::AudioSpec.new
+      desired[:freq] = SAMPLE_RATE
+      desired[:format] = SDL::AUDIO_F32SYS
+      desired[:channels] = 2
+      desired[:samples] = SAMPLES * 2
+
+      @device = SDL.OpenAudioDevice(nil, 0, desired, nil, 0)
+
+      SDL.PauseAudioDevice(@device, 0)
+    end
+
+    def queue(buffer)
+      sleep(0.001) while SDL.GetQueuedAudioSize(@device) > 8192
+
+      buf_ptr = FFI::MemoryPointer.new(:float, buffer.size)
+      buf_ptr.put_array_of_float(0, buffer)
+
+      SDL.QueueAudio(@device, buf_ptr, buffer.size * buf_ptr.type_size)
+    end
+  end
+end

data/lib/rubyboy/bus.rb

@@ -1,140 +1,84 @@
 # frozen_string_literal: true
 
-require_relative 'cartridge/factory'
-
 module Rubyboy
   class Bus
-    def initialize(ppu, rom, timer, interrupt, joypad)
+    def initialize(ppu, rom, ram, mbc, timer, interrupt, joypad, apu)
       @ppu = ppu
       @rom = rom
-      @ram = Ram.new
-      @mbc = Cartridge::Factory.create(@rom, @ram)
+      @ram = ram
+      @mbc = mbc
       @joypad = joypad
+      @apu = apu
       @interrupt = interrupt
       @timer = timer
 
-      @tmp = {}
+      @read_methods = Array.new(0x10000)
+      @write_methods = Array.new(0x10000)
+
+      set_methods
     end
 
-    def read_byte(addr)
-      case addr
-      when 0x0000..0x7fff
-        @mbc.read_byte(addr)
-      when 0x8000..0x9fff
-        @ppu.read_byte(addr)
-      when 0xa000..0xbfff
-        @mbc.read_byte(addr)
-      when 0xc000..0xcfff
-        @ram.wram1[addr - 0xc000]
-      when 0xd000..0xdfff
-        @ram.wram2[addr - 0xd000]
-      when 0xe000..0xfdff
-        # echo ram
-      when 0xfe00..0xfe9f
-        @ppu.read_byte(addr)
-      when 0xfea0..0xfeff
-        # unused
-        0xff
-      when 0xff00
-        @joypad.read_byte(addr)
-      when 0xff01..0xff02
-        # serial
-        @tmp[addr] ||= 0
-      when 0xff04..0xff07
-        @timer.read_byte(addr)
-      when 0xff0f
-        @interrupt.read_byte(addr)
-      when 0xff10..0xff26
-        # sound
-        @tmp[addr] ||= 0
-      when 0xff30..0xff3f
-        # wave pattern ram
-        @tmp[addr] ||= 0
-      when 0xff40..0xff4b
-        @ppu.read_byte(addr)
-      when 0xff4f
-        # vbk
-        @tmp[addr] ||= 0
-      when 0xff50
-        # boot rom
-        @tmp[addr] ||= 0
-      when 0xff51..0xff55
-        # hdma
-        @tmp[addr] ||= 0
-      when 0xff68..0xff6b
-        # bgp
-        @tmp[addr] ||= 0
-      when 0xff70
-        # svbk
-        @tmp[addr] ||= 0
-      when 0xff80..0xfffe
-        @ram.hram[addr - 0xff80]
-      when 0xffff
-        @interrupt.read_byte(addr)
-      else
-        0xff
+    def set_methods
+      0x10000.times do |addr|
+        case addr
+        when 0x0000..0x7fff
+          @read_methods[addr] = -> { @mbc.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @mbc.write_byte(addr, value) }
+        when 0x8000..0x9fff
+          @read_methods[addr] = -> { @ppu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @ppu.write_byte(addr, value) }
+        when 0xa000..0xbfff
+          @read_methods[addr] = -> { @mbc.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @mbc.write_byte(addr, value) }
+        when 0xc000..0xcfff
+          @read_methods[addr] = -> { @ram.wram1[addr - 0xc000] }
+          @write_methods[addr] = ->(value) { @ram.wram1[addr - 0xc000] = value }
+        when 0xd000..0xdfff
+          @read_methods[addr] = -> { @ram.wram2[addr - 0xd000] }
+          @write_methods[addr] = ->(value) { @ram.wram2[addr - 0xd000] = value }
+        when 0xfe00..0xfe9f
+          @read_methods[addr] = -> { @ppu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @ppu.write_byte(addr, value) }
+        when 0xff00
+          @read_methods[addr] = -> { @joypad.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @joypad.write_byte(addr, value) }
+        when 0xff04..0xff07
+          @read_methods[addr] = -> { @timer.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @timer.write_byte(addr, value) }
+        when 0xff0f
+          @read_methods[addr] = -> { @interrupt.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @interrupt.write_byte(addr, value) }
+        when 0xff10..0xff26
+          @read_methods[addr] = -> { @apu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @apu.write_byte(addr, value) }
+        when 0xff30..0xff3f
+          @read_methods[addr] = -> { @apu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @apu.write_byte(addr, value) }
+        when 0xff46
+          @read_methods[addr] = -> { @ppu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { 0xa0.times { |i| write_byte(0xfe00 + i, read_byte((value << 8) + i)) } }
+        when 0xff40..0xff4b
+          @read_methods[addr] = -> { @ppu.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @ppu.write_byte(addr, value) }
+        when 0xff80..0xfffe
+          @read_methods[addr] = -> { @ram.hram[addr - 0xff80] }
+          @write_methods[addr] = ->(value) { @ram.hram[addr - 0xff80] = value }
+        when 0xffff
+          @read_methods[addr] = -> { @interrupt.read_byte(addr) }
+          @write_methods[addr] = ->(value) { @interrupt.write_byte(addr, value) }
+        else
+          @read_methods[addr] = -> { 0xff }
+          @write_methods[addr] = ->(_value) {}
+        end
       end
     end
 
+    def read_byte(addr)
+      @read_methods[addr].call
+    end
+
     def write_byte(addr, value)
-      case addr
-      when 0x0000..0x7fff
-        @mbc.write_byte(addr, value)
-      when 0x8000..0x9fff
-        @ppu.write_byte(addr, value)
-      when 0xa000..0xbfff
-        @mbc.write_byte(addr, value)
-      when 0xc000..0xcfff
-        @ram.wram1[addr - 0xc000] = value
-      when 0xd000..0xdfff
-        @ram.wram2[addr - 0xd000] = value
-      when 0xe000..0xfdff
-        # echo ram
-      when 0xfe00..0xfe9f
-        @ppu.write_byte(addr, value)
-      when 0xfea0..0xfeff
-        # unused
-      when 0xff00
-        @joypad.write_byte(addr, value)
-      when 0xff01..0xff02
-        # serial
-        @tmp[addr] = value
-      when 0xff04..0xff07
-        @timer.write_byte(addr, value)
-      when 0xff0f
-        @interrupt.write_byte(addr, value)
-      when 0xff10..0xff26
-        # sound
-        @tmp[addr] = value
-      when 0xff30..0xff3f
-        # wave pattern ram
-        @tmp[addr] = value
-      when 0xff46
-        0xa0.times do |i|
-          write_byte(0xfe00 + i, read_byte((value << 8) + i))
-        end
-      when 0xff40..0xff4b
-        @ppu.write_byte(addr, value)
-      when 0xff4f
-        # vbk
-        @tmp[addr] = value
-      when 0xff50
-        # boot rom
-        @tmp[addr] = value
-      when 0xff51..0xff55
-        # hdma
-        @tmp[addr] = value
-      when 0xff68..0xff6b
-        # bgp
-        @tmp[addr] = value
-      when 0xff70
-        # svbk
-        @tmp[addr] = value
-      when 0xff80..0xfffe
-        @ram.hram[addr - 0xff80] = value
-      when 0xffff
-        @interrupt.write_byte(addr, value)
-      end
+      @write_methods[addr].call(value)
     end
 
     def read_word(addr)

data/lib/rubyboy/cartridge/factory.rb

@@ -15,7 +15,7 @@ module Rubyboy
         when 0x08..0x09
           Nombc.new(rom)
         else
-          raise "Unsupported cartridge type: #{cartridge_type}"
+          raise "Unsupported cartridge type: #{rom.cartridge_type}"
         end
       end
     end

data/lib/rubyboy/cartridge/mbc1.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../ram'
-
 module Rubyboy
   module Cartridge
     class Mbc1
@@ -12,50 +10,66 @@ module Rubyboy
         @ram_bank = 0
         @ram_enable = false
         @ram_banking_mode = false
+
+        @read_methods = Array.new(0xc000)
+        @write_methods = Array.new(0xc000)
+
+        set_methods
       end
 
-      def read_byte(addr)
-        case addr
-        when 0x0000..0x3fff
-          @rom.data[addr]
-        when 0x4000..0x7fff
-          @rom.data[addr + (@rom_bank - 1) * 0x4000]
-        when 0xa000..0xbfff
-          if @ram_enable
-            if @ram_banking_mode
-              @ram.eram[addr - 0xa000 + @ram_bank * 0x800]
-            else
-              @ram.eram[addr - 0xa000]
+      def set_methods
+        0xc000.times do |addr|
+          @read_methods[addr] =
+            case addr
+            when 0x0000..0x3fff then -> { @rom.data[addr] }
+            when 0x4000..0x7fff then -> { @rom.data[addr + (@rom_bank - 1) * 0x4000] }
+            when 0xa000..0xbfff
+              lambda do
+                if @ram_enable
+                  if @ram_banking_mode
+                    @ram.eram[addr - 0xa000 + @ram_bank * 0x800]
+                  else
+                    @ram.eram[addr - 0xa000]
+                  end
+                else
+                  0xff
+                end
+              end
             end
-          else
-            0xff
-          end
-        else
-          raise "not implemented: read_byte #{addr}"
         end
-      end
 
-      def write_byte(addr, value)
-        case addr
-        when 0x0000..0x1fff
-          @ram_enable = value & 0x0f == 0x0a
-        when 0x2000..0x3fff
-          @rom_bank = value & 0x1f
-          @rom_bank = 1 if @rom_bank == 0
-        when 0x4000..0x5fff
-          @ram_bank = value & 0x03
-        when 0x6000..0x7fff
-          @ram_banking_mode = value & 0x01 == 0x01
-        when 0xa000..0xbfff
-          if @ram_enable
-            if @ram_banking_mode
-              @ram.eram[addr - 0xa000 + @ram_bank * 0x800] = value
-            else
-              @ram.eram[addr - 0xa000] = value
+        0xc000.times do |addr|
+          @write_methods[addr] =
+            case addr
+            when 0x0000..0x1fff then ->(value) { @ram_enable = value & 0x0f == 0x0a }
+            when 0x2000..0x3fff
+              lambda do |value|
+                @rom_bank = value & 0x1f
+                @rom_bank = 1 if @rom_bank == 0
+              end
+            when 0x4000..0x5fff then ->(value) { @ram_bank = value & 0x03 }
+            when 0x6000..0x7fff then ->(value) { @ram_banking_mode = value & 0x01 == 0x01 }
+            when 0xa000..0xbfff
+              lambda do |value|
+                if @ram_enable
+                  if @ram_banking_mode
+                    @ram.eram[addr - 0xa000 + @ram_bank * 0x800] = value
+                  else
+                    @ram.eram[addr - 0xa000] = value
+                  end
+                end
+              end
             end
-          end
         end
       end
+
+      def read_byte(addr)
+        @read_methods[addr].call
+      end
+
+      def write_byte(addr, value)
+        @write_methods[addr].call(value)
+      end
     end
   end
 end