Need help converting MIDI to gp tabs

[petr-michovsky]

Hey! I'm having trouble setting up my project so that I can read in a MIDI file using mido that contains drum MIDI for a whole song. I have sucessfully managed to extract the MIDI events from the file, but I'm having a hard time figuring out how to convert the MIDI ticks into gp time formats. So far I've only managed to import a single measure with all notes being quarter notes. I couldn't even figure out how to change the values to not be quarter notes to begin with. I've read the documentation and source code several time, but I can't seem to figure it out. If anybody would help me resolve my issue, I would be very grateful!

Leaving my code below:

CODE

---

import mido
import guitarpro as gp
from guitarpro.models import *

"""
The Note object represents a point on a single vertical line in the measure/bar.
The Beat object represents the collection of notes at a specific time.
The Measure object represents one bar.
"""

DEFAULT_PERCUSSION_CHANNEL = 9

Load the MIDI file

midi_file = mido.MidiFile('test_midi.mid')
ppq = midi_file.ticks_per_beat # Get PPQ (Pulses Per Quarter Note) from the MIDI file
print(f"PPQ: {ppq}")

gp_midi_map = {
"Kick": 35,
"Snare": 38,
"Highest Tom": 50,
"High Tom": 48,
"Mid Tom": 47,
"Floor Tom": 41,
"Floor Tom 2": 43,
"Hat": 42,
"Hat Open": 46,
"Foot X Hat Closet": 44,
"Crash": 49,
"Crash 2": 57,
"Ride": 51,
"China": 52,
"Ride Bell": 53,
"Splash": 55,
"Cowbell": 56,
}

ggd_midi_map = {
"Kick": 24,
"Snare": 26
}

reverse_ggd_midi_map = {value: key for key, value in ggd_midi_map.items()}

print("reverse_ggd_midi_map:", reverse_ggd_midi_map)
print("gp_midi_map:", gp_midi_map)

def extract_measure(midi_file_path, measure_number, ppq, time_signature=(4, 4), bpm=130):
# Load the MIDI file
midi_file = mido.MidiFile(midi_file_path)

# Calculate the number of ticks per measure
ticks_per_beat = ppq  # Ticks per quarter note
ticks_per_measure = ticks_per_beat * time_signature[0]  # Numerator gives beats per measure

# Calculate measure start and end
target_measure_start = (measure_number - 1) * ticks_per_measure
target_measure_end = measure_number * ticks_per_measure

selected_measure_events = []
current_ticks = 0

for track in midi_file.tracks:
    track_events = []
    for msg in track:
        current_ticks += msg.time

        # Collect events for the target measure
        if target_measure_start <= current_ticks < target_measure_end:
            track_events.append(msg)
        elif current_ticks >= target_measure_end:
            break

    selected_measure_events.append(track_events)

return selected_measure_events

first_measure = extract_measure('test_midi.mid', 1, ppq=480, bpm=130)
second_measure = extract_measure('test_midi.mid', 5, ppq=480, bpm=130)

def ticks_to_guitar_pro_duration(ticks):
# Example for a quarter note duration
beats = ticks / ppq
duration_percent = beats / 1.0 # Assuming 1 beat for a quarter note
return duration_percent

def parse_midi_for_drums():
drum_events = []

for track in second_measure:
    time = 0
    for msg in track:
        time += msg.time  # Accumulate time (ticks)
        if msg.type == 'note_on' and msg.velocity > 0:
            drum_events.append((msg.note, msg.velocity, time))

print(f"Drum Events: {drum_events}")
return drum_events

def create_empty_guitar_pro_track(bpm, song_name, artist):
print(f"Creating Guitar Pro Track: {song_name} by {artist} at {bpm} BPM")

song = Song(
    title=song_name,
    artist=artist,
    tempo=bpm
)

track = Track(
    song=song,
    number=1,
    name="Drums",
    isPercussionTrack=True,
    settings=TrackSettings(tablature=False)
)

measure_header = MeasureHeader(
    number=1,
    start=Duration.quarterTime,
)

# Create a Measure and add it to the Track
measure = Measure(
    track=track,
    header=measure_header
)

voice = Voice(measure=measure)

drum_events = parse_midi_for_drums()

for note, velocity, time in drum_events:
    # Determine the Guitar Pro note value from the MIDI note
    gp_note_value = gp_midi_map.get(reverse_ggd_midi_map.get(note, "Kick"), 35)  # Default to Kick if not found
    duration_percent = ticks_to_guitar_pro_duration(time)

    print(gp_note_value)
    print(duration_percent)
    print(time)

    beat = Beat(
        voice=voice,
        duration=Duration.fromTime(time)
    )
    note = Note(
        beat=beat,
        value=gp_note_value,
        velocity=velocity,
        string=5,
        durationPercent=duration_percent,
        type=NoteType.normal
    )

    beat.notes.append(note)
    voice.beats.append(beat)  # This line adds the notes to the measure

measure.voices.append(voice)

# Removing empty voices
measure.voices = [voice for voice in measure.voices if not voice.isEmpty]
print(measure.voices)

track.measures.append(measure)

track.measures = [measure for measure in track.measures if not measure.isEmpty]
print(track.measures)

song.tracks.append(track)
song.tracks = [t for t in song.tracks if t.name == "Drums"]

gp.write(song, stream='empty_track.gp5')
print("Finished writing to Guitar Pro file.")

Example usage

create_empty_guitar_pro_track(130, 'My Song', 'My Artist')