n65 0.5.0

data/utils/midi/Makefile

@@ -0,0 +1,3 @@
+
+build: convert
+	clang++ source/*.cpp -I include -o convert

data/utils/midi/include/event.h

@@ -0,0 +1,93 @@
+#ifndef MIDI_EVENT_H
+#define MIDI_EVENT_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "helpers.h"
+
+namespace Midi {
+
+enum MidiMessageType {Midi = 0, MidiNoteOff = 0x8, MidiNoteOn, MidiPolyAftertouch, 
+                      MidiControlChange, MidiProgramChange,    MidiChannelAftertouch, 
+                      MidiPitchWheel,    MidiMetaEvent = 0xFF, MidiSysex1 = 0xF0, MidiSysex2 = 0xF7};
+
+
+enum MidiMetaType {MetaSequenceNumber = 0x0, MetaTextEvent = 0x1,      MetaCopyright = 0x2,
+                   MetaTrackName  = 0x3,     MetaInstrumentName = 0x4, MetaLyricText = 0x5,
+                   MetaMarkerText = 0x6,     MetaCuePoint = 0x7,       MetaChannelPrefixAssignment = 0x20,
+                   MetaEndOfTrack = 0x2F,    MetaTempoSetting = 0x51,  MetaSMPTEOffset = 0x54,
+                   MetaTimeSignature = 0x58, MetaKeySignature = 0x59,  MetaSequenceSpecific = 0x7F};
+
+/***
+ *   Spec:
+ *   MidiTrackEvent = <delta_time (Variable)> + <MidiEvent> | <MetaEvent> | <SysexEvent>
+ *   MidiEvent = <MidiMessageType (4 bits)>  + <channel (4 bits)> + <parameter1 (1 byte)> <parameter2 (1 byte)>
+ *   MetaEvent = 0xFF + <MidiMetaType> + <size (Variable)> + <data>
+ *   SysexEvent = 0xF0 + <data> + 0xF7  -or- 
+ *   SysexEvent = 0xF7 + <data> 0xF7
+ ***/
+
+class Event {
+    private:
+    unsigned int  m_delta;
+    unsigned int  m_size;
+    unsigned int  m_data_size;
+    unsigned char m_status;
+    unsigned char m_meta_type;
+    unsigned char m_parameter1;
+    unsigned char m_parameter2;
+    void *m_data;
+
+    public:
+    Event();
+    Event(int delta, int status, int parameter1, int parameter2);
+    void init_midi(int delta, int status, int parameter1, int parameter2);
+    void init_from_file(FILE *fp, unsigned char last_status);
+    ~Event();
+
+    //  Some easy inline functions
+    static bool is_status_byte(unsigned char byte) { return ((byte & 0x80) >> 7) == 1; } 
+    unsigned int delta() const { return m_delta; }
+    unsigned char status() const { return m_status; }
+    unsigned int bytes_read() const { return m_size; }
+    unsigned char parameter1() const { return m_parameter1; }
+    unsigned char parameter2() const { return m_parameter2; }
+    int message_type() const { return (m_status &0xF0) >> 4; }
+    int channel() const { return (m_status &0xF); }
+    void *sysex_data() const { return m_data; }
+
+
+    void print_yaml(){
+      printf("      - :delta: 0x%X\n", m_delta);
+      printf("        :status: 0x%X\n", m_status);
+
+      switch(m_status){ 
+        case 0xFF: 
+          printf("        :meta_type: 0x%X\n", m_meta_type);
+          printf("        :meta_data_size: 0x%X\n", m_data_size);
+          break;
+        case 0xF0: 
+        case 0xF7: 
+          printf("        :sysex_data_size: %d\n", m_data_size);
+          break;
+        default: 
+          printf("        :parameter1: 0x%X\n", m_parameter1);
+          printf("        :parameter2: 0x%X\n", m_parameter2);
+      }
+      /*  Printing out the actual data as a string confuses the YAML parser
+       *  So let's just not do that.
+      if(m_data){
+        printf("        :data: \"");
+
+        for(int i = 0; i < m_data_size; i++){ 
+          printf("%c", ((unsigned char*)m_data)[i]); 
+        } 
+        printf("\"\n");
+      }
+      */
+    }
+};
+
+}
+
+#endif

data/utils/midi/include/file.h

