Upload _Decompressor.py

_Decompressor.py

@@ -0,0 +1,252 @@
+'''
+Imports
+'''
+import guitarpro
+from guitarpro import *
+import numpy as np
+import os
+import pickle
+import re
+from tqdm import tqdm
+
+from keras.utils import np_utils
+
+
+'''
+Constants
+'''
+# PITCH[i] = the pitch associated with midi note number i.
+# For example, PITCH[69] = 'A4'
+PITCH = {val : str(GuitarString(number=0, value=val)) for val in range(128)}
+# MIDI[string] = the midi number associated with the note described by string.
+# For example, MIDI['A4'] = 69.
+MIDI  = {str(GuitarString(number=0, value=val)) : val for val in range(128)}
+
+
+
+'''
+get_strings function
+'''
+def get_strings(chord, tuning, as_fingerings=True):
+    
+    lowest_string = len(tuning) # Bass has 4 strings, while metal guitars can have 6-8 strings.
+    
+    if as_fingerings:
+        # NEW CODE:
+        # Represent the tuning as the number of semitones between the open strings and the lowest string.
+        # i.e., relative_tuning[lowest_string] = 0
+        relative_tuning = {k : v - tuning[lowest_string] for k, v in tuning.items()}
+    
+    chord_parts = chord.split('_')
+    
+    
+    if as_fingerings:
+        # NEW CODE:
+        root_value = int(chord_parts[0])
+    else:
+        # NEW CODE:
+        root_value = MIDI[chord_parts[0]]
+    
+    
+    if as_fingerings:
+        # NEW CODE:
+        if root_value < 0:
+            print(f'!!!!! error !!!!!\t {root_value} < 0')
+    else:
+        # OLD CODE:
+        if root_value < tuning[lowest_string]:
+            print(f'!!!!! error !!!!!\t {root_value} < {tuning[lowest_string]}')
+    
+    # Using the tuning, get a list of all possible fret positions for the root note.
+    if as_fingerings:
+        # NEW CODE:
+        tuning_values = np.array(list(relative_tuning.values()))
+    else:
+        # OLD CODE:
+        tuning_values = np.array(list(tuning.values()))
+        
+    fingerings = root_value - tuning_values
+    
+    
+    # + 1 because tuning[] is 1-indexed.
+    string = np.where(fingerings >= 0, fingerings, np.inf).argmin() + 1
+    fret = fingerings[string-1]
+    
+    # If we are just playing a single note, then the function can just return what it has now.
+    if len(chord_parts) == 1:
+        return [(fret, string)]
+    
+    # If the chord requires a very high pitch, lower its fingering to the second-highest string,
+    # so as to save the highest string for the other part of the chord.
+    if string == 1:
+        string = 2
+        fret = fingerings[string-1]
+    
+    if chord_parts[1] == '5':
+        upper_value = root_value + 7 # perfect fifth
+    elif chord_parts[1] == 'dim5':
+        upper_value = root_value + 6 # tritone
+    elif chord_parts[1] == '4':
+        upper_value = root_value + 5
+    else:
+        upper_value = root_value + 5 # in case of an error, assume that the upper value is a perfect 4th above the root.
+    
+
+    if as_fingerings:
+        # NEW CODE:
+        upper_fret = upper_value - relative_tuning[string-1]
+    else:
+        # OLD CODE:
+        upper_fret = upper_value - tuning[string-1]
+        
+        
+    if upper_fret < 0:
+        # There are some rare cases where the chord cannot be played given a tuning.
+        # For example, a tritone or a perfect 4th with root C2 in a drop-C guitar.
+        # In that case, just return the root note.
+        return [(fret, string)]
+    
+    return [(fret, string), (upper_fret, string-1)]
+
+
+
+
+class SongWriter:
+    
+    def __init__(self, initialTempo):
+        self.song = guitarpro.models.Song(tempo=initialTempo)
+        self.song.tracks = [] # Initialize song.tracks to an empty list.
+        
+        self.currentTempo = initialTempo
+
+    '''
+    decompress_track function
+    '''
+    def decompress_track(self, track, tuning, tempo=None, instrument=None, name=None, as_fingerings=True):
+        
+        # Instantiate the Midi Channel / Instrument for this track,
+        # making sure to avoid channel 9 (the drum channel)
+        channel = MidiChannel(channel = len(self.song.tracks) + (len(self.song.tracks) >= 9),
+                              effectChannel = len(self.song.tracks) + (len(self.song.tracks) >= 9))
+        if instrument is not None:
+            channel.instrument = instrument
+        
+        # Instantiate the name for this track
+        if name is None:
+            name = f'Track {len(self.song.tracks) + 1}'
+            
+        # Pre-format the name to avoid any characters that the tab file format doesn't like.
+        # Keep only spaces and alphanumeric characters.
+        name = name.split('(')[0]
+        name = re.sub(r' \W+', '', name)
+        
+        # Instantiate the actual Track itself
+        self.song.tracks.append(Track(song=self.song, name=name, channel=channel))
+
+        # Calculate the dict key corresponding to the lowest-tuned string.
+        lowest_string = len(tuning)
+        
+        # Set the guitar tuning for the instrument.
+        self.song.tracks[-1].strings = [GuitarString(number=num, value=val) for num, val in tuning.items()]
+
+        
+         
+
+        # The first measureHeader and measure are already added by default. Let's remove them to make things more standard.
+        if len(self.song.tracks) == 1:
+            self.song.measureHeaders = []
+            self.song.tracks[0].measures = []
+            
+        startingTrackIdx = len(self.song.measureHeaders)
+        
+        for i in range(startingTrackIdx, startingTrackIdx+len(track)):
+            start = guitarpro.Duration.quarterTime * (1 + i*6)
+
+            self.song.addMeasureHeader(MeasureHeader(number=i+1, start=start))
+            
+            # Add new measure to every existing track.
+            for existing_track in self.song.tracks:
+                existing_track.measures.append( Measure(existing_track, self.song.measureHeaders[i]) )
+
+
+
+
+
+        for m_i, measure in enumerate(self.song.tracks[-1].measures):
+
+            if m_i < startingTrackIdx:
+                continue # Skip tracks that have already been written to.
+            
+            # "beats" starts off as an empy array [].
+            voice = measure.voices[0]
+            beats = voice.beats
+
+            #print(m_i - startingTrackIdx)
+            # For the m_i-th measure, get the indices b_i and the beats track_beat of the compressed song.
+            for b_i, track_beat in enumerate(track[m_i - startingTrackIdx]):
+                
+                #print(f'\t{b_i}')
+                
+                # If a tempo change is needed:
+                if tempo is not None and tempo != self.currentTempo:
+                    # Implement the tempo change, then update the current tempo.
+                    effect = BeatEffect(mixTableChange=MixTableChange(tempo=MixTableItem(value=tempo), hideTempo=False))
+                    self.currentTempo = tempo
+                else:
+                    effect = BeatEffect()
+                
+
+                chord = track_beat[0]
+                duration = Duration(value=int(track_beat[1]), isDotted=bool(track_beat[2]))
+
+                # since "beats" is empty, we can append Beat objects to it.
+                beats.append(Beat(voice, duration=duration, effect=effect))
+                if chord == 'rest':
+                    beats[b_i].status = guitarpro.BeatStatus.rest
+
+                elif chord == 'tied':
+                    # If this tied note is the first beat in its measure:
+                    if b_i == 0:
+                        # If this tied note is the first beat in the first measure:
+                        if m_i == 0:
+                            # Designate this beat as a rest, then move on to the next beat.
+                            beats[b_i].status = guitarpro.BeatStatus.rest
+                            continue
+                        else:
+                            # Get the last Beat object from the previous Measure.
+                            previous_beats = self.song.tracks[-1].measures[m_i-1].voices[0].beats
+                            if len(previous_beats) == 0:
+                                beats[b_i].status = guitarpro.BeatStatus.rest
+                                continue
+                            previous_beat = previous_beats[-1]
+                    else:
+                        # Get the previous Beat object from the current Measure.
+                        previous_beat = beats[b_i-1]
+
+                    for note in previous_beat.notes:
+                        beats[b_i].notes.append(Note(beat=beats[b_i], value=note.value, string=note.string, type=NoteType.tie))
+
+
+
+
+                elif chord == 'dead':
+                    beats[b_i].notes.append(Note(beat=beats[b_i], value=0, string=lowest_string, type=NoteType.dead))
+                    beats[b_i].notes.append(Note(beat=beats[b_i], value=0, string=lowest_string-1, type=NoteType.dead))
+                    beats[b_i].notes.append(Note(beat=beats[b_i], value=0, string=lowest_string-2, type=NoteType.dead))
+
+                else:
+                    for fret, string in get_strings(chord, tuning, as_fingerings):
+                        noteEffect = NoteEffect(palmMute=track_beat[3])
+                        beats[b_i].notes.append(Note(beat=beats[b_i], value=fret, string=string,
+                                                     type=NoteType.normal, effect=noteEffect))
+
+
+                #print('\t\t', chord, '\t', duration)
+
+
+        # Lastly, return the song so that it can be saved to a .gp5 file.
+        # return new_song
+        
+    
+    def write(self, filename):
+        guitarpro.write(self.song, filename)