Midi2TromboneChamp.py

from mido import MidiFile, MetaMessage
import pyperclip

import sys
import json
from easygui import *
import os
import math
from collections import OrderedDict


DEFAULT_TEMPO = 0.5
DEFAULT_NOTE_LENGTH = 0.2
APPDATA_DIR = os.path.expandvars(r'%LOCALAPPDATA%\Midi2TromboneChamp')


def resource_path():
    # https://stackoverflow.com/questions/7674790/bundling-data-files-with-pyinstaller-onefile
    # pyinstaller secretly runs application from a temp directly and doesn't pass the original exe location through,
    # so rather than creating a .json wherever the exe is, we have to dump it in appdata
    directory = APPDATA_DIR  # if getattr(sys, 'frozen', False) else os.path.dirname(os.path.realpath(__file__))
    if not os.path.exists(directory):
        print(f"Creating directory to store config: {directory}")
        os.mkdir(directory)
    return directory


def ticks2s(ticks, tempo, ticks_per_beat):
    """
        Converts ticks to seconds
    """
    return ticks/ticks_per_beat * tempo


def note2freq(x):
    """
        Convert a MIDI note into a frequency (given in Hz)
    """
    a = 440
    return (a/32) * (2 ** ((x-9)/12))


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


def is_note_on(msg):
    return msg.type == "note_on" and msg.velocity > 0


def is_note_off(msg):
    return msg.type == "note_off" or (msg.type == "note_on" and msg.velocity == 0)


def SetupNote(beat, length, noteNumber, endNoteNumber):
    startPitch = (noteNumber-60)*13.75
    endPitch = (endNoteNumber-60)*13.75
    return [beat, length , startPitch , endPitch - startPitch , endPitch]


class DialogFieldValues:
    _history_file = os.path.join(resource_path(), "history.json")

    def __init__(self):
        # Default values for each field go here
        self.open_midi_file = '*'
        # Chart info (.tmp file)
        self.song_name = ""
        self.short_name = ""
        self.directory_name = ""
        self.year = 2022
        self.artist = "Unknown"
        self.genre = "Korean Hyper Folk Emo"
        self.description = "The charter was too lazy to fill out a description. Boo the lazy charter! BOOOOO!!!"
        self.difficulty = 10
        self.spacing = 120
        # NOTE: Skipping song endpoint as that can always be inferred
        self.bpm = 120
        self.bpb = 2

        self.save_tmb_file = 'song.tmb'

        if os.path.exists(DialogFieldValues._history_file):
            try:
                self._populate_from_history()
            except:
                print("ERROR: Exception was raised when trying to load dialog history! " +
                      f"You may need to delete {DialogFieldValues._history_file} to fix. " +
                      f"If that doesn't work, ping @devook on Discord with the stack trace.")
                raise

    def _populate_from_history(self):
        with open(DialogFieldValues._history_file, "r") as f:
            history = json.load(f)
        for key, value in history.items():
            if key not in self.__dict__:
                print(f"{key}: {history[key]} removed because DialogFields doesn't have this field any more")
                continue
            self.__dict__[key] = history[key]

    def populate_empty_names(self, song_name):
        if self.song_name.strip() == "":
            self.song_name = song_name
            self.short_name = song_name
        if self.directory_name.strip() == "":
            self.directory_name = song_name

    def get_multi_field_mappings(self) -> OrderedDict:
        """
        Provides the definitive mapping between what the fields are named in the multi-enter box prompt, and
        which attributes those field names map to in the DialogFieldValues class. Defined here because I hate using
        parallel-indexed lists as a standin for a hashmap-like structure, but those structures are forced on us
        by easygui.multenterbox
        """
        fields = OrderedDict()
        fields["Song Name"] = "song_name"
        fields["Short Name"] = "short_name"
        fields["Folder Name"] = "directory_name"
        fields["Year"] = "year"
        fields["Author"] = "artist"
        fields["Genre"] = "genre"
        fields["Description"] = "description"
        fields["Difficulty"] = "difficulty"
        fields["Note Spacing"] = "spacing"
        fields["Beats Per Bar"] = "bpb"
        # TODO: This should be a unit test, really...
        assert all(hasattr(self, name) for name in fields.values()), \
            f"Field names in {self.get_multi_field_mappings.__name__} are out-dated: " \
            f"{[name for name in fields.values() if not hasattr(self, name)]} are not attributes of {DialogFieldValues.__name__}"
        return fields

    # TODO: Fields should be sanitized before being stored so we don't need to do any type-casting here
    def to_chart_info(self, endpoint) -> dict:
        return {
            "name": self.song_name,
            "shortName": self.short_name,
            "trackRef": self.directory_name,
            "year": int(self.year),
            "author": self.artist,
            "genre": self.genre,
            "description": self.description,
            "difficulty": int(self.difficulty),
            "savednotespacing": int(self.spacing),
            "endpoint": endpoint,
            "timesig": int(self.bpb),
            "tempo": int(self.bpm),
            # TODO: Add support for lyrics (probably needs work on TrombLoader side too)
            "lyrics": [],
            "UNK1": 0
        }
        # info["name"] = fieldValues[0]
        # info["shortName"] = fieldValues[1]
        # info["trackRef"] = fieldValues[2]
        # info["year"] = int(fieldValues[3])
        # info["author"] = fieldValues[4]
        # info["genre"] = fieldValues[5]
        # info["description"] = fieldValues[6]
        # info["difficulty"] = int(fieldValues[7])
        # info["savednotespacing"] = int(fieldValues[8])
        # info["endpoint"] = int(fieldValues[9])
        # info["timesig"] = int(fieldValues[10])
        # info["tempo"] = int(bpm)
        # info["lyrics"] = []
        # info["UNK1"] = 0

    def save(self):
        with open(DialogFieldValues._history_file, "w") as f:
            json.dump(self.__dict__, f)


