From 50f7a6e6ee5895766e9ad9d0a60a2e96e574893c Mon Sep 17 00:00:00 2001
From: 196Ikuchil <196thinline@gmail.com>
Date: Mon, 16 Mar 2020 01:53:08 +0900
Subject: [PATCH] WIP

---
 index.html                     |   2 +
 main.js                        |   8 +-
 roms/apu/test_apu_env.nes      | Bin 0 -> 16400 bytes
 src/externs/lib.js             |  18 +++
 src/nes/apu/constants.rs       |  11 ++
 src/nes/apu/mod.rs             | 132 +++++++++++++++++++
 src/nes/apu/square.rs          | 234 +++++++++++++++++++++++++++++++++
 src/nes/bus/cpu_bus.rs         |   8 +-
 src/nes/cassette_paser/mod.rs  |   7 +-
 src/nes/mod.rs                 |  10 +-
 src/nes/webaudio/noise.js      |  59 +++++++++
 src/nes/webaudio/oscillator.js |  97 ++++++++++++++
 12 files changed, 579 insertions(+), 7 deletions(-)
 create mode 100644 roms/apu/test_apu_env.nes
 create mode 100644 src/nes/apu/constants.rs
 create mode 100644 src/nes/apu/mod.rs
 create mode 100644 src/nes/apu/square.rs
 create mode 100644 src/nes/webaudio/noise.js
 create mode 100644 src/nes/webaudio/oscillator.js

diff --git a/index.html b/index.html
index ef031bb..cf0b714 100644
--- a/index.html
+++ b/index.html
@@ -61,6 +61,8 @@
         <li>→ →</li>
       </ul>
     </div>
+    <script type="module" src="./src/nes/webaudio/oscillator.js"></script>
+    <script type="module" src="./src/nes/webaudio/noise.js"></script>
     <script type="module" src="./init.js"></script>
     <script type="module" src="./main.js"></script>
     <script type="module">
