teek 0.1.1 → 0.1.2

data/sample/optcarrot/vendor/optcarrot/apu.rb

@@ -0,0 +1,856 @@
+module Optcarrot
+  # APU implementation (audio output)
+  class APU
+    CLK_M2_MUL   = 6
+    CLK_NTSC     = 39_375_000 * CLK_M2_MUL
+    CLK_NTSC_DIV = 11
+
+    CHANNEL_OUTPUT_MUL   = 256
+    CHANNEL_OUTPUT_DECAY = CHANNEL_OUTPUT_MUL / 4 - 1
+
+    FRAME_CLOCKS = [29830, 1, 1, 29828].map {|n| RP2A03_CC * n }
+    OSCILLATOR_CLOCKS = [
+      [7458, 7456, 7458, 7458],
+      [7458, 7456, 7458, 7458 + 7452]
+    ].map {|a| a.map {|n| RP2A03_CC * n } }
+
+    def inspect
+      "#<#{ self.class }>"
+    end
+
+    ###########################################################################
+    # initialization
+
+    def initialize(conf, cpu, rate, bits)
+      @conf = conf
+      @cpu = cpu
+
+      @pulse_0, @pulse_1 = Pulse.new(self), Pulse.new(self)
+      @triangle = Triangle.new(self)
+      @noise = Noise.new(self)
+      @dmc = DMC.new(@cpu, self)
+      @mixer = Mixer.new(@pulse_0, @pulse_1, @triangle, @noise, @dmc)
+
+      @conf.fatal("audio sample rate must be >= 11050") if rate < 11050
+      @conf.fatal("audio bit depth must be 8 or 16") if bits != 8 && bits != 16
+
+      @settings_rate = rate
+
+      @output = []
+      @buffer = []
+
+      @fixed_clock = 1
+      @rate_clock = 1
+      @rate_counter = 0
+      @frame_counter = 0
+      @frame_divider = 0
+      @frame_irq_clock = 0
+      @frame_irq_repeat = 0
+      @dmc_clock = 0
+
+      reset(false)
+    end
+
+    def reset_mapping
+      @frame_counter /= @fixed_clock
+      @rate_counter /= @fixed_clock
+      multiplier = 0
+      while true
+        multiplier += 1
+        break if multiplier >= 512
+        break if CLK_NTSC * multiplier % @settings_rate == 0
+      end
+      @rate_clock = CLK_NTSC * multiplier / @settings_rate
+      @fixed_clock = CLK_NTSC_DIV * multiplier
+      @frame_counter *= @fixed_clock
+      @rate_counter *= @fixed_clock
+
+      @mixer.reset
+      @buffer.clear
+
+      multiplier = 0
+      while true
+        multiplier += 1
+        break if multiplier >= 0x1000
+        break if CLK_NTSC * (multiplier + 1) / @settings_rate > 0x7ffff
+        break if CLK_NTSC * multiplier % @settings_rate == 0
+      end
+      rate = CLK_NTSC * multiplier / @settings_rate
+      fixed = CLK_NTSC_DIV * CPU::CLK_1 * multiplier
+
+      @pulse_0 .update_settings(rate, fixed)
+      @pulse_1 .update_settings(rate, fixed)
+      @triangle.update_settings(rate, fixed)
+      @noise   .update_settings(rate, fixed)
+
+      @cpu.add_mappings(0x4000, method(:peek_40xx), @pulse_0 .method(:poke_0))
+      @cpu.add_mappings(0x4001, method(:peek_40xx), @pulse_0 .method(:poke_1))
+      @cpu.add_mappings(0x4002, method(:peek_40xx), @pulse_0 .method(:poke_2))
+      @cpu.add_mappings(0x4003, method(:peek_40xx), @pulse_0 .method(:poke_3))
+      @cpu.add_mappings(0x4004, method(:peek_40xx), @pulse_1 .method(:poke_0))
+      @cpu.add_mappings(0x4005, method(:peek_40xx), @pulse_1 .method(:poke_1))
+      @cpu.add_mappings(0x4006, method(:peek_40xx), @pulse_1 .method(:poke_2))
+      @cpu.add_mappings(0x4007, method(:peek_40xx), @pulse_1 .method(:poke_3))
+      @cpu.add_mappings(0x4008, method(:peek_40xx), @triangle.method(:poke_0))
+      @cpu.add_mappings(0x400a, method(:peek_40xx), @triangle.method(:poke_2))
+      @cpu.add_mappings(0x400b, method(:peek_40xx), @triangle.method(:poke_3))
+      @cpu.add_mappings(0x400c, method(:peek_40xx), @noise   .method(:poke_0))
+      @cpu.add_mappings(0x400e, method(:peek_40xx), @noise   .method(:poke_2))
+      @cpu.add_mappings(0x400f, method(:peek_40xx), @noise   .method(:poke_3))
+      @cpu.add_mappings(0x4010, method(:peek_40xx), @dmc     .method(:poke_0))
+      @cpu.add_mappings(0x4011, method(:peek_40xx), @dmc     .method(:poke_1))
+      @cpu.add_mappings(0x4012, method(:peek_40xx), @dmc     .method(:poke_2))
+      @cpu.add_mappings(0x4013, method(:peek_40xx), @dmc     .method(:poke_3))
+      @cpu.add_mappings(0x4015, method(:peek_4015), method(:poke_4015))
+      @frame_irq_clock = (@frame_counter / @fixed_clock) - CPU::CLK_1
+    end
+
+    def reset(mapping = true)
+      @cycles_ratecounter = 0
+      @frame_divider = 0
+      @frame_irq_clock = FOREVER_CLOCK
+      @frame_irq_repeat = 0
+      @dmc_clock = DMC::LUT[0]
+      @frame_counter = FRAME_CLOCKS[0] * @fixed_clock
+
+      reset_mapping if mapping
+
+      @pulse_0.reset
+      @pulse_1.reset
+      @triangle.reset
+      @noise.reset
+      @dmc.reset
+      @mixer.reset
+      @buffer.clear
+      @oscillator_clocks = OSCILLATOR_CLOCKS[0]
+    end
+
+    ###########################################################################
+    # other APIs
+
+    attr_reader :output
+
+    def do_clock
+      clock_dma(@cpu.current_clock)
+      clock_frame_irq(@cpu.current_clock) if @frame_irq_clock <= @cpu.current_clock
+      @dmc_clock < @frame_irq_clock ? @dmc_clock : @frame_irq_clock
+    end
+
+    def clock_dma(clk)
+      clock_dmc(clk) if @dmc_clock <= clk
+    end
+
+    def update(target = @cpu.update)
+      target *= @fixed_clock
+      proceed(target)
+      clock_frame_counter if @frame_counter < target
+    end
+
+    def update_latency
+      update(@cpu.update + 1)
+    end
+
+    def update_delta
+      elapsed = @cpu.update
+      delta = @frame_counter != elapsed * @fixed_clock
+      update(elapsed + 1)
+      delta
+    end
+
+    def vsync
+      flush_sound
+      update(@cpu.current_clock)
+      frame = @cpu.next_frame_clock
+      @dmc_clock -= frame
+      @frame_irq_clock -= frame if @frame_irq_clock != FOREVER_CLOCK
+      frame *= @fixed_clock
+      @rate_counter -= frame
+      @frame_counter -= frame
+    end
+
+    ###########################################################################
+    # helpers
+
+    def clock_oscillators(two_clocks)
+      @pulse_0.clock_envelope
+      @pulse_1.clock_envelope
+      @triangle.clock_linear_counter
+      @noise.clock_envelope
+      return unless two_clocks
+      @pulse_0.clock_sweep(-1)
+      @pulse_1.clock_sweep(0)
+      @triangle.clock_length_counter
+      @noise.clock_length_counter
+    end
+
+    def clock_dmc(target)
+      begin
+        if @dmc.clock_dac
+          update(@dmc_clock)
+          @dmc.update
+        end
+        @dmc_clock += @dmc.freq
+        @dmc.clock_dma
+      end while @dmc_clock <= target
+    end
+
+    def clock_frame_counter
+      clock_oscillators(@frame_divider[0] == 1)
+      @frame_divider = (@frame_divider + 1) & 3
+      @frame_counter += @oscillator_clocks[@frame_divider] * @fixed_clock
+    end
+
+    def clock_frame_irq(target)
+      @cpu.do_irq(CPU::IRQ_FRAME, @frame_irq_clock)
+      begin
+        @frame_irq_clock += FRAME_CLOCKS[1 + @frame_irq_repeat % 3]
+        @frame_irq_repeat += 1
+      end while @frame_irq_clock <= target
+    end
+
+    def flush_sound
+      if @buffer.size < @settings_rate / 60
+        target = @cpu.current_clock * @fixed_clock
+        proceed(target)
+        if @buffer.size < @settings_rate / 60
+          clock_frame_counter if @frame_counter < target
+          @buffer << @mixer.sample while @buffer.size < @settings_rate / 60
+        end
+      end
+      @output.clear
+      @output.concat(@buffer) # Array#replace creates an object internally
+      @buffer.clear
+    end
+
+    def proceed(target)
+      while @rate_counter < target && @buffer.size < @settings_rate / 60
+        @buffer << @mixer.sample
+        clock_frame_counter if @frame_counter <= @rate_counter
+        @rate_counter += @rate_clock
+      end
+    end
+
+    ###########################################################################
+    # mapped memory handlers
+
+    # Control
+    def poke_4015(_addr, data)
+      update
+      @pulse_0 .enable(data[0] == 1)
+      @pulse_1 .enable(data[1] == 1)
+      @triangle.enable(data[2] == 1)
+      @noise   .enable(data[3] == 1)
+      @dmc     .enable(data[4] == 1)
+    end
+
+    # Status
+    def peek_4015(_addr)
+      elapsed = @cpu.update
+      clock_frame_irq(elapsed) if @frame_irq_clock <= elapsed
+      update(elapsed) if @frame_counter < elapsed * @fixed_clock
+      @cpu.clear_irq(CPU::IRQ_FRAME) |
+        (@pulse_0 .status ? 0x01 : 0) |
+        (@pulse_1 .status ? 0x02 : 0) |
+        (@triangle.status ? 0x04 : 0) |
+        (@noise   .status ? 0x08 : 0) |
+        (@dmc     .status ? 0x10 : 0)
+    end
+
+    # Frame counter (NOTE: this handler is called via Pads)
+    def poke_4017(_addr, data)
+      n = @cpu.update
+      n += CPU::CLK_1 if @cpu.odd_clock?
+      update(n)
+      clock_frame_irq(n) if @frame_irq_clock <= n
+      n += CPU::CLK_1
+      @oscillator_clocks = OSCILLATOR_CLOCKS[data[7]]
+      @frame_counter = (n + @oscillator_clocks[0]) * @fixed_clock
+      @frame_divider = 0
+      @frame_irq_clock = data & 0xc0 != 0 ? FOREVER_CLOCK : n + FRAME_CLOCKS[0]
+      @frame_irq_repeat = 0
+      @cpu.clear_irq(CPU::IRQ_FRAME) if data[6] != 0
+      clock_oscillators(true) if data[7] != 0
+    end
+
+    def peek_40xx(_addr)
+      0x40
+    end
+
+    ###########################################################################
+    # helper classes
+
+    # A counter for note length
+    class LengthCounter
+      LUT = [
+        0x0a, 0xfe, 0x14, 0x02, 0x28, 0x04, 0x50, 0x06, 0xa0, 0x08, 0x3c, 0x0a, 0x0e, 0x0c, 0x1a, 0x0e,
+        0x0c, 0x10, 0x18, 0x12, 0x30, 0x14, 0x60, 0x16, 0xc0, 0x18, 0x48, 0x1a, 0x10, 0x1c, 0x20, 0x1e,
+      ]
+      def reset
+        @enabled = false
+        @count = 0
+      end
+
+      attr_reader :count
+
+      def enable(enabled)
+        @enabled = enabled
+        @count = 0 unless @enabled
+        @enabled
+      end
+
+      def write(data, frame_counter_delta)
+        @count = @enabled ? LUT[data] : 0 if frame_counter_delta || @count == 0
+      end
+
+      def clock
+        return false if @count == 0
+        @count -= 1
+        return @count == 0
+      end
+    end
+
+    # Wave envelope
+    class Envelope
+      attr_reader :output, :looping
+
+      def reset_clock
+        @reset = true
+      end
+
+      def reset
+        @output = 0
+        @count = 0
+        @volume_base = @volume = 0
+        @constant = true
+        @looping = false
+        @reset = false
+        update_output
+      end
+
+      def clock
+        if @reset
+          @reset = false
+          @volume = 0x0f
+        else
+          if @count != 0
+            @count -= 1
+            return
+          end
+          @volume = (@volume - 1) & 0x0f if @volume != 0 || @looping
+        end
+        @count = @volume_base
+        update_output
+      end
+
+      def write(data)
+        @volume_base = data & 0x0f
+        @constant = data[4] == 1
+        @looping = data[5] == 1
+        update_output
+      end
+
+      def update_output
+        @output = (@constant ? @volume_base : @volume) * CHANNEL_OUTPUT_MUL
+      end
+    end
+
+    # Mixer (with DC Blocking filter)
+    class Mixer
+      VOL   = 192
+      P_F   = 900
+      P_0   = 9552 * CHANNEL_OUTPUT_MUL * VOL * (P_F / 100)
+      P_1   = 8128 * CHANNEL_OUTPUT_MUL * P_F
+      P_2   = P_F * 100
+      TND_F = 500
+      TND_0 = 16367 * CHANNEL_OUTPUT_MUL * VOL * (TND_F / 100)
+      TND_1 = 24329 * CHANNEL_OUTPUT_MUL * TND_F
+      TND_2 = TND_F * 100
+
+      def initialize(pulse_0, pulse_1, triangle, noise, dmc)
+        @pulse_0, @pulse_1, @triangle, @noise, @dmc = pulse_0, pulse_1, triangle, noise, dmc
+      end
+
+      def reset
+        @acc = @prev = @next = 0
+      end
+
+      def sample
+        dac0 = @pulse_0.sample + @pulse_1.sample
+        dac1 = @triangle.sample + @noise.sample + @dmc.sample
+        sample = (P_0 * dac0 / (P_1 + P_2 * dac0)) + (TND_0 * dac1 / (TND_1 + TND_2 * dac1))
+
+        @acc -= @prev
+        @prev = sample << 15
+        @acc += @prev - @next * 3 # POLE
+        sample = @next = @acc >> 15
+
+        sample = -0x7fff if sample < -0x7fff
+        sample = 0x7fff if sample > 0x7fff
+        sample
+      end
+    end
+
+    # base class for oscillator channels (Pulse, Triangle, and Noise)
+    class Oscillator
+      def inspect
+        "#<#{ self.class }>"
+      end
+
+      def initialize(apu)
+        @apu = apu
+        @rate = @fixed = 1
+        @envelope = @length_counter = @wave_length = nil
+      end
+
+      def reset
+        @timer = 2048 * @fixed # 2048: reset cycles
+        @freq = @fixed
+        @amp = 0
+
+        @wave_length = 0 if @wave_length
+        @envelope.reset if @envelope
+        @length_counter.reset if @length_counter
+        @active = active?
+      end
+
+      def active?
+        return false if @length_counter && @length_counter.count == 0
+        return false if @envelope && @envelope.output == 0
+        return true
+      end
+
+      def poke_0(_addr, data)
+        if @envelope
+          @apu.update_latency
+          @envelope.write(data)
+          @active = active?
+        end
+      end
+
+      def poke_2(_addr, data)
+        @apu.update
+        if @wave_length
+          @wave_length = (@wave_length & 0x0700) | (data & 0x00ff)
+          update_freq
+        end
+      end
+
+      def poke_3(_addr, data)
+        delta = @apu.update_delta
+        if @wave_length
+          @wave_length = (@wave_length & 0x00ff) | ((data & 0x07) << 8)
+          update_freq
+        end
+        @envelope.reset_clock if @envelope
+        @length_counter.write(data >> 3, delta) if @length_counter
+        @active = active?
+      end
+
+      def enable(enabled)
+        @length_counter.enable(enabled)
+        @active = active?
+      end
+
+      def update_settings(r, f)
+        @freq = @freq / @fixed * f
+        @timer = @timer / @fixed * f
+        @rate, @fixed = r, f
+      end
+
+      def status
+        @length_counter.count > 0
+      end
+
+      def clock_envelope
+        @envelope.clock
+        @active = active?
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    ### Pulse channel ###
+    class Pulse < Oscillator
+      MIN_FREQ = 0x0008
+      MAX_FREQ = 0x07ff
+      WAVE_FORM = [0b11111101, 0b11111001, 0b11100001, 0b00000110].map {|n| (0..7).map {|i| n[i] * 0x1f } }
+
+      def initialize(_apu)
+        super
+        @wave_length = 0
+        @envelope = Envelope.new
+        @length_counter = LengthCounter.new
+      end
+
+      def reset
+        super
+        @freq = @fixed * 2
+        @valid_freq = false
+        @step = 0
+        @form = WAVE_FORM[0]
+        @sweep_rate = 0
+        @sweep_count = 1
+        @sweep_reload = false
+        @sweep_increase = -1
+        @sweep_shift = 0
+      end
+
+      def active?
+        super && @valid_freq
+      end
+
+      def update_freq
+        if @wave_length >= MIN_FREQ && @wave_length + (@sweep_increase & @wave_length >> @sweep_shift) <= MAX_FREQ
+          @freq = (@wave_length + 1) * 2 * @fixed
+          @valid_freq = true
+        else
+          @valid_freq = false
+        end
+        @active = active?
+      end
+
+      def poke_0(_addr, data)
+        super
+        @form = WAVE_FORM[data >> 6 & 3]
+      end
+
+      def poke_1(_addr, data)
+        @apu.update
+        @sweep_increase = data[3] != 0 ? 0 : -1
+        @sweep_shift = data & 0x07
+        @sweep_rate = 0
+        if data[7] == 1 && @sweep_shift > 0
+          @sweep_rate = ((data >> 4) & 0x07) + 1
+          @sweep_reload = true
+        end
+        update_freq
+      end
+
+      def poke_3(_addr, _data)
+        super
+        @step = 0
+      end
+
+      def clock_sweep(complement)
+        @active = false if !@envelope.looping && @length_counter.clock
+        if @sweep_rate != 0
+          @sweep_count -= 1
+          if @sweep_count == 0
+            @sweep_count = @sweep_rate
+            if @wave_length >= MIN_FREQ
+              shifted = @wave_length >> @sweep_shift
+              if @sweep_increase == 0
+                @wave_length += complement - shifted
+                update_freq
+              elsif @wave_length + shifted <= MAX_FREQ
+                @wave_length += shifted
+                update_freq
+              end
+            end
+          end
+        end
+
+        return unless @sweep_reload
+
+        @sweep_reload = false
+        @sweep_count = @sweep_rate
+      end
+
+      def sample
+        sum = @timer
+        @timer -= @rate
+        if @active
+          if @timer < 0
+            sum >>= @form[@step]
+            begin
+              v = -@timer
+              v = @freq if v > @freq
+              sum += v >> @form[@step = (@step + 1) & 7]
+              @timer += @freq
+            end while @timer < 0
+            @amp = (sum * @envelope.output + @rate / 2) / @rate
+          else
+            @amp = @envelope.output >> @form[@step]
+          end
+        else
+          if @timer < 0
+            count = (-@timer + @freq - 1) / @freq
+            @step = (@step + count) & 7
+            @timer += count * @freq
+          end
+          return 0 if @amp < CHANNEL_OUTPUT_DECAY
+          @amp -= CHANNEL_OUTPUT_DECAY
+        end
+        @amp
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    ### Triangle channel ###
+    class Triangle < Oscillator
+      MIN_FREQ = 2 + 1
+      WAVE_FORM = (0..15).to_a + (0..15).to_a.reverse
+
+      def initialize(_apu)
+        super
+        @wave_length = 0
+        @length_counter = LengthCounter.new
+      end
+
+      def reset
+        super
+        @step = 7
+        @status = :counting
+        @linear_counter_load = 0
+        @linear_counter_start = true
+        @linear_counter = 0
+      end
+
+      def active?
+        super && @linear_counter != 0 && @wave_length >= MIN_FREQ
+      end
+
+      def update_freq
+        @freq = (@wave_length + 1) * @fixed
+        @active = active?
+      end
+
+      def poke_0(_addr, data)
+        super
+        @apu.update
+        @linear_counter_load = data & 0x7f
+        @linear_counter_start = data[7] == 0
+      end
+
+      def poke_3(_addr, _data)
+        super
+        @status = :reload
+      end
+
+      def clock_linear_counter
+        if @status == :counting
+          @linear_counter -= 1 if @linear_counter != 0
+        else
+          @status = :counting if @linear_counter_start
+          @linear_counter = @linear_counter_load
+        end
+        @active = active?
+      end
+
+      def clock_length_counter
+        @active = false if @linear_counter_start && @length_counter.clock
+      end
+
+      def sample
+        if @active
+          sum = @timer
+          @timer -= @rate
+          if @timer < 0
+            sum *= WAVE_FORM[@step]
+            begin
+              v = -@timer
+              v = @freq if v > @freq
+              sum += v * WAVE_FORM[@step = (@step + 1) & 0x1f]
+              @timer += @freq
+            end while @timer < 0
+            @amp = (sum * CHANNEL_OUTPUT_MUL + @rate / 2) / @rate * 3
+          else
+            @amp = WAVE_FORM[@step] * CHANNEL_OUTPUT_MUL * 3
+          end
+        else
+          return 0 if @amp < CHANNEL_OUTPUT_DECAY
+          @amp -= CHANNEL_OUTPUT_DECAY
+          @step = 0
+        end
+        @amp
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    ### Noise channel ###
+    class Noise < Oscillator
+      LUT = [4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 4068]
+      NEXT_BITS_1, NEXT_BITS_6 = [1, 6].map do |shifter|
+        (0..0x7fff).map {|bits| bits[0] == bits[shifter] ? bits / 2 : bits / 2 + 0x4000 }
+      end
+
+      def initialize(_apu)
+        super
+        @envelope = Envelope.new
+        @length_counter = LengthCounter.new
+      end
+
+      def reset
+        super
+        @freq = LUT[0] * @fixed
+        @bits = 0x4000
+        @shifter = NEXT_BITS_1
+      end
+
+      def poke_2(_addr, data)
+        @apu.update
+        @freq = LUT[data & 0x0f] * @fixed
+        @shifter = data[7] != 0 ? NEXT_BITS_6 : NEXT_BITS_1
+      end
+
+      def clock_length_counter
+        @active = false if !@envelope.looping && @length_counter.clock
+      end
+
+      def sample
+        @timer -= @rate
+        if @active
+          return @bits.even? ? @envelope.output * 2 : 0 if @timer >= 0
+
+          sum = @bits.even? ? (@timer + @rate) : 0
+          begin
+            @bits = @shifter[@bits]
+            if @bits.even?
+              v = -@timer
+              v = @freq if v > @freq
+              sum += v
+            end
+            @timer += @freq
+          end while @timer < 0
+          return (sum * @envelope.output + @rate / 2) / @rate * 2
+        else
+          while @timer < 0
+            @bits = @shifter[@bits]
+            @timer += @freq
+          end
+          return 0
+        end
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    ### DMC channel ###
+    class DMC
+      LUT = [428, 380, 340, 320, 286, 254, 226, 214, 190, 160, 142, 128, 106, 84, 72, 54].map {|n| n * RP2A03_CC }
+
+      def initialize(cpu, apu)
+        @apu = apu
+        @cpu = cpu
+        @freq = LUT[0]
+      end
+
+      def reset
+        @cur_sample          = 0
+        @lin_sample          = 0
+        @freq                = LUT[0]
+        @loop                = false
+        @irq_enable          = false
+        @regs_length_counter = 1
+        @regs_address        = 0xc000
+        @out_active          = false
+        @out_shifter         = 0
+        @out_dac             = 0
+        @out_buffer          = 0x00
+        @dma_length_counter  = 0
+        @dma_buffered        = false
+        @dma_address         = 0xc000
+        @dma_buffer          = 0x00
+      end
+
+      attr_reader :freq
+
+      def enable(enabled)
+        @cpu.clear_irq(CPU::IRQ_DMC)
+        if !enabled
+          @dma_length_counter = 0
+        elsif @dma_length_counter == 0
+          @dma_length_counter = @regs_length_counter
+          @dma_address = @regs_address
+          do_dma unless @dma_buffered
+        end
+      end
+
+      def sample
+        if @cur_sample != @lin_sample
+          step = CHANNEL_OUTPUT_MUL * 8
+          if @lin_sample + step < @cur_sample
+            @lin_sample += step
+          elsif @cur_sample < @lin_sample - step
+            @lin_sample -= step
+          else
+            @lin_sample = @cur_sample
+          end
+        end
+        @lin_sample
+      end
+
+      def do_dma
+        @dma_buffer = @cpu.dmc_dma(@dma_address)
+        @dma_address = 0x8000 | ((@dma_address + 1) & 0x7fff)
+        @dma_buffered = true
+        @dma_length_counter -= 1
+        if @dma_length_counter == 0
+          if @loop
+            @dma_address = @regs_address
+            @dma_length_counter = @regs_length_counter
+          elsif @irq_enable
+            @cpu.do_irq(CPU::IRQ_DMC, @cpu.current_clock)
+          end
+        end
+      end
+
+      def update
+        @cur_sample = @out_dac * CHANNEL_OUTPUT_MUL
+      end
+
+      def poke_0(_addr, data)
+        @loop = data[6] != 0
+        @irq_enable = data[7] != 0
+        @freq = LUT[data & 0x0f]
+        @cpu.clear_irq(CPU::IRQ_DMC) unless @irq_enable
+      end
+
+      def poke_1(_addr, data)
+        @apu.update
+        @out_dac = data & 0x7f
+        update
+      end
+
+      def poke_2(_addr, data)
+        @regs_address = 0xc000 | (data << 6)
+      end
+
+      def poke_3(_addr, data)
+        @regs_length_counter = (data << 4) + 1
+      end
+
+      def clock_dac
+        if @out_active
+          n = @out_dac + ((@out_buffer & 1) << 2) - 2
+          @out_buffer >>= 1
+          if 0 <= n && n <= 0x7f && n != @out_dac
+            @out_dac = n
+            return true
+          end
+        end
+        return false
+      end
+
+      def clock_dma
+        if @out_shifter == 0
+          @out_shifter = 7
+          @out_active = @dma_buffered
+          if @out_active
+            @dma_buffered = false
+            @out_buffer = @dma_buffer
+            do_dma if @dma_length_counter != 0
+          end
+        else
+          @out_shifter -= 1
+        end
+      end
+
+      def status
+        @dma_length_counter > 0
+      end
+    end
+  end
+end