@@ -0,0 +1,57 @@
+#ifndef MIDI_FILE_H
+#define MIDI_FILE_H
+
+#include <vector>
+#include "track.h"
+
+namespace Midi {
+
+/***
+ *   Spec:
+ *   MidiFile = <midi_header_t> + <MidiTrack> [+ <MidiTrack> ...]
+ *
+ *   midi_header_t = "MThd" + <size (4 bytes)> + <format (2 bytes)> + <track_count (2 bytes)> + <ticks_per_quarter_note (2 bytes)>
+ *
+ ***/
+
+typedef struct midi_header_t {
+    char cookie[4];
+    unsigned int  size;
+    unsigned short format;
+    unsigned short track_count;
+    unsigned short ticks_per_quarter_note;
+} __attribute__((packed)) midi_header_t;
+
+
+class File {
+    private:
+    midi_header_t m_header;
+
+    public:
+    File(void);
+    ~File(void);
+    std::vector<Track *> m_tracks;
+    void init_from_file(const char *filename);
+
+    void print_yaml(){
+      printf("---\n");
+      printf(":midi_file:\n");
+      printf("  :header: Mthd\n");
+      printf("  :size: %u\n", m_header.size);
+      printf("  :format: %u\n", m_header.format);
+      printf("  :track_count: %u\n", m_header.track_count);
+      printf("  :ticks_per_quarter_note: %u\n", m_header.ticks_per_quarter_note);
+      printf("  :tracks:\n");
+
+      for(int i = 0; i < m_tracks.size(); i++){
+        if(i == 0){
+          m_tracks[i]->print_yaml(); 
+        }else{
+          m_tracks[i]->print_yaml(); 
+        }
+      }
+    }
+};
+
+}
+#endif

data/utils/midi/include/helpers.h

@@ -0,0 +1,14 @@
+#ifndef MIDI_HELPERS_H
+#define MIDI_HELPERS_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace Midi {
+
+unsigned int read_variable_length(FILE *fp, unsigned int *value_size);
+short swap_endian_16(short big_endian);
+int swap_endian_32(int big_endian);
+
+}
+#endif

data/utils/midi/include/track.h

@@ -0,0 +1,45 @@
+#ifndef MIDI_TRACK_H
+#define MIDI_TRACK_H
+
+#include "event.h"
+#include <vector>
+
+namespace Midi {
+
+/***
+ *   Spec:
+ *   MidiTrack = <midi_track_header_t> + <MidiEvent> [+ <MidiEvent> ...]
+ *   midi_track_header_t = "MTrk" + <size (4 bytes)>
+ *
+ ***/
+
+typedef struct midi_track_header_t {
+    char cookie[4];
+    unsigned int size;
+} __attribute__((packed)) midi_track_header_t;
+
+
+class Track {
+    private:
+    unsigned int m_total_size;
+    midi_track_header_t m_header;
+
+    public:
+    Track(void);
+    ~Track(void);
+    void init_from_file(FILE *fp);
+    std::vector<Event *> m_events;
+
+    void print_yaml(){
+      printf("    - :header: MTrk\n");
+      printf("      :total_size: %u\n", m_header.size);
+      printf("      :events:\n");
+
+      for(int i = 0; i < m_events.size(); i++){ 
+        m_events[i]->print_yaml(); 
+      } 
+    }
+};
+
+}
+#endif