class DialogBoxes:

    def __init__(self):
        self.__values = DialogFieldValues()

    @staticmethod
    def _default_if_none(possibly_none, default_value):
        return default_value if possibly_none is None else possibly_none

    @staticmethod
    def _default_if_path_not_exists(possible_path, default_value):
        return possible_path if possible_path is not None and os.path.exists(possible_path) else default_value

    def _quit_or_save(self, value):
        if value is None:
            print("Got None back from a dialog -- assuming we canceled and quitting!")
            quit(1)
        self.__values.save()
        return value

    # TODO? Might want to revisit and make the validation a little more robust
    # Difficulty, for example is only valid on a scale of 0-10, date should be a YYYY-formatted year, etc.
    def _is_chart_info_valid(self, mapping, fields, values):
        return all(v.strip() != "" for v in values)

    def prompt_for_midi_file(self):
        default_path = DialogBoxes._default_if_path_not_exists(self.__values.open_midi_file, '*')
        self.__values.open_midi_file = fileopenbox(
            msg="Choose a MIDI file to convert.",
            default=default_path,
            filetypes=[["\\*.mid", "\\*.midi"], "MIDI files"])
        return self._quit_or_save(self.__values.open_midi_file)

    def prompt_for_bpm(self):
        # NOTE: Truncating to int in text box here,
        # although users are free to give float values if they really want to...
        bpm = enterbox("BPM of Midi", "Enter BPM", "{:.0f}".format(self.__values.bpm))
        # float(None) will throw an exception, so have to go around it when dialog is canceled
        self.__values.bpm = None if bpm is None else float(bpm)
        return self._quit_or_save(self.__values.bpm)

    def prompt_for_chart_info(self, song_name, final_bar):
        msg = "Enter the Chart Info"
        title = "Chart Info"
        self.__values.populate_empty_names(song_name)
        field_mappings = self.__values.get_multi_field_mappings()
        # We don't save a value for Endpoint because it can be inferred and is likely to change between iterations
        field_names = list(field_mappings.keys()) + ["Song Endpoint (in beats)"]
        field_values = [getattr(self.__values, name) for name in field_mappings.values()] + [int(final_bar + 4)]
        all_fields_ok = False
        while not all_fields_ok:
            field_values = multenterbox(msg, title, field_names, field_values)
            if field_values is None:
                print("Cancel pressed -- quitting")
                quit(1)
            all_fields_ok = self._is_chart_info_valid(field_mappings, field_names, field_values)
            # If we loop around, we'll use this message instead
            msg = "All fields are required. Please don't leave any blank."

        # Push new values back into history for everything we're keeping track of (not song endpoint)
        for name, value in zip(field_names, field_values):
            if name in field_mappings:
                setattr(self.__values, field_mappings[name], value)
        self.__values.save()

        # TODO: Remove this assumption that final_bar is always the last entry in the values array
        return self.__values.to_chart_info(int(field_values[-1]))

    def prompt_for_file_save(self):
        self.__values.save_tmb_file = filesavebox(default=self.__values.save_tmb_file)
        return self._quit_or_save(self.__values.save_tmb_file)