diff --git a/main.js b/main.js
index 5d7f585..f50af3b 100644
--- a/main.js
+++ b/main.js
@@ -1,4 +1,4 @@
-
+import Oscillator from './src/nes/webaudio/oscillator.js'
 let buf = null
 
 const convertKeyCode = (key) => {
@@ -38,10 +38,14 @@ const startArrayBuf = (arrayBuf) => {
   const run = Module.cwrap('run', null, ['number', 'number'])
   const canvas = document.querySelector('canvas')
   const ctx = canvas.getContext('2d')
+  if (Module.NES) {
+    Module.NES.oscs.forEach(o => o.close());
+  }
   Module.NES = {
     ctx,
     canvas,
     image: ctx.createImageData(256, 240),
+    oscs: [new Oscillator(), new Oscillator()],
   }
   canvas.width = 256
   canvas.height = 240
@@ -58,7 +62,7 @@ const startArrayBuf = (arrayBuf) => {
 }
 
 // called from html
-export const start = async (rom = './roms/nestest.nes') => {
+export const start = async (rom = './roms/apu/test_apu_env.nes') => {
   const res = await fetch(rom);
   const arrayBuf = await res.arrayBuffer();
   startArrayBuf(arrayBuf);
diff --git a/roms/apu/test_apu_env.nes b/roms/apu/test_apu_env.nes
new file mode 100644
index 0000000000000000000000000000000000000000..636ba59ef2891e68578ad210f58d3872832801e9
GIT binary patch
literal 16400
zcmeIup-Mwx7zW@oEyf|p#Nyg+Vev1543WX&U>MyU>=IT^UmUj2t1zGR7yF-=1dA-}
z?9AdVIC$Rhg_pN{&-26Vu2=n~6#@hZ5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAVA>k1y<1xCnb9IO^T0ta5@)h+mEaIGR3g2(%UrBsULN-CVxl2>o)Jd+a~|4^Jm<5
z&C|R*#`So&TORWM^>*3jua~Y%XYb<y0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
Q1PBly@V^BXr7DYZ1kDVQ8vp<R

literal 0
HcmV?d00001

diff --git a/src/externs/lib.js b/src/externs/lib.js
index 1a53897..2df0456 100644
--- a/src/externs/lib.js
+++ b/src/externs/lib.js
@@ -4,4 +4,22 @@ mergeInto(LibraryManager.library, {
     Module.NES.image.data.set(Module.NES.buf);
     Module.NES.ctx.putImageData(Module.NES.image, 0, 0);
   },
+  start_oscillator: function (index) {
+    Module.NES.oscs[index].start()
+  },
+  stop_oscillator: function (index) {
+    Module.NES.oscs[index].stop()
+  },
+  set_oscillator_frequency: function (index, freq) {
+    Module.NES.oscs[index].setFrequency(freq)
+  },
+  change_oscillator_frequency: function (index, freq) {
+    Module.NES.oscs[index].changeFrequency(freq)
+  },
+  set_oscillator_volume: function (index, volume) {
+    Module.NES.oscs[index].setVolume(volume)
+  },
+  set_oscillator_duty: function (index, duty) {
+    Module.NES.oscs[index].setDuty(duty)
+  }
 });
diff --git a/src/nes/apu/constants.rs b/src/nes/apu/constants.rs
new file mode 100644
index 0000000..7d1a894
--- /dev/null
+++ b/src/nes/apu/constants.rs
@@ -0,0 +1,11 @@
+pub const CPU_CLOCK: usize = 1789772;
+
+pub const DIVIDE_COUNT_FOR_240HZ: u16 = 7457;
+
+// ref. http://pgate1.at-ninja.jp/NES_on_FPGA/nes_apu.htm
+pub const COUNTER_TABLE: &'static [u8] = &[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];
+
+pub const GROBAL_GAIN: f32 = 0.1;
\ No newline at end of file
diff --git a/src/nes/apu/mod.rs b/src/nes/apu/mod.rs
new file mode 100644
index 0000000..95b051a
--- /dev/null
+++ b/src/nes/apu/mod.rs
@@ -0,0 +1,132 @@
+mod square;
+mod constants;
+
+use self::constants::*;
+use self::square::Square;
+use super::types::{Data, Addr};
+
+#[derive(Debug)]
+pub struct Apu {
+  squares: (Square, Square),
+  cycle: u16,
+  step: usize,
+  sequencer_mode: bool, // t => mode 1, f => mode 0
+  enable_irq: bool,
+}
+
+impl Apu {
+  pub fn new() -> Self {
+    Apu {
+      squares: (Square::new(0), Square::new(1)),
+      cycle: 0,
+      step: 0,
+      sequencer_mode: false,
+      enable_irq: false,
+    }
+  }
+  pub fn run(&mut self, cycle: u16) {
+    self.cycle += cycle;
+    if self.cycle >= DIVIDE_COUNT_FOR_240HZ {
+      // TODO: invoked by 240hz
+      self.cycle -= DIVIDE_COUNT_FOR_240HZ;
+      if self.sequencer_mode {
+        self.update_by_sequence_mode1();
+      } else {
+        self.update_by_sequence_mdoe0();
+      }
+    }
+  }
+
+  // step 4
+  fn update_by_sequence_mdoe0(&mut self) {
+    if self.step % 2 == 1 {
+      self.update_counters();
+    }
+    self.step += 1;
+    if self.step == 4 {
+      if self.enable_irq {
+        // TODO:
+      }
+      self.step = 0;
+    }
+    self.update_envelope();
+  }
+
+  // step 5
+  fn update_by_sequence_mode1(&mut self) {
+    if self.step % 2 == 0 {
+      self.update_counters();
+    }
+    self.step += 1;
+    if self.step == 5 {
+      self.step = 0;
+    } else {
+      self.update_envelope();
+    }
+  }
+
+  // generate envelope & linear clock
+  fn update_envelope(&mut self) {
+    self.squares.0.update_envelope();
+    self.squares.1.update_envelope();
+  }
+
+  // generate length counter & sweep ckock
+  fn update_counters(&mut self) {
+    self.squares.0.update_counters();
+    self.squares.1.update_counters();
+  }
+
+  pub fn read(&mut self, addr: Addr) -> Data {
+    match addr {
+      0x15 => {
+        let s0 = if self.squares.0.has_count_end() {
+          0x00
+      } else {
+          0x01
+      };
+      let s1 = if self.squares.1.has_count_end() {
+          0x00
+      } else {
+          0x02
+      };
+      s1 | s0
+      }
+    _ => 0,
+    }
+  }
+
+  pub fn write(&mut self, addr: Addr, data: Data) {
+    match addr {
+      0x00..=0x03 => {
+        self.squares.0.write(addr, data);
+      }
+      0x04..=0x07 => {
+        self.squares.1.write(addr - 0x04, data);
+      }
+      0x08..=0x0b => {
+      }
+      0x0c..=0x0f => {
+      }
+      0x15 => {
+        if data & 0x01 == 0x01 {
+          self.squares.0.enable();
+        } else {
+          self.squares.0.disable();
+        }
+        if data & 0x02 == 0x02 {
+          self.squares.1.enable();
+        } else {
+          self.squares.1.disable();
+        }
+      }
+      0x17 => {
+        self.sequencer_mode = data & 0x80 == 0x80;
+        self.enable_irq = data & 0x40 != 0x40; // actually it keeps wherer irq is disabled
+        self.step = 0;
+        self.cycle = 0;
+      }
+      _ => (),
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/nes/apu/square.rs b/src/nes/apu/square.rs
new file mode 100644
index 0000000..b35a32f
--- /dev/null
+++ b/src/nes/apu/square.rs
@@ -0,0 +1,234 @@
+use super::constants::*;
+use super::super::types::{Data, Addr};
+
+#[derive(Debug)]
+pub struct Square {
+  index: usize,
+  // $4000
+  is_length_counter_enabled: bool,
+  is_envelope_enabled: bool,
+  is_envelope_loop_enabled: bool,
+  envelope_period_and_volume: usize,
+  // $4001
+  is_sweep_enabled: bool,
+  sweep_unit_divider: usize,
+  is_sweep_direction_upper: bool,
+  sweep_shift_amount: usize,
+  // $4003 &0x04 << 8 | $4002
+  divider_frequency: usize,
+  length_counter: usize,
+
+  frequency: usize,
+  sweep_unit_counter: usize,
+  envelope_generator_counter: usize,
+  envelope_volume: usize,
+  is_sweep_overflowed: bool,
+  enabled: bool,
+  playing: bool,
+}
+
+extern "C" {
+  fn start_oscillator(index: usize);
+  fn stop_oscillator(index: usize);
+  fn set_oscillator_frequency(index: usize, freq: usize);
+  fn change_oscillator_frequency(index: usize, freq: usize);
+  fn set_oscillator_volume(index: usize, volume: f32);
+  fn set_oscillator_duty(index: usize, duty: f32);
+
+}
+
+impl Square {
+  pub fn new(index: usize) -> Self {
+    Square {
+      index,
+      is_length_counter_enabled: false,
+      is_envelope_enabled: false,
+      is_envelope_loop_enabled: false,
+      envelope_period_and_volume: 0x0F,
+      is_sweep_enabled: false,
+      sweep_unit_divider: 1,
+      is_sweep_direction_upper: true,
+      sweep_shift_amount: 0,
+      divider_frequency: 1,
+      length_counter: 0,
+
+      frequency: 0,
+      sweep_unit_counter: 0,
+      envelope_generator_counter: 0,
+      envelope_volume: 0,
+      is_sweep_overflowed: false,
+      enabled: false,
+      playing: false,
+    }
+  }
+
+  pub fn write(&mut self, addr: Addr, data: Data) {
+    match addr {
+      0x00 => {
+        let duty = (data >> 6) & 0x3;
+        self.is_envelope_loop_enabled = (data & 0x20) == 0x20;
+        self.is_length_counter_enabled = !self.is_envelope_loop_enabled; // opposite loop flag
+        self.is_envelope_enabled = (data & 0x10) != 0x10; //actually register keep loop is disabled on nes
+        self.envelope_period_and_volume = data as usize & 0x0F;
+        unsafe {
+          set_oscillator_volume(self.index, self.get_volume());
+          set_oscillator_duty(self.index, self.get_duty(duty as usize));
+        }
+      }
+      0x01 => {
+        self.is_sweep_enabled = data & 0x80 == 0x80;
+        self.sweep_unit_divider = ((data as usize >> 4) & 0x07) + 1;
+        self.is_sweep_direction_upper = data & 0x08 == 0x80;
+        self.sweep_shift_amount = data as usize & 0x07;
+      }
+      0x02 => {
+        self.divider_frequency = (self.divider_frequency & 0x700) | data as usize;
+        self.is_sweep_overflowed = false;
+        self.update_frequency();
+        self.change_frequency();
+      }
+      0x03 => {
+        self.divider_frequency &= 0xFF;
+        self.divider_frequency |= (data as usize & 0x7) << 8;
+        self.is_sweep_overflowed = false;
+        if self.is_length_counter_enabled {
+          self.length_counter = COUNTER_TABLE[(data & 0xF8) as usize >> 3] as usize / 2;
+        }
+        self.update_frequency();
+        self.sweep_unit_counter = 0;
+        // envelope
+        self.envelope_generator_counter = self.envelope_period_and_volume;
+        self.envelope_volume = 0x0F;
+        if self.enabled {
+            self.start();
+        }
+      }
+      _ => ()
+    }
+  }
+
+  fn change_frequency(&self){
+    unsafe {
+      change_oscillator_frequency(self.index, self.frequency);
+    }
+  }
+
+  pub fn update_frequency(&mut self) {
+    self.frequency = CPU_CLOCK / ((self.divider_frequency + 1) * 16) as usize;
+  }
+
+  pub fn enable(&mut self) {
+    self.enabled = true;
+    self.start();
+  }
+
+  pub fn disable(&mut self) {
+    self.enabled = false;
+    self.stop();
+  }
+
+  pub fn start(&mut self) {
+    if !self.playing {
+      self.playing = true;
+      unsafe {
+        start_oscillator(self.index);
+        set_oscillator_frequency(self.index, self.frequency);
+      };
+    } else {
+      self.change_frequency();
+    }
+  }
+
+  pub fn stop(&mut self) {
+    if self.playing {
+      self.playing = false;
+      unsafe {
+        stop_oscillator(self.index);
+      };
+    }
+  }
+
+  pub fn has_count_end(&self) -> bool {
+    self.length_counter == 0
+  }
+
+  // Length counter
+  // Excitated by divider
+  // When clocked by the frame counter, the length counter is decremented except when:
+  // The length counter is 0, or The halt flag is set
+  pub fn update_counters(&mut self ) {
+    if self.is_length_counter_enabled && self.length_counter > 0 {
+      self.length_counter -= 1;
+      if self.length_counter == 0 {
+          self.stop();
+      }
+    }
+
+    if !self.is_sweep_enabled || !self.playing {
+      return;
+    };
+
+    self.sweep_unit_counter += 1;
+    if self.sweep_unit_counter % self.sweep_unit_divider == 0 {
+        self.sweep_unit_counter = 0;
+
+        if self.is_sweep_direction_upper {
+            self.divider_frequency = self.divider_frequency -
+                                         (self.divider_frequency >>
+                                          self.sweep_shift_amount);
+        } else {
+            self.divider_frequency = self.divider_frequency +
+                                         (self.divider_frequency >>
+                                          self.sweep_shift_amount);
+
+        };
+        if self.divider_frequency > 0x7FF || self.divider_frequency < 8 {
+          self.is_sweep_overflowed = true;
+          self.stop();
+        }else {
+          self.is_sweep_overflowed = false;
+        }
+        self.update_frequency();
+        self.change_frequency();
+    }
+  }
+
+  // divider Excitation
+  pub fn update_envelope(&mut self) {
+    self.envelope_generator_counter -= 1;
+    if self.envelope_generator_counter <= 0 {
+      self.envelope_generator_counter = self.envelope_period_and_volume;
+      if self.envelope_volume > 0 {
+        self.envelope_volume -= 1;
+      } else {
+        self.envelope_volume = if self.is_envelope_loop_enabled {
+          0x0F
+        } else {
+          0x00
+        };
+      }
+    }
+    unsafe {
+      set_oscillator_volume(self.index, self.get_volume());
+    }
+  }
+
+  fn get_volume(&self) -> f32 {
+    let vol = if !self.is_envelope_enabled || self.is_sweep_overflowed || self.length_counter == 0 || self.divider_frequency < 8{
+      self.envelope_period_and_volume
+    } else {
+      self.envelope_volume
+    };
+    vol as f32 / (GROBAL_GAIN)
+  }
+
+  pub fn get_duty(&self, duty: usize) -> f32 {
+    match duty {
+      0x00 => 0.125,
+      0x01 => 0.25,
+      0x02 => 0.5,
+      0x03 => 0.75,
+      _ => 0.0,
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/nes/bus/cpu_bus.rs b/src/nes/bus/cpu_bus.rs
index 40ecf02..dc2694c 100644
--- a/src/nes/bus/cpu_bus.rs
+++ b/src/nes/bus/cpu_bus.rs
@@ -1,4 +1,5 @@
 use super::super::types::{Data, Addr, Word};
+use super::super::apu::Apu;
 use super::super::dma::Dma;
 use super::super::ppu::Ppu;
 use super::super::ram::Ram;
@@ -6,6 +7,7 @@ use super::super::rom::Rom;
 use super::super::keypad::Keypad;
 
 pub struct Bus<'a> {
+  apu: &'a mut Apu,
   program_rom: &'a Rom,
   work_ram: &'a mut Ram,
   ppu: &'a mut Ppu,
@@ -21,6 +23,7 @@ pub trait CpuBus {
 
 impl<'a> Bus<'a> {
   pub fn new(
+    apu: &'a mut Apu,
     program_rom: &'a Rom,
     work_ram: &'a mut Ram,
     ppu: &'a mut Ppu,
@@ -28,6 +31,7 @@ impl<'a> Bus<'a> {
     keypad: &'a mut Keypad,
   ) -> Bus<'a> {
     Self {
+      apu,
       program_rom,
       work_ram,
       ppu,
@@ -50,7 +54,7 @@ impl<'a> CpuBus for Bus<'a> {
       0x2000..=0x3FFF => self.ppu.read(addr - 0x2000),
       0x4016 => self.keypad.read(),
       0x4017 => 0, // TODO: 2player
-      0x4000...0x401F => 0, // TODO: apu
+      0x4000..=0x401F => self.apu.read(addr - 0x4000),
       0x6000..=0x7FFF => {
         println!("Not implemented. This area is battery backup ram area 0x{:x}", addr );
         0
@@ -70,7 +74,7 @@ impl<'a> CpuBus for Bus<'a> {
       0x2000..=0x3FFF => self.ppu.write(addr - 0x2000, data),
       0x4014 => self.dma.write(data),
       0x4016 => self.keypad.write(data),
-      0x4000..=0x401F => (), // TODO: apu
+      0x4000..=0x401F => self.apu.write(addr - 0x4000, data),
       0x6000..=0x7FFF => {
         println!("Not implemented. This area is battery backup ram area 0x{:x}", addr );
       }
diff --git a/src/nes/cassette_paser/mod.rs b/src/nes/cassette_paser/mod.rs
index ea2c03f..caf770b 100644
--- a/src/nes/cassette_paser/mod.rs
+++ b/src/nes/cassette_paser/mod.rs
@@ -28,10 +28,15 @@ pub fn parse(buf: &mut [Data]) -> Cassette {
   println!("mapper type is {}", mapper);
   let character_rom_start = NES_HEADER_SIZE + program_rom_pages * PROGRAM_ROM_SIZE;
   let character_rom_end = character_rom_start + character_rom_pages * CHARACTER_ROM_SIZE;
+  let c_ram = if character_rom_start != character_rom_end {
+    buf[character_rom_start..character_rom_end].to_vec()
+  } else {
+    vec!(0;0x128)
+  };
   Cassette {
     is_horizontal_mirror,
     program_rom: buf[NES_HEADER_SIZE..character_rom_start].to_vec(),
-    character_ram: buf[character_rom_start..character_rom_end].to_vec(),
+    character_ram: c_ram,
     mapper,
   }
 }
\ No newline at end of file
diff --git a/src/nes/mod.rs b/src/nes/mod.rs
index 9b3534f..3414eae 100644
--- a/src/nes/mod.rs
+++ b/src/nes/mod.rs
@@ -1,3 +1,4 @@
+mod apu;
 mod bus;
 mod cassette_paser;
 mod cpu;
@@ -11,6 +12,7 @@ mod rom;
 mod ppu;
 mod renderer;
 
+pub use self::apu::*;
 pub use self::renderer::*;
 pub use self::keypad::*;
 use self::bus::cpu_bus;
@@ -18,12 +20,13 @@ use self::ram::Ram;
 use self::rom::Rom;
 use self::ppu::*;
 use self::dma::*;
-use self::types::{Data, Addr, Word};
+pub use self::types::{Data, Addr, Word};
 
 const DMA_CYCLES: u16 = 514;
 
 #[derive(Debug)]
 pub struct Context {
+  apu: Apu,
   work_ram: Ram,
   ppu: Ppu,
   program_rom: Rom,
@@ -36,6 +39,7 @@ pub struct Context {
 
 pub fn reset(ctx: &mut Context) {
   let mut cpu_bus = cpu_bus::Bus::new(
+    &mut ctx.apu,
     &ctx.program_rom,
     &mut ctx.work_ram,
     &mut ctx.ppu,
@@ -53,6 +57,7 @@ pub fn run(ctx: &mut Context, key_state: Data){
       DMA_CYCLES
     } else {
       let mut cpu_bus = cpu_bus::Bus::new(
+        &mut ctx.apu,
         &ctx.program_rom,
         &mut ctx.work_ram,
         &mut ctx.ppu,
@@ -61,7 +66,7 @@ pub fn run(ctx: &mut Context, key_state: Data){
       );
       cpu::run(&mut ctx.cpu_register, &mut cpu_bus, &mut ctx.nmi) as Word
     };
-
+    ctx.apu.run(cycle);
     let is_ready = ctx.ppu.run((cycle * 3) as usize, &mut ctx.nmi);
     if is_ready {
       if ctx.ppu.background.0.len() != 0 {
@@ -76,6 +81,7 @@ impl Context {
   pub fn new(buf: &mut [Data]) -> Self {
     let cassette = cassette_paser::parse(buf);
     Context {
+      apu: Apu::new(),
       cpu_register: cpu_register::Register::new(),
       program_rom: Rom::new(cassette.program_rom),
       ppu: Ppu::new(
diff --git a/src/nes/webaudio/noise.js b/src/nes/webaudio/noise.js
new file mode 100644
index 0000000..cf13f29
--- /dev/null
+++ b/src/nes/webaudio/noise.js
@@ -0,0 +1,59 @@
+export default class Noise {
+  constructor () {
+    try {
+      const AudioContext = window.AudioContext || window.webkitAudioContext
+      this.context = new AudioContext();
+    } catch (e) {
+      throw new Error('Web Audio isn\'t supported in this browser!');
+    }
+    this.createSource()
+    this.playing = false
+  }
+
+  createSource() {
+    const node = this.context.createBufferSource()
+    const buffer = this.context.createBuffer(1, this.context.sampleRate, this.context.sampleRate)
+    const data = buffer.getChannelData(0)
+    for (let i = 0; i < this.context.sampleRate; i++) {
+      data[i] = Math.random();
+    }
+    node.buffer = buffer
+    node.loop = true
+    this.gain = this.context.createGain()
+    this.gain.gain.value = 0.01
+    node.connect(this.gain)
+    this.bandpass = this.context.createBiquadFilter()
+    this.gain.connect(this.bandpass)
+    this.bandpass.connect(this.context.destination)
+    this.source = node
+    this.setVolume(0)
+  }
+
+  setVolume (v) {
+    v = Math.max(0, Math.min(1, v))
+    this.gain.gain.value = v
+  }
+
+  setFrequency (f) {
+    this.bandpass.frequency.value = frequency > 22050 ? 22050 : f
+  }
+
+  start () {
+    if (!this.playing) {
+      this.playing = true
+      this.source.start(0)
+    }
+  }
+
+  stop() {
+    if (this.playing) {
+      this.playing = false
+      this.source.stop()
+      this.createSource()
+    }
+  }
+
+  close() {
+    this.context.close()
+  }
+}
\ No newline at end of file
diff --git a/src/nes/webaudio/oscillator.js b/src/nes/webaudio/oscillator.js
new file mode 100644
index 0000000..26641fd
--- /dev/null
+++ b/src/nes/webaudio/oscillator.js
@@ -0,0 +1,97 @@
+
+export default class Oscillator {
+  constructor (type) {
+    try {
+      const AudioContext = window.AudioContext || window.webkitAudioContext
+      this.context = new AudioContext()
+    } catch (e) {
+      throw new Error('Web Audio isn\'t supported in this browser!')
+    }
+    this.type = type || 'square'
+    this.oscillator = this.createOscillator({kind: this.type})
+
+    this.setVolume(0)
+    this.setDuty(0.5)
+    this.playing = false
+  }
+
+  start () {
+    if (this.playing) {
+      this.stop()
+    }
+    this.playing = true
+    this.oscillator.start(0)
+  }
+
+  stop () {
+    if (this.stop) {
+      this.setVolume(0)
+      this.playing = false
+      this.oscillator.stop(this.context.currentTime)
+      this.oscillator = this.createOscillator()
+      this.setDuty(0.5)
+    }
+  }
+
+  close () {
+    this.context.close()
+  }
+
+  createOscillator(options = {}) {
+    const oscillator = this.context.createOscillator()
+    if (options.kind) {
+      if (options.kind == 'square') {
+        oscillator.type = 'sawtooth'
+      } else {
+        oscillator.type = options.kind
+      }
+    }
+
+    if (options.frequency) oscillator.frequency.value = options.frequency
+    if (options.harmonics) {
+      const waveform = this.context.createPeriodicWave(
+        new Float32Array(options.harmonics.real),
+        new Float32Array(options.harmonics.imag)
+      )
+      oscillator.setPeriodicWave(waveform);
+    }
+    var inverter = this.context.createGain() // for square
+    inverter.gain.value = -1
+    this.delay = this.context.createDelay() // for duty
+    this.duty = 0.5
+
+    this.gain = this.context.createGain()
+    this.gain.gain.volume = 0.01
+    this.gain.gain.value = 1
+    oscillator.connect(inverter)
+    oscillator.connect(this.gain)
+    inverter.connect(this.delay)
+    this.delay.connect(this.gain)
+    this.gain.connect(this.context.destination)
+    return oscillator
+  }
+
+  setDuty(duty) {
+    this.duty = duty
+    this.changeDuty()
+  }
+
+  changeDuty(freq = this.oscillator.frequency.value) {
+    this.delay.delayTime.value = (1.0 - this.duty) / (freq + 0.00000001)
+  }
+
+  setFrequency (frequency) {
+    this.oscillator.frequency.value = frequency
+    this.changeDuty()
+  }
+
+  changeFrequency (frequency) {
+    this.oscillator.frequency.setValueAtTime(frequency, this.context.currentTime)
+    this.changeDuty(frequency)
+  }
+
+  setVolume (volume) {
+    volume = Math.max(0, Math.min(1, volume))
+    this.gain.gain.value = volume
+  }
+}
\ No newline at end of file