data/utils/midi/midi_to_nes.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+
+class MidiToNES
+
+  ####  Custom Exceptions
+  class MidiFormatNotSupported < StandardError; end
+
+  ####  Some Constants
+  NoteOff = 0x8
+  NoteOn  = 0x9
+
+  ####  A440 Tuning, and NES CPU speed in hz
+  Tuning = 440.0
+  CPU    = 1789773.0
+
+
+  ####  LSB Address registers of the APU, MSB is always 0x40
+  Pulse1Control = 0x00
+  Pulse1FT = 0x2
+  Pulse1CT = 0x3
+
+
+  ####
+  ##  Initialize from a yaml file
+  def self.init_from_file(filename, bpm)
+    self.new(File.read(filename), bpm)
+  end
+
+
+  ####
+  ##  Initialize with a yaml string
+  def initialize(yaml_string, bpm)
+    @bpm = bpm.to_f
+    @midi_data = YAML.load(yaml_string)[:midi_file]
+    unless @midi_data[:format].zero?
+      fail(MidiFormatNotSupported, "Currently only supports format 0 Midi Files")
+    end
+    @ticks_per_quarter_note = @midi_data[:ticks_per_quarter_note]
+  end
+
+
+  ####
+  ##  Write to binary file
+  def write_binary(filename)
+    binary = convert
+    File.open(filename, 'wb') do |fp|
+      fp.write(binary)
+    end
+  end
+
+
+  ####
+  ##  For now assume one track
+  def convert
+    tick_count = 1
+    events = []
+
+    track = @midi_data[:tracks].first
+    track[:events].each do |event|
+
+      delta, status, note, velocity = event.values_at(:delta, :status, :parameter1, :parameter2)
+
+      ##  The status byte contains both the Midi message type, and channel.
+      type =   (status & 0b11110000) >> 4
+      channel = status & 0b00001111
+
+      ##  We only care about note on and off, and only care about channel 0 for now.
+      next unless type == NoteOn || type == NoteOff
+      next unless channel.zero?
+
+      ##  Update the total time
+      tick_count += delta
+
+      ##  Ok this is a note either turning on or off
+      if type == NoteOff || velocity.zero?
+        #event = {:start => tick_count, :note => note, :velocity => 0}
+        #events << event
+      else
+        event = {:start => tick_count, :note => note, :velocity => velocity}
+        events << event
+      end
+    end
+
+    ##  Finally sort event list by start time
+    events.sort! do |a, b|
+      a[:start] <=> b[:start]
+    end
+
+    ##  Now convert these events to a bytestream for our NES sound engine
+    events_to_byte_stream(events)
+  end
+
+
+  ####
+  ##  This converts a list of note events into a byte stream for updating NES APU registers
+  def events_to_byte_stream(events)
+    last_tick = 1
+    byte_stream = []
+
+    events.each do |event|
+      ##  Work out the delta again
+      delta = event[:start] - last_tick
+      byte_stream << midi_tick_to_vblank(delta)   #  Delta
+      byte_stream << pulse_control_value(event)   #  Value
+      if event[:velocity].zero?
+        #byte_stream << 0                          #  Off with 0 frequency timer
+        #byte_stream << 0
+      else
+        byte_stream << pulse_ft_value(event)      #  Value
+        byte_stream << pulse_ct_value(event)      #  Value
+      end
+      last_tick += delta
+    end
+    byte_stream.pack('C*')
+  end
+
+
+  ####
+  ##  Given an event, produce a value for register nes.apu.pulse1.control
+  ##  DDLC VVVV 
+  ##  Duty (D), envelope loop / length counter halt (L), constant volume (C), volume/envelope (V)
+  def pulse_control_value(event)
+    ##  Start with 50% duty cycle, length counter halt is on
+    ##  Constant volume is On, and volume is determined by bit-reducing the event velocity to 4-bit
+    value = 0b10000111         
+
+    #four_bit_max  = (2**4 - 1)
+    #seven_bit_max = (2**7 - 1)
+
+    #volume_float = event[:velocity] / seven_bit_max.to_f
+    #volume_4_bit = (volume_float * four_bit_max).round & 0b00001111
+
+    #value | volume_4_bit
+  end
+
+
+  ####
+  ##  Given an event, produce a value for register nes.apu.pulse1.ft
+  ##  TTTT TTTT
+  ##  This is the low byte of the timer, the higher few bits being in pulse1.ct
+  def pulse_ft_value(event)
+    midi_note_to_nes_timer(event[:note]) & 0xff
+  end
+
+
+  ####
+  ##  Given an event, produce a value for register nes.apu.pulse1.ct
+  ##  LLLL LTTT
+  ##  This has the higher 3 bits of the timer, and L is the length counter.
+  ##  For now let's just use duration as the length counter.
+  def pulse_ct_value(event)
+    value = 0b11111000
+
+    ##  We will grab the high 3 bits of the 11-bit timer value now
+    timer_high_3bit = midi_note_to_nes_timer(event[:note]) & 0b11100000000
+    value | (timer_high_3bit >> 8)
+  end
+
+
+  ####
+  ##  Midi note to NES timer
+  def midi_note_to_nes_timer(midi_note)
+    frequency = Tuning * 2**((midi_note - 69) / 12.0)
+    timer = (CPU / (16 * frequency)) - 1
+    if timer > (2**11 - 1)
+      fail("midi note #{midi_note} is too big at #{timer}")
+    end
+    timer.round
+  end
+
+
+  ####
+  ##  Convert a MIDI tick delta to an NES vblank delta.
+  def midi_tick_to_vblank(midi_tick)
+    quarter_note_in_seconds = 60 / @bpm
+    vblanks_per_quarter_note = quarter_note_in_seconds / (1/60.0)
+    tick_normalized = midi_tick / @ticks_per_quarter_note.to_f
+    vblanks = tick_normalized * vblanks_per_quarter_note
+    vblanks.round
+  end
+
+end
+
+if __FILE__ == $0
+  unless ARGV.size == 2
+    STDERR.puts("Usage #{$0} <bpm> <music.mid>")
+    exit(1)
+  end
+
+  bpm, midi_file = ARGV
+
+  ##  Run the midi file through my converter written in C++
+  IO.popen("./convert #{midi_file}") do |io|
+    midi_to_nes = MidiToNES.new(io.read, bpm.to_i)
+    midi_to_nes.write_binary('../../data.mus')
+  end
+
+end
+
+
+
+

data/utils/midi/source/convert.cpp

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include "file.h"
+
+int main(int argc, char **argv){
+
+  if(argc < 1){
+    printf("Need a midi file argument\n");
+    exit(1);
+  }
+
+  Midi::File midi_file;
+  midi_file.init_from_file(argv[1]);
+  midi_file.print_yaml();
+
+  return 0;
+}