if __name__ == '__main__':
    dialog = DialogBoxes()
    midi_file = dialog.prompt_for_midi_file()
    song_name = os.path.splitext(os.path.basename(midi_file))[0]
    bpm = dialog.prompt_for_bpm()
    nyxTracks = dict()
    for i in range(16):
        nyxTracks[i] = []
    # Import the MIDI file...
    mid = MidiFile(filename=midi_file, clip=True)

    print("TYPE: " + str(mid.type))
    print("LENGTH: " + str(mid.length))
    print("TICKS PER BEAT: " + str(mid.ticks_per_beat))

    if mid.type == 3:
        print("Unsupported type.")
        exit()

    """
        First read all the notes in the MIDI file
    """
    tracksMerged = []
    notes = {}
    tick_duration = 60/(mid.ticks_per_beat*bpm)
    
    notes = []
    print("Tick Duration:")
    print(tick_duration)

    print("Tempo:" + str(DEFAULT_TEMPO))
        
    final_bar = 0

    allMidiEventsSorted = []

    for i, track in enumerate(mid.tracks):
        currTrack = i
        tempo = DEFAULT_TEMPO
        totaltime = 0
        globalTime = 0
        currentNote = []
        globalBeatTime = 0
        currBeat = 0
        for message in track:
            t = ticks2s(message.time, tempo, mid.ticks_per_beat)
            tromboneBeat = message.time/mid.ticks_per_beat
            totaltime += t

            if isinstance(message, MetaMessage):  # Tempo change
                if message.type == "set_tempo":
                    tempo = message.tempo / 10**6
                elif message.type == "end_of_track":
                    pass
                else:
                    print("Unsupported metamessage: " + str(message))

            else:
                globalTime+= message.time
                globalBeatTime+= tromboneBeat
                    
                currTime = globalTime*tick_duration*1000
                currBeat = round(globalBeatTime,3)
                allMidiEventsSorted += [(i,message, currBeat)]


    
    allMidiEventsSorted = sorted(allMidiEventsSorted, key=lambda x: x[2] )

    keyframes = []
    for i, message, currBeat in allMidiEventsSorted:
        if message.type == "note_on":
            seconds = currBeat*60/bpm
            keyframes += [(seconds, (message.note -60)/12)]
                    
    currTrack = i
    tempo = DEFAULT_TEMPO
    totaltime = 0
    globalTime = 0
    currentNote = []
    globalBeatTime = 0
    noteToUse = 0
    lastNote = -1000
    lastChannel = -1
    DEFAULT_NOTE_LENGTH = 0.2
    noteTrimming = 0.0
    currBeat = 0
    noteHeld = False
    
    for i, message, currBeat in allMidiEventsSorted:
        if (True):
            if isinstance(message, MetaMessage):  # Tempo change
                if message.type == "set_tempo":
                    tempo = message.tempo / 10**6
                elif message.type == "end_of_track":
                    pass
                else:
                    print("Unsupported metamessage: " + str(message))

            else:  # Note
                if is_note_on(message):
                    noteToUse = min(max(48, message.note),72)
                    lastNote = noteToUse
                    lastChannel = message.channel
                    if (not noteHeld):
                        #No notes being held, so we set it up
                        currentNote = SetupNote(currBeat, 0, noteToUse, noteToUse)
                    else:
                        #If we are holding one, we add the previous note we set up, and set up a new one
                        print("Cancelling Previous note!" + str(currBeat) + " old is" + str(currentNote[0]))
                        currentNote[1] = round(currBeat-currentNote[0],3)
                        currentNote[4] = (noteToUse-60)*13.75
                        currentNote[3] = currentNote[4]-currentNote[2]

                        for noteParam in range(len(currentNote)):
                                currentNote[noteParam] = round(currentNote[noteParam],3)
                        if (currentNote[1] == 0):
                                currentNote[1] = DEFAULT_NOTE_LENGTH
                        
                        notes += [currentNote]
                        currentNote = SetupNote(currBeat, 0, noteToUse, noteToUse)
                    print(currentNote)
                    noteHeld = True

                if is_note_off(message):
                    noteToUse = min(max(48, message.note),72)
                    if (message.channel == 1):
                        print("Skipping channel 1 note off...")
                    if (message.channel == 0):
                        if (noteToUse == lastNote and noteHeld):
                            currentNote[1] = round(currBeat-currentNote[0] - noteTrimming,3)
                            currentNote[4] = currentNote[4]
                            currentNote[3] = 0

                            for noteParam in range(len(currentNote)):
                                currentNote[noteParam] = round(currentNote[noteParam],3)

                            if (currentNote[1] <= 0):
                                currentNote[1] = DEFAULT_NOTE_LENGTH
                            #print(currentNote)
                            notes += [currentNote]
                            noteHeld = False


        final_bar = max(final_bar, currBeat)
        #print("totaltime: " + str(totaltime)+"s")
            
    notes = sorted(notes, key=lambda x: x[0] )
    pyperclip.copy(str(notes))

    chart_info = dialog.prompt_for_chart_info(song_name, final_bar)
    chart_info["notes"] = notes

    out = dialog.prompt_for_file_save()
    with open(out, "w") as f:
        json.dump(chart_info, f)

sys.exit()