Upload TMIDIX.py

TMIDIX.py

@@ -14,14 +14,14 @@ r'''############################################################################
 #
 #	Project Los Angeles
 #
-#	Tegridy Code 2021
+#	Tegridy Code 2024
 #
 #   https://github.com/Tegridy-Code/Project-Los-Angeles
 #
 #
 ###################################################################################
 ###################################################################################
-#       Copyright 2021 Project Los Angeles / Tegridy Code
+#       Copyright 2024 Project Los Angeles / Tegridy Code
 #
 #       Licensed under the Apache License, Version 2.0 (the "License");
 #       you may not use this file except in compliance with the License.
@@ -4690,7 +4690,8 @@ def augment_enhanced_score_notes(enhanced_score_notes,
                                   pitch_shift=0,
                                   ceil_timings=False,
                                   round_timings=False,
-                                  legacy_timings=True
+                                  legacy_timings=True,
+                                  sort_drums_last=False
                                 ):
 
     esn = copy.deepcopy(enhanced_score_notes)
@@ -4740,6 +4741,9 @@ def augment_enhanced_score_notes(enhanced_score_notes,
       esn.sort(key=lambda x: x[6])
       esn.sort(key=lambda x: x[4], reverse=True)
       esn.sort(key=lambda x: x[1])
+      
+    if sort_drums_last:
+        esn.sort(key=lambda x: (x[1], -x[4], x[6]) if x[6] != 128 else (x[1], x[6], -x[4]))
 
     return esn
 
@@ -7097,13 +7101,25 @@ def escore_notes_averages(escore_notes,
   else:
     durs = [e[durs_index] for e in escore_notes if e[chans_index] != 9]
 
+  if len(times) == 0:
+      times = [0]
+      
+  if len(durs) == 0:
+      durs = [0]
+
   if return_ptcs_and_vels:
     if average_drums:
       ptcs = [e[ptcs_index] for e in escore_notes]
       vels = [e[vels_index] for e in escore_notes]
     else:
       ptcs = [e[ptcs_index] for e in escore_notes if e[chans_index] != 9]
-      vels = [e[vels_index] for e in escore_notes if e[chans_index] != 9]      
+      vels = [e[vels_index] for e in escore_notes if e[chans_index] != 9]
+      
+    if len(ptcs) == 0:
+        ptcs = [0]
+      
+    if len(vels) == 0:
+        vels = [0]
 
     return [sum(times) / len(times), sum(durs) / len(durs), sum(ptcs) / len(ptcs), sum(vels) / len(vels)]
   
@@ -7883,19 +7899,21 @@ def solo_piano_escore_notes(escore_notes,
     chord = []
 
     for cc in c:
-      if cc[pitches_index] not in seen:
 
-          if cc[channels_index] != 9:
+      if cc[channels_index] != 9:
+        if cc[pitches_index] not in seen:
+            
             cc[channels_index] = 0
             cc[patches_index] = 0
-            
+        
             chord.append(cc)
             seen.append(cc[pitches_index])
-          
-          else:
-            if keep_drums:
+      
+      else:
+        if keep_drums:
+          if cc[pitches_index]+128 not in seen:
               chord.append(cc)
-              seen.append(cc[pitches_index])
+              seen.append(cc[pitches_index]+128)
 
     sp_escore_notes.append(chord)
 
@@ -9254,6 +9272,1032 @@ def find_highest_density_escore_notes_chunk(escore_notes, max_chunk_time=512):
     
     return chunk_escore
 
+###################################################################################
+
+def advanced_add_drums_to_escore_notes(escore_notes,
+                                       main_beat_min_dtime=5,
+                                       main_beat_dtime_thres=1,
+                                       drums_durations_value=2,
+                                       drums_pitches_velocities=[(36, 100), 
+                                                                 (38, 100), 
+                                                                 (41, 125)],
+                                       recalculate_score_timings=True,
+                                       intro_drums_count=4,
+                                       intro_drums_time_k=4,
+                                       intro_drums_pitch_velocity=[37, 110]
+                                      ):
+
+    #===========================================================
+    
+    new_dscore = delta_score_notes(escore_notes)
+
+    times = [d[1] for d in new_dscore if d[1] != 0]
+
+    time = [c[0] for c in Counter(times).most_common() if c[0] >= main_beat_min_dtime][0]
+
+    #===========================================================
+
+    if intro_drums_count > 0:
+
+        drums_score = []
+
+        for i in range(intro_drums_count):
+
+            if i == 0:
+                dtime = 0
+
+            else:
+                dtime = time
+            
+            drums_score.append(['note', 
+                                dtime * intro_drums_time_k, 
+                                drums_durations_value, 
+                                9, 
+                                intro_drums_pitch_velocity[0], 
+                                intro_drums_pitch_velocity[1], 
+                                128]
+                              )
+            
+        new_dscore[0][1] = time * intro_drums_time_k
+
+        new_dscore = drums_score + new_dscore
+
+    #===========================================================
+
+    for e in new_dscore:
+    
+        if abs(e[1] - time) == main_beat_dtime_thres:
+            e[1] = time
+
+        if recalculate_score_timings:
+        
+            if e[1] % time != 0 and e[1] > time:
+                if e[1] % time < time // 2:
+                    e[1] -= e[1] % time
+        
+                else:
+                    e[1] += time - (e[1] % time)
+
+    #===========================================================
+
+    drums_score = []
+    
+    dtime = 0
+    
+    idx = 0
+    
+    for i, e in enumerate(new_dscore):
+        
+        drums_score.append(e)
+        
+        dtime += e[1]
+
+        if e[1] != 0:
+            idx += 1
+
+        if i >= intro_drums_count:
+    
+            if (e[1] % time == 0 and e[1] != 0) or i == 0:
+                
+                if idx % 2 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[0][0], 
+                                        drums_pitches_velocities[0][1], 
+                                        128]
+                                      )
+                    
+                if idx % 2 != 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[1][0], 
+                                        drums_pitches_velocities[1][1], 
+                                        128]
+                                      )
+        
+                if idx % 4 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[2][0], 
+                                        drums_pitches_velocities[2][1], 
+                                        128]
+                                      )
+
+    #===========================================================
+    
+    return delta_score_to_abs_score(drums_score)
+
+###################################################################################
+
+MIDI_TEXT_EVENTS = ['text_event',
+                    'copyright_text_event',
+                    'track_name',
+                    'instrument_name',
+                    'lyric',
+                    'marker',
+                    'cue_point',
+                    'text_event_08',
+                    'text_event_09',
+                    'text_event_0a',
+                    'text_event_0b',
+                    'text_event_0c',
+                    'text_event_0d',
+                    'text_event_0e',
+                    'text_event_0f'
+                  ]
+
+###################################################################################
+
+import hashlib
+import re
+
+###################################################################################
+
+def get_md5_hash(data):
+    return hashlib.md5(data).hexdigest()
+
+###################################################################################
+
+def is_valid_md5_hash(string):
+    return bool(re.match(r'^[a-fA-F0-9]{32}$', string))
+
+###################################################################################
+
+def clean_string(original_string,
+                 regex=r'[^a-zA-Z0-9 ]',
+                 remove_duplicate_spaces=True,
+                 title=False
+                ):
+    
+    cstr1 = re.sub(regex, '', original_string)
+
+    if title:
+        cstr1 = cstr1.title()
+
+    if remove_duplicate_spaces:
+        return re.sub(r'\s+', ' ', cstr1).strip()
+
+    else:
+        return cstr1
+    
+###################################################################################
+    
+def encode_to_ord(text, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+
+    encoded = []
+    
+    for char in text:
+        if ord(char) in chars_range:
+            encoded.append(chars_range.index(ord(char)) + chars_shift)
+            
+        else:
+            if sub_char:
+                encoded.append(chars_range.index(ord(sub_char)) + chars_shift)
+        
+    
+    return [encoded, chars_range]
+
+###################################################################################
+
+def decode_from_ord(ord_list, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+        
+    return ''.join(chr(chars_range[num-chars_shift]) if 0 <= num-chars_shift < len(chars_range) else sub_char for num in ord_list)
+
+###################################################################################
+
+def lists_similarity(list1, list2, by_elements=True, by_sum=True):
+    
+    if len(list1) != len(list2):
+        return -1
+    
+    element_ratios = []
+    total_counts1 = sum(list1)
+    total_counts2 = sum(list2)
+
+    for a, b in zip(list1, list2):
+        if a == 0 and b == 0:
+            element_ratios.append(1)
+        elif a == 0 or b == 0:
+            element_ratios.append(0)
+        else:
+            element_ratios.append(min(a, b) / max(a, b))
+
+    average_element_ratio = sum(element_ratios) / len(element_ratios)
+
+    total_counts_ratio = min(total_counts1, total_counts2) / max(total_counts1, total_counts2)
+
+    if by_elements and by_sum:
+        return (average_element_ratio + total_counts_ratio) / 2
+
+    elif by_elements and not by_sum:
+        return average_element_ratio
+
+    elif not by_elements and by_sum:
+        return total_counts_ratio
+
+    else:
+        return -1
+
+###################################################################################
+
+def find_indexes(lst, value, mode='equal', dual_mode=True):
+
+    indexes = []
+
+    if mode == 'equal' or dual_mode:    
+        indexes.extend([index for index, elem in enumerate(lst) if elem == value])
+
+    if mode == 'smaller':
+        indexes.extend([index for index, elem in enumerate(lst) if elem < value])
+
+    if mode == 'larger':
+        indexes.extend([index for index, elem in enumerate(lst) if elem > value])
+
+    return sorted(set(indexes))
+
+###################################################################################
+
+NUMERALS = ["one", "two", "three", "four", 
+            "five", "six", "seven", "eight", 
+            "nine", "ten", "eleven", "twelve", 
+            "thirteen", "fourteen", "fifteen", "sixteen"
+           ]
+
+SEMITONES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+MOOD_SCALES = ['Major', 'Minor', 'Major Minor']
+
+###################################################################################
+
+def alpha_str(string):
+    return re.sub(r'[^a-zA-Z ()]', '', string).strip()
+
+###################################################################################
+
+def escore_notes_to_text_description(escore_notes, song_name='', artist_name=''):
+
+    #==============================================================================
+
+    song_time_min = (escore_notes[-1][1] * 16) / 1000 / 60
+
+    if song_time_min < 1.5:
+        song_length = 'short'
+    
+    elif 1.5 <= song_time_min < 2.5:
+        song_length = 'average'
+    
+    elif song_time_min >= 2.5:
+        song_length = 'long'
+
+    #==============================================================================
+
+    escore_times = [e[1] for e in escore_notes if e[3] != 9]
+    
+    comp_type = ''
+
+    if len(escore_times) > 0:
+        if len(escore_times) == len(set(escore_times)):
+            comp_type = 'monophonic melody'
+        
+        elif len(escore_times) >= len(set(escore_times)) and 1 in Counter(escore_times).values():
+            comp_type = 'melody and accompaniment'
+        
+        elif len(escore_times) >= len(set(escore_times)) and 1 not in Counter(escore_times).values():
+            comp_type = 'accompaniment'
+    
+    else:
+        comp_type = 'drums only'
+
+    #==============================================================================
+
+    patches = sorted(set([e[6] for e in escore_notes]))
+    
+    instruments = [alpha_str(Number2patch[p]) for p in patches if p < 128]
+
+    if 128 in patches:
+        drums_present = True
+
+    else:
+        drums_present = False
+
+    drums_pitches = [e[4] for e in escore_notes if e[3] == 9]
+
+    most_common_drums = [alpha_str(Notenum2percussion[p[0]]) for p in Counter(drums_pitches).most_common(3) if p[0] in Notenum2percussion]
+
+    #==============================================================================
+
+    pitches = [e[4] for e in escore_notes if e[3] != 9]
+    
+    key = ''
+    
+    if pitches:
+        key = SEMITONES[statistics.mode(pitches) % 12]
+
+    #==============================================================================
+        
+    mood = ''
+    
+    if pitches:
+    
+        cscore = chordify_score([1000, escore_notes])
+
+        tones_chords = Counter()
+
+        for c in cscore:
+            if len([e for e in c if e[3] != 9]) > 0:
+                tones_chords[tuple(sorted(set([e[4] % 12 for e in c if e[3] != 9])))] += 1
+                
+        most_common_tones_chords = [check_and_fix_tones_chord(list(c[0])) for c in tones_chords.most_common(10)]
+        
+        mood_scale = statistics.mode(tones_chords_to_types(most_common_tones_chords, return_chord_type_index=True)) % 3
+
+        mood = MOOD_SCALES[mood_scale]
+
+    #==============================================================================
+    
+    if pitches:
+    
+        escore_averages = escore_notes_averages(escore_notes, return_ptcs_and_vels=True)
+
+        if escore_averages[0] < 8:
+            rythm = 'fast'
+        
+        elif 8 <= escore_averages[0] <= 12:
+            rythm = 'average'
+        
+        elif escore_averages[0] > 12:
+            rythm = 'slow'
+        
+        if escore_averages[1] < 16:
+            tempo = 'fast'
+        
+        elif 16 <= escore_averages[1] <= 24:
+            tempo = 'average'
+        
+        elif escore_averages[1] > 24:
+            tempo = 'slow'
+        
+        if escore_averages[2] < 50:
+            tone = 'bass'
+        
+        elif 50 <= escore_averages[2] <= 70:
+            tone = 'midrange'
+        
+        elif escore_averages[2] > 70:
+            tone = 'treble'
+        
+        if escore_averages[3] < 80:
+            dynamics = 'quiet'
+        
+        elif 80 <= escore_averages[3] <= 100:
+            dynamics = 'average'
+        
+        elif escore_averages[3] > 100:
+            dynamics = 'loud'
+
+    #==============================================================================
+        
+    description = ''
+
+    if song_name != '':
+        description = 'Song "' + song_name + '"'
+    
+    if artist_name != '':
+        description += ' by ' + artist_name
+
+    if song_name != '' or artist_name != '':
+        description += '.'
+        description += '\n'
+    
+    description += 'The song is '
+
+    if song_length != 'average':
+        description += 'a ' + song_length
+
+    else:
+        description += 'an ' + song_length
+
+    description += ' duration '
+
+    description += comp_type + ' composition'
+
+    if comp_type != 'drum track':
+
+        if drums_present:
+            description += ' with drums'
+    
+        else:
+            description += ' without drums'
+    
+        if key and mood:
+            description += ' in ' + key + ' ' + mood
+
+    description += '.'
+
+    description += '\n'
+    
+    if pitches:
+
+        description += 'It has '
+        
+        description += rythm + ' rythm, '
+        description += tempo + ' tempo, '
+        description += tone + ' tone and '
+        description += dynamics + ' dynamics.'
+
+        description += '\n'
+
+        description += 'The song ' 
+
+        if len(instruments) == 1:
+            description += 'is played on a solo ' + instruments[0] + '.'
+
+        else:
+            description += 'features ' + NUMERALS[max(0, min(15, len(instruments)-1))] + ' instruments: '
+            description += ', '.join(instruments[:-1]) + ' and ' + instruments[-1] + '.'
+
+        description += '\n'
+
+    if drums_present and most_common_drums:
+        description += 'The drum track has predominant '
+        description += ', '.join(most_common_drums[:-1]) + ' and ' + most_common_drums[-1] + '.'
+
+    #==============================================================================
+
+    return description
+
+###################################################################################
+
+#==================================================================================
+#
+# Below constants code is a courtesy of MidiTok
+#
+# Retrieved on 12/29/2024
+#
+# https://github.com/Natooz/MidiTok/blob/main/src/miditok/constants.py
+#
+#==================================================================================
+
+MIDI_FILES_EXTENSIONS = [".mid", ".midi", ".kar", ".MID", ".MIDI", ".KAR"]
+
+# The recommended pitches for piano in the GM2 specs are from 21 to 108
+PIANO_PITCH_RANGE = range(21, 109)
+
+# Chord params
+# "chord_unknown" specifies the range of number of notes that can form "unknown" chords
+# (that do not fit in "chord_maps") to add in tokens.
+# Known chord maps, with 0 as root note
+BASIC_CHORDS_MAP = {
+    "min": (0, 3, 7),
+    "maj": (0, 4, 7),
+    "dim": (0, 3, 6),
+    "aug": (0, 4, 8),
+    "sus2": (0, 2, 7),
+    "sus4": (0, 5, 7),
+    "7dom": (0, 4, 7, 10),
+    "7min": (0, 3, 7, 10),
+    "7maj": (0, 4, 7, 11),
+    "7halfdim": (0, 3, 6, 10),
+    "7dim": (0, 3, 6, 9),
+    "7aug": (0, 4, 8, 11),
+    "9maj": (0, 4, 7, 10, 14),
+    "9min": (0, 4, 7, 10, 13),
+    }
+
+# Drums
+# Recommended range from the GM2 specs
+DRUMS_PITCH_RANGE = range(27, 90)
+
+# Used with chords
+PITCH_CLASSES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+# http://newt.phys.unsw.edu.au/jw/notes.html
+# https://www.midi.org/specifications
+
+# index i = program i+1 in the GM2 specs (7. Appendix A)
+# index i = program i as retrieved by packages
+MIDI_INSTRUMENTS = [
+    # Piano
+    {"name": "Acoustic Grand Piano", "pitch_range": range(21, 109)},
+    {"name": "Bright Acoustic Piano", "pitch_range": range(21, 109)},
+    {"name": "Electric Grand Piano", "pitch_range": range(21, 109)},
+    {"name": "Honky-tonk Piano", "pitch_range": range(21, 109)},
+    {"name": "Electric Piano 1", "pitch_range": range(28, 104)},
+    {"name": "Electric Piano 2", "pitch_range": range(28, 104)},
+    {"name": "Harpsichord", "pitch_range": range(41, 90)},
+    {"name": "Clavi", "pitch_range": range(36, 97)},
+    # Chromatic Percussion
+    {"name": "Celesta", "pitch_range": range(60, 109)},
+    {"name": "Glockenspiel", "pitch_range": range(72, 109)},
+    {"name": "Music Box", "pitch_range": range(60, 85)},
+    {"name": "Vibraphone", "pitch_range": range(53, 90)},
+    {"name": "Marimba", "pitch_range": range(48, 85)},
+    {"name": "Xylophone", "pitch_range": range(65, 97)},
+    {"name": "Tubular Bells", "pitch_range": range(60, 78)},
+    {"name": "Dulcimer", "pitch_range": range(60, 85)},
+    # Organs
+    {"name": "Drawbar Organ", "pitch_range": range(36, 97)},
+    {"name": "Percussive Organ", "pitch_range": range(36, 97)},
+    {"name": "Rock Organ", "pitch_range": range(36, 97)},
+    {"name": "Church Organ", "pitch_range": range(21, 109)},
+    {"name": "Reed Organ", "pitch_range": range(36, 97)},
+    {"name": "Accordion", "pitch_range": range(53, 90)},
+    {"name": "Harmonica", "pitch_range": range(60, 85)},
+    {"name": "Tango Accordion", "pitch_range": range(53, 90)},
+    # Guitars
+    {"name": "Acoustic Guitar (nylon)", "pitch_range": range(40, 85)},
+    {"name": "Acoustic Guitar (steel)", "pitch_range": range(40, 85)},
+    {"name": "Electric Guitar (jazz)", "pitch_range": range(40, 87)},
+    {"name": "Electric Guitar (clean)", "pitch_range": range(40, 87)},
+    {"name": "Electric Guitar (muted)", "pitch_range": range(40, 87)},
+    {"name": "Overdriven Guitar", "pitch_range": range(40, 87)},
+    {"name": "Distortion Guitar", "pitch_range": range(40, 87)},
+    {"name": "Guitar Harmonics", "pitch_range": range(40, 87)},
+    # Bass
+    {"name": "Acoustic Bass", "pitch_range": range(28, 56)},
+    {"name": "Electric Bass (finger)", "pitch_range": range(28, 56)},
+    {"name": "Electric Bass (pick)", "pitch_range": range(28, 56)},
+    {"name": "Fretless Bass", "pitch_range": range(28, 56)},
+    {"name": "Slap Bass 1", "pitch_range": range(28, 56)},
+    {"name": "Slap Bass 2", "pitch_range": range(28, 56)},
+    {"name": "Synth Bass 1", "pitch_range": range(28, 56)},
+    {"name": "Synth Bass 2", "pitch_range": range(28, 56)},
+    # Strings & Orchestral instruments
+    {"name": "Violin", "pitch_range": range(55, 94)},
+    {"name": "Viola", "pitch_range": range(48, 85)},
+    {"name": "Cello", "pitch_range": range(36, 73)},
+    {"name": "Contrabass", "pitch_range": range(28, 56)},
+    {"name": "Tremolo Strings", "pitch_range": range(28, 94)},
+    {"name": "Pizzicato Strings", "pitch_range": range(28, 94)},
+    {"name": "Orchestral Harp", "pitch_range": range(23, 104)},
+    {"name": "Timpani", "pitch_range": range(36, 58)},
+    # Ensembles
+    {"name": "String Ensembles 1", "pitch_range": range(28, 97)},
+    {"name": "String Ensembles 2", "pitch_range": range(28, 97)},
+    {"name": "SynthStrings 1", "pitch_range": range(36, 97)},
+    {"name": "SynthStrings 2", "pitch_range": range(36, 97)},
+    {"name": "Choir Aahs", "pitch_range": range(48, 80)},
+    {"name": "Voice Oohs", "pitch_range": range(48, 80)},
+    {"name": "Synth Voice", "pitch_range": range(48, 85)},
+    {"name": "Orchestra Hit", "pitch_range": range(48, 73)},
+    # Brass
+    {"name": "Trumpet", "pitch_range": range(58, 95)},
+    {"name": "Trombone", "pitch_range": range(34, 76)},
+    {"name": "Tuba", "pitch_range": range(29, 56)},
+    {"name": "Muted Trumpet", "pitch_range": range(58, 83)},
+    {"name": "French Horn", "pitch_range": range(41, 78)},
+    {"name": "Brass Section", "pitch_range": range(36, 97)},
+    {"name": "Synth Brass 1", "pitch_range": range(36, 97)},
+    {"name": "Synth Brass 2", "pitch_range": range(36, 97)},
+    # Reed
+    {"name": "Soprano Sax", "pitch_range": range(54, 88)},
+    {"name": "Alto Sax", "pitch_range": range(49, 81)},
+    {"name": "Tenor Sax", "pitch_range": range(42, 76)},
+    {"name": "Baritone Sax", "pitch_range": range(37, 69)},
+    {"name": "Oboe", "pitch_range": range(58, 92)},
+    {"name": "English Horn", "pitch_range": range(52, 82)},
+    {"name": "Bassoon", "pitch_range": range(34, 73)},
+    {"name": "Clarinet", "pitch_range": range(50, 92)},
+    # Pipe
+    {"name": "Piccolo", "pitch_range": range(74, 109)},
+    {"name": "Flute", "pitch_range": range(60, 97)},
+    {"name": "Recorder", "pitch_range": range(60, 97)},
+    {"name": "Pan Flute", "pitch_range": range(60, 97)},
+    {"name": "Blown Bottle", "pitch_range": range(60, 97)},
+    {"name": "Shakuhachi", "pitch_range": range(55, 85)},
+    {"name": "Whistle", "pitch_range": range(60, 97)},
+    {"name": "Ocarina", "pitch_range": range(60, 85)},
+    # Synth Lead
+    {"name": "Lead 1 (square)", "pitch_range": range(21, 109)},
+    {"name": "Lead 2 (sawtooth)", "pitch_range": range(21, 109)},
+    {"name": "Lead 3 (calliope)", "pitch_range": range(36, 97)},
+    {"name": "Lead 4 (chiff)", "pitch_range": range(36, 97)},
+    {"name": "Lead 5 (charang)", "pitch_range": range(36, 97)},
+    {"name": "Lead 6 (voice)", "pitch_range": range(36, 97)},
+    {"name": "Lead 7 (fifths)", "pitch_range": range(36, 97)},
+    {"name": "Lead 8 (bass + lead)", "pitch_range": range(21, 109)},
+    # Synth Pad
+    {"name": "Pad 1 (new age)", "pitch_range": range(36, 97)},
+    {"name": "Pad 2 (warm)", "pitch_range": range(36, 97)},
+    {"name": "Pad 3 (polysynth)", "pitch_range": range(36, 97)},
+    {"name": "Pad 4 (choir)", "pitch_range": range(36, 97)},
+    {"name": "Pad 5 (bowed)", "pitch_range": range(36, 97)},
+    {"name": "Pad 6 (metallic)", "pitch_range": range(36, 97)},
+    {"name": "Pad 7 (halo)", "pitch_range": range(36, 97)},
+    {"name": "Pad 8 (sweep)", "pitch_range": range(36, 97)},
+    # Synth SFX
+    {"name": "FX 1 (rain)", "pitch_range": range(36, 97)},
+    {"name": "FX 2 (soundtrack)", "pitch_range": range(36, 97)},
+    {"name": "FX 3 (crystal)", "pitch_range": range(36, 97)},
+    {"name": "FX 4 (atmosphere)", "pitch_range": range(36, 97)},
+    {"name": "FX 5 (brightness)", "pitch_range": range(36, 97)},
+    {"name": "FX 6 (goblins)", "pitch_range": range(36, 97)},
+    {"name": "FX 7 (echoes)", "pitch_range": range(36, 97)},
+    {"name": "FX 8 (sci-fi)", "pitch_range": range(36, 97)},
+    # Ethnic Misc.
+    {"name": "Sitar", "pitch_range": range(48, 78)},
+    {"name": "Banjo", "pitch_range": range(48, 85)},
+    {"name": "Shamisen", "pitch_range": range(50, 80)},
+    {"name": "Koto", "pitch_range": range(55, 85)},
+    {"name": "Kalimba", "pitch_range": range(48, 80)},
+    {"name": "Bag pipe", "pitch_range": range(36, 78)},
+    {"name": "Fiddle", "pitch_range": range(55, 97)},
+    {"name": "Shanai", "pitch_range": range(48, 73)},
+    # Percussive
+    {"name": "Tinkle Bell", "pitch_range": range(72, 85)},
+    {"name": "Agogo", "pitch_range": range(60, 73)},
+    {"name": "Steel Drums", "pitch_range": range(52, 77)},
+    {"name": "Woodblock", "pitch_range": range(128)},
+    {"name": "Taiko Drum", "pitch_range": range(128)},
+    {"name": "Melodic Tom", "pitch_range": range(128)},
+    {"name": "Synth Drum", "pitch_range": range(128)},
+    {"name": "Reverse Cymbal", "pitch_range": range(128)},
+    # SFX
+    {"name": "Guitar Fret Noise, Guitar Cutting Noise", "pitch_range": range(128)},
+    {"name": "Breath Noise, Flute Key Click", "pitch_range": range(128)},
+    {
+        "name": "Seashore, Rain, Thunder, Wind, Stream, Bubbles",
+        "pitch_range": range(128),
+    },
+    {"name": "Bird Tweet, Dog, Horse Gallop", "pitch_range": range(128)},
+    {
+        "name": "Telephone Ring, Door Creaking, Door, Scratch, Wind Chime",
+        "pitch_range": range(128),
+    },
+    {"name": "Helicopter, Car Sounds", "pitch_range": range(128)},
+    {
+        "name": "Applause, Laughing, Screaming, Punch, Heart Beat, Footstep",
+        "pitch_range": range(128),
+    },
+    {"name": "Gunshot, Machine Gun, Lasergun, Explosion", "pitch_range": range(128)},
+]
+
+INSTRUMENTS_CLASSES = [
+    {"name": "Piano", "program_range": range(8)},  # 0
+    {"name": "Chromatic Percussion", "program_range": range(8, 16)},
+    {"name": "Organ", "program_range": range(16, 24)},
+    {"name": "Guitar", "program_range": range(24, 32)},
+    {"name": "Bass", "program_range": range(32, 40)},
+    {"name": "Strings", "program_range": range(40, 48)},  # 5
+    {"name": "Ensemble", "program_range": range(48, 56)},
+    {"name": "Brass", "program_range": range(56, 64)},
+    {"name": "Reed", "program_range": range(64, 72)},
+    {"name": "Pipe", "program_range": range(72, 80)},
+    {"name": "Synth Lead", "program_range": range(80, 88)},  # 10
+    {"name": "Synth Pad", "program_range": range(88, 96)},
+    {"name": "Synth Effects", "program_range": range(96, 104)},
+    {"name": "Ethnic", "program_range": range(104, 112)},
+    {"name": "Percussive", "program_range": range(112, 120)},
+    {"name": "Sound Effects", "program_range": range(120, 128)},  # 15
+    {"name": "Drums", "program_range": range(-1, 0)},
+]
+
+# To easily get the class index of any instrument program
+CLASS_OF_INST = [
+    i
+    for i, inst_class in enumerate(INSTRUMENTS_CLASSES)
+    for _ in inst_class["program_range"]
+]
+
+# index i = program i+1 in the GM2 specs (8. Appendix B)
+# index i = program i retrieved by packages
+DRUMS_SETS = {
+    0: "Standard",
+    8: "Room",
+    16: "Power",
+    24: "Electronic",
+    25: "Analog",
+    32: "Jazz",
+    40: "Brush",
+    48: "Orchestra",
+    56: "SFX",
+}
+
+# Control changes list (without specifications):
+# https://www.midi.org/specifications-old/item/table-3-control-change-messages-data-bytes-2
+# Undefined and general control changes are not considered here
+# All these attributes can take values from 0 to 127, with some of them being on/off
+CONTROL_CHANGES = {
+    # MSB
+    0: "Bank Select",
+    1: "Modulation Depth",
+    2: "Breath Controller",
+    4: "Foot Controller",
+    5: "Portamento Time",
+    6: "Data Entry",
+    7: "Channel Volume",
+    8: "Balance",
+    10: "Pan",
+    11: "Expression Controller",
+    # LSB
+    32: "Bank Select",
+    33: "Modulation Depth",
+    34: "Breath Controller",
+    36: "Foot Controller",
+    37: "Portamento Time",
+    38: "Data Entry",
+    39: "Channel Volume",
+    40: "Balance",
+    42: "Pan",
+    43: "Expression Controller",
+    # On / Off control changes, ≤63 off, ≥64 on
+    64: "Damper Pedal",
+    65: "Portamento",
+    66: "Sostenuto",
+    67: "Soft Pedal",
+    68: "Legato Footswitch",
+    69: "Hold 2",
+    # Continuous controls
+    70: "Sound Variation",
+    71: "Timbre/Harmonic Intensity",
+    72: "Release Time",
+    73: "Attack Time",
+    74: "Brightness",
+    75: "Decay Time",
+    76: "Vibrato Rate",
+    77: "Vibrato Depth",
+    78: "Vibrato Delay",
+    84: "Portamento Control",
+    88: "High Resolution Velocity Prefix",
+    # Effects depths
+    91: "Reverb Depth",
+    92: "Tremolo Depth",
+    93: "Chorus Depth",
+    94: "Celeste Depth",
+    95: "Phaser Depth",
+    # Registered parameters numbers
+    96: "Data Increment",
+    97: "Data Decrement",
+    #  98: 'Non-Registered Parameter Number (NRPN) - LSB',
+    #  99: 'Non-Registered Parameter Number (NRPN) - MSB',
+    100: "Registered Parameter Number (RPN) - LSB",
+    101: "Registered Parameter Number (RPN) - MSB",
+    # Channel mode controls
+    120: "All Sound Off",
+    121: "Reset All Controllers",
+    122: "Local Control On/Off",
+    123: "All Notes Off",
+    124: "Omni Mode Off",  # + all notes off
+    125: "Omni Mode On",  # + all notes off
+    126: "Mono Mode On",  # + poly off, + all notes off
+    127: "Poly Mode On",  # + mono off, +all notes off
+}
+
+###################################################################################
+
+def patches_onset_times(escore_notes, times_idx=1, patches_idx=6):
+    
+    patches = [e[patches_idx] for e in escore_notes]
+
+    patches_oset = ordered_set(patches)
+
+    patches_onset_times = []
+
+    for p in patches_oset:
+        for e in escore_notes:
+            if e[patches_idx] == p:
+                patches_onset_times.append([p, e[times_idx]])
+                break
+
+    return patches_onset_times
+
+###################################################################################
+
+def count_escore_notes_patches(escore_notes, patches_idx=6):
+
+    patches = [e[patches_idx] for e in escore_notes]
+
+    return Counter(patches).most_common()
+
+###################################################################################
+
+def escore_notes_monoponic_melodies(escore_notes,
+                                    bad_notes_ratio=0.0,
+                                    times_idx=1,
+                                    patches_idx=6
+                                    ):
+
+    patches = escore_notes_patches(escore_notes, patches_index=patches_idx)
+
+    monophonic_melodies = []
+
+    for p in patches:
+        patch_score = [e for e in escore_notes if e[patches_idx] == p]
+
+        ps_times = [e[times_idx] for e in patch_score]
+
+        if len(ps_times) <= len(set(ps_times)) * (1+bad_notes_ratio):
+            monophonic_melodies.append([p, len(patch_score)])
+            
+    return monophonic_melodies
+
+###################################################################################
+
+from itertools import groupby
+from operator import itemgetter
+
+def group_by_threshold(data, threshold, groupby_idx):
+
+    data.sort(key=itemgetter(groupby_idx))
+
+    grouped_data = []
+    cluster = []
+
+    for i, item in enumerate(data):
+        if not cluster:
+            cluster.append(item)
+        elif abs(item[groupby_idx] - cluster[-1][groupby_idx]) <= threshold:
+            cluster.append(item)
+        else:
+            grouped_data.append(cluster)
+            cluster = [item]
+    
+    if cluster:
+        grouped_data.append(cluster)
+        
+    return grouped_data
+
+###################################################################################
+
+def split_escore_notes_by_time(escore_notes, time_threshold=256):
+
+    dscore = delta_score_notes(escore_notes, timings_clip_value=time_threshold-1)
+
+    score_chunks = []
+
+    ctime = 0
+    pchunk_idx = 0
+
+    for i, e in enumerate(dscore):
+        
+        ctime += e[1]
+
+        if ctime >= time_threshold:
+            score_chunks.append(escore_notes[pchunk_idx:i])
+            pchunk_idx = i
+            ctime = 0
+
+    return score_chunks
+
+###################################################################################
+
+def escore_notes_grouped_patches(escore_notes, time_threshold=256):
+    
+    split_score_chunks = split_escore_notes_by_time(escore_notes,
+                                                    time_threshold=time_threshold
+                                                    )
+
+    chunks_patches = []
+
+    for s in split_score_chunks:
+        chunks_patches.append(escore_notes_patches(s))
+
+    return chunks_patches
+
+###################################################################################
+
+def computeLPSArray(pattern, M, lps):
+    length = 0
+    i = 1
+    
+    lps[0] = 0
+    
+    while i < M:
+        if pattern[i] == pattern[length]:
+            length += 1
+            lps[i] = length
+            i += 1
+        else:
+            if length != 0:
+                length = lps[length-1]
+            else:
+                lps[i] = 0
+                i += 1
+                
+###################################################################################
+
+def find_pattern_idxs(sub_pattern, pattern):
+
+    lst = pattern
+    pattern = sub_pattern
+    
+    M = len(pattern)
+    N = len(lst)
+    
+    lps = [0] * M
+    j = 0  # index for pattern[]
+
+    computeLPSArray(pattern, M, lps)
+    
+    i = 0  # index for lst[]
+    indexes = []
+    
+    while i < N:
+        if pattern[j] == lst[i]:
+            i += 1
+            j += 1
+        
+        if j == M:
+            end_index = i - 1
+            start_index = end_index - M + 1
+            indexes.append((start_index, end_index))
+            j = lps[j-1]
+        elif i < N and pattern[j] != lst[i]:
+            if j != 0:
+                j = lps[j-1]
+            else:
+                i += 1
+                
+    return indexes
+
+###################################################################################
+
+def escore_notes_patch_lrno_patterns(escore_notes, 
+                                     patch=0, 
+                                     zero_score_timings=False,
+                                     pitches_idx=4,
+                                     patches_idx=6
+                                    ):
+
+    patch_escore = [e for e in escore_notes if e[patches_idx] == patch]
+
+    if patch_escore:
+        
+        patch_cscore = chordify_score([1000, patch_escore])
+    
+        patch_tscore = []
+    
+        for c in patch_cscore:
+    
+            tones_chord = sorted(set([p[pitches_idx] % 12 for p in c]))
+    
+            if tones_chord not in ALL_CHORDS_SORTED:
+                tnoes_chord = check_and_fix_tones_chord(tones_chord)
+    
+            patch_tscore.append(ALL_CHORDS_SORTED.index(tones_chord))
+    
+        pattern = find_lrno_pattern_fast(patch_tscore)
+    
+        patterns_idxs = find_pattern_idxs(pattern, patch_tscore)
+    
+        patch_lrno_scores = []
+    
+        for idxs in patterns_idxs:
+            
+            score = patch_escore[idxs[0]:idxs[1]]
+            
+            if zero_score_timings:
+                score = recalculate_score_timings(score)
+                
+            patch_lrno_scores.append(score)
+    
+        return patch_lrno_scores
+        
+    else:
+        return []
+
+###################################################################################
+
+ALL_BASE_CHORDS_SORTED = [[0], [0, 2], [0, 2, 4], [0, 2, 4, 6], [0, 2, 4, 6, 8], [0, 2, 4, 6, 8, 10],
+                         [0, 2, 4, 6, 9], [0, 2, 4, 6, 10], [0, 2, 4, 7], [0, 2, 4, 7, 9],
+                         [0, 2, 4, 7, 10], [0, 2, 4, 8], [0, 2, 4, 8, 10], [0, 2, 4, 9], [0, 2, 4, 10],
+                         [0, 2, 5], [0, 2, 5, 7], [0, 2, 5, 7, 9], [0, 2, 5, 7, 10], [0, 2, 5, 8],
+                         [0, 2, 5, 8, 10], [0, 2, 5, 9], [0, 2, 5, 10], [0, 2, 6], [0, 2, 6, 8],
+                         [0, 2, 6, 8, 10], [0, 2, 6, 9], [0, 2, 6, 10], [0, 2, 7], [0, 2, 7, 9],
+                         [0, 2, 7, 10], [0, 2, 8], [0, 2, 8, 10], [0, 2, 9], [0, 2, 10], [0, 3],
+                         [0, 3, 5], [0, 3, 5, 7], [0, 3, 5, 7, 9], [0, 3, 5, 7, 10], [0, 3, 5, 8],
+                         [0, 3, 5, 8, 10], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6], [0, 3, 6, 8],
+                         [0, 3, 6, 8, 10], [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 9],
+                         [0, 3, 7, 10], [0, 3, 8], [0, 3, 8, 10], [0, 3, 9], [0, 3, 10], [0, 4],
+                         [0, 4, 6], [0, 4, 6, 8], [0, 4, 6, 8, 10], [0, 4, 6, 9], [0, 4, 6, 10],
+                         [0, 4, 7], [0, 4, 7, 9], [0, 4, 7, 10], [0, 4, 8], [0, 4, 8, 10], [0, 4, 9],
+                         [0, 4, 10], [0, 5], [0, 5, 7], [0, 5, 7, 9], [0, 5, 7, 10], [0, 5, 8],
+                         [0, 5, 8, 10], [0, 5, 9], [0, 5, 10], [0, 6], [0, 6, 8], [0, 6, 8, 10],
+                         [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 9], [0, 7, 10], [0, 8], [0, 8, 10],
+                         [0, 9], [0, 10]]
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module