Upload 2 files

TMIDIX.py

@@ -1461,6 +1461,7 @@ import tqdm
 
 from itertools import zip_longest
 from itertools import groupby
+from collections import Counter
 
 from operator import itemgetter
 
@@ -3852,7 +3853,8 @@ ALL_CHORDS = [[0], [7], [5], [9], [2], [4], [11], [10], [8], [6], [3], [1], [0,
               [2, 5, 7, 9, 11], [1, 3, 5, 7, 10], [0, 2, 4, 7, 10], [1, 3, 5, 7, 9],
               [1, 3, 5, 9, 11], [1, 5, 7, 9, 11], [1, 3, 7, 9, 11], [3, 5, 7, 9, 11],
               [2, 4, 6, 8, 10], [0, 4, 6, 8, 10], [0, 2, 6, 8, 10], [1, 3, 5, 7, 11],
-              [0, 2, 4, 8, 10], [0, 2, 4, 6, 8], [0, 2, 4, 6, 10]]
+              [0, 2, 4, 8, 10], [0, 2, 4, 6, 8], [0, 2, 4, 6, 10], [0, 2, 4, 6, 8, 10],
+              [1, 3, 5, 7, 9, 11]]
 
 def find_exact_match_variable_length(list_of_lists, target_list, uncertain_indices):
     # Infer possible values for each uncertain index
@@ -3981,7 +3983,7 @@ def analyze_score_pitches(score, channels_to_analyze=[0]):
 
 ###################################################################################
 
-ALL_CHORDS_GROUPED = [
+ALL_CHORDS_GROUPED = [[[1, 3, 5, 7, 9, 11], [0, 2, 4, 6, 8, 10]],
     [[0, 2, 5, 7, 10], [0, 2, 4, 7, 9], [0, 2, 5, 7, 9], [1, 4, 6, 9, 11],
     [1, 3, 6, 8, 11], [1, 3, 6, 8, 10], [1, 4, 6, 8, 11], [1, 3, 5, 8, 10],
     [2, 4, 6, 9, 11], [2, 4, 7, 9, 11], [0, 3, 5, 7, 10], [0, 3, 5, 8, 10],
@@ -4427,12 +4429,15 @@ def ascii_texts_search(texts = ['text1', 'text2', 'text3'],
                        deterministic_matching = False
                        ):
 
+    texts_copy = texts
+
     if not deterministic_matching:
-      random.shuffle(texts)
+      texts_copy = copy.deepcopy(texts)
+      random.shuffle(texts_copy)
 
     clean_texts = []
 
-    for t in texts:
+    for t in texts_copy:
       text_words_list = [at.split(chr(32)) for at in t.split(chr(10))]
       
       clean_text_words_list = []
@@ -4473,7 +4478,7 @@ def ascii_texts_search(texts = ['text1', 'text2', 'text3'],
 
       if texts_match_ratios:
         max_text_match_ratio = max(texts_match_ratios)
-        max_match_ratio_text = texts[texts_match_ratios.index(max_text_match_ratio)]
+        max_match_ratio_text = texts_copy[texts_match_ratios.index(max_text_match_ratio)]
         max_text_words_match_indexes = words_match_indexes[texts_match_ratios.index(max_text_match_ratio)]
 
       return [max_match_ratio_text, max_text_match_ratio, max_text_words_match_indexes]
@@ -4507,6 +4512,56 @@ def ascii_text_words_counter(ascii_text):
     
 ###################################################################################
 
+def check_and_fix_tones_chord(tones_chord):
+
+    lst = tones_chord
+
+    if len(lst) == 2:
+      if lst[1] - lst[0] == 1:
+        return [lst[-1]]
+      else:
+        if 0 in lst and 11 in lst:
+          lst.remove(0)
+        return lst
+
+    non_consecutive = [lst[0]]
+
+    if len(lst) > 2: 
+      for i in range(1, len(lst) - 1):
+          if lst[i-1] + 1 != lst[i] and lst[i] + 1 != lst[i+1]:
+              non_consecutive.append(lst[i])
+      non_consecutive.append(lst[-1])
+
+    if 0 in non_consecutive and 11 in non_consecutive:
+      non_consecutive.remove(0)
+
+    return non_consecutive
+
+###################################################################################
+
+def create_similarity_matrix(list_of_values, matrix_length=0):
+
+    counts = Counter(list_of_values).items()
+
+    if matrix_length > 0:
+      sim_matrix = [0] * max(matrix_length, len(list_of_values))
+    else:
+      sim_matrix = [0] * len(counts)
+
+    for c in counts:
+      sim_matrix[c[0]] = c[1]
+
+    similarity_matrix = [[0] * len(sim_matrix) for _ in range(len(sim_matrix))]
+
+    for i in range(len(sim_matrix)):
+      for j in range(len(sim_matrix)):
+        if max(sim_matrix[i], sim_matrix[j]) != 0:
+          similarity_matrix[i][j] = min(sim_matrix[i], sim_matrix[j]) / max(sim_matrix[i], sim_matrix[j])
+
+    return similarity_matrix, sim_matrix
+
+###################################################################################
+
 # This is the end of the TMIDI X Python module
 
 ###################################################################################

midi_to_colab_audio.py

@@ -1,4 +1,4 @@
-#===================================================================================================================
+r'''#===================================================================================================================
 #
 # MIDI to Colab AUdio Python Module
 #
@@ -47,7 +47,6 @@
 # could break compatiblity, but there's not much else you can do to fix the bug
 # https://en.wikipedia.org/wiki/Shift_JIS
 
-r'''
 This module offers functions:  concatenate_scores(), grep(),
 merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(),
 opus2score(), play_score(), score2midi(), score2opus(), score2stats(),
@@ -2874,12 +2873,16 @@ def raw_audio_string(data):
 #===============================================================================
 
 import numpy as np
+import wave
 
 def midi_opus_to_colab_audio(midi_opus, 
                               soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2', 
                               sample_rate=16000, # 44100
                               volume_scale=10,
-                              output_for_gradio=False
+                              trim_silence=True,
+                              silence_threshold=0.1,
+                              output_for_gradio=False,
+                              write_audio_to_WAV=''
                               ):
 
     def normalize_volume(matrix, factor=10):
@@ -2889,68 +2892,95 @@ def midi_opus_to_colab_audio(midi_opus,
         final_matrix = np.clip(mult_matrix, -1.0, 1.0)
         return final_matrix
 
-    ticks_per_beat = midi_opus[0]
-    event_list = []
-    for track_idx, track in enumerate(midi_opus[1:]):
-        abs_t = 0
-        for event in track:
-            abs_t += event[1]
-            event_new = [*event]
-            event_new[1] = abs_t
-            event_list.append(event_new)
-    event_list = sorted(event_list, key=lambda e: e[1])
-
-    tempo = int((60 / 120) * 10 ** 6)  # default 120 bpm
-    ss = np.empty((0, 2), dtype=np.int16)
-    fl = Synth(samplerate=float(sample_rate))
-    sfid = fl.sfload(soundfont_path)
-    last_t = 0
-    for c in range(16):
-        fl.program_select(c, sfid, 128 if c == 9 else 0, 0)
-    for event in event_list:
-        name = event[0]
-        sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
-        sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
-        last_t = event[1]
-        if sample_len > 0:
-            sample = fl.get_samples(sample_len).reshape(sample_len, 2)
-            ss = np.concatenate([ss, sample])
-        if name == "set_tempo":
-            tempo = event[2]
-        elif name == "patch_change":
-            c, p = event[2:4]
-            fl.program_select(c, sfid, 128 if c == 9 else 0, p)
-        elif name == "control_change":
-            c, cc, v = event[2:5]
-            fl.cc(c, cc, v)
-        elif name == "note_on" and event[3] > 0:
-            c, p, v = event[2:5]
-            fl.noteon(c, p, v)
-        elif name == "note_off" or (name == "note_on" and event[3] == 0):
-            c, p = event[2:4]
-            fl.noteoff(c, p)
-
-    fl.delete()
-    if ss.shape[0] > 0:
-        max_val = np.abs(ss).max()
-        if max_val != 0:
-            ss = (ss / max_val) * np.iinfo(np.int16).max
-    ss = ss.astype(np.int16)
-
-    ss = ss.swapaxes(1, 0)
-
-    raw_audio = normalize_volume(ss, volume_scale)
-
-    if output_for_gradio:
-      raw_audio = np.transpose(raw_audio)
-    
-    return raw_audio
+    if midi_opus[1]:
+
+      ticks_per_beat = midi_opus[0]
+      event_list = []
+      for track_idx, track in enumerate(midi_opus[1:]):
+          abs_t = 0
+          for event in track:
+              abs_t += event[1]
+              event_new = [*event]
+              event_new[1] = abs_t
+              event_list.append(event_new)
+      event_list = sorted(event_list, key=lambda e: e[1])
+
+      tempo = int((60 / 120) * 10 ** 6)  # default 120 bpm
+      ss = np.empty((0, 2), dtype=np.int16)
+      fl = Synth(samplerate=float(sample_rate))
+      sfid = fl.sfload(soundfont_path)
+      last_t = 0
+      for c in range(16):
+          fl.program_select(c, sfid, 128 if c == 9 else 0, 0)
+      for event in event_list:
+          name = event[0]
+          sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
+          sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
+          last_t = event[1]
+          if sample_len > 0:
+              sample = fl.get_samples(sample_len).reshape(sample_len, 2)
+              ss = np.concatenate([ss, sample])
+          if name == "set_tempo":
+              tempo = event[2]
+          elif name == "patch_change":
+              c, p = event[2:4]
+              fl.program_select(c, sfid, 128 if c == 9 else 0, p)
+          elif name == "control_change":
+              c, cc, v = event[2:5]
+              fl.cc(c, cc, v)
+          elif name == "note_on" and event[3] > 0:
+              c, p, v = event[2:5]
+              fl.noteon(c, p, v)
+          elif name == "note_off" or (name == "note_on" and event[3] == 0):
+              c, p = event[2:4]
+              fl.noteoff(c, p)
+
+      fl.delete()
+      if ss.shape[0] > 0:
+          max_val = np.abs(ss).max()
+          if max_val != 0:
+              ss = (ss / max_val) * np.iinfo(np.int16).max
+      ss = ss.astype(np.int16)
+
+      if trim_silence:
+          threshold = np.std(np.abs(ss)) * silence_threshold
+          exceeded_thresh = np.abs(ss) > threshold
+          if np.any(exceeded_thresh): 
+              last_idx = np.where(exceeded_thresh)[0][-1]
+              ss = ss[:last_idx+1]
+
+      if output_for_gradio:
+        return ss
+      
+      ss = ss.swapaxes(1, 0)
+
+      raw_audio = normalize_volume(ss, volume_scale)
+      
+      if write_audio_to_WAV != '':
+
+        r_audio = raw_audio.T
+
+        r_audio = np.int16(r_audio / np.max(np.abs(r_audio)) * 32767)
+
+        with wave.open(write_audio_to_WAV, 'w') as wf:
+            wf.setframerate(sample_rate)
+            wf.setsampwidth(2)
+            wf.setnchannels(r_audio.shape[1])
+            wf.writeframes(r_audio)
+
+      return raw_audio
+  
+    else:
+      return None
 
 def midi_to_colab_audio(midi_file, 
                         soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2', 
                         sample_rate=16000, # 44100
                         volume_scale=10,
-                        output_for_gradio=False
+                        trim_silence=True,
+                        silence_threshold=0.1,
+                        output_for_gradio=False,
+                        write_audio_to_WAV=False
                         ):
 
     '''
@@ -2965,8 +2995,6 @@ def midi_to_colab_audio(midi_file,
     
     '''
 
-    midi_opus = midi2opus(open(midi_file, 'rb').read())
-
     def normalize_volume(matrix, factor=10):
         norm = np.linalg.norm(matrix)
         matrix = matrix/norm  # normalized matrix
@@ -2974,61 +3002,89 @@ def midi_to_colab_audio(midi_file,
         final_matrix = np.clip(mult_matrix, -1.0, 1.0)
         return final_matrix
 
-    ticks_per_beat = midi_opus[0]
-    event_list = []
-    for track_idx, track in enumerate(midi_opus[1:]):
-        abs_t = 0
-        for event in track:
-            abs_t += event[1]
-            event_new = [*event]
-            event_new[1] = abs_t
-            event_list.append(event_new)
-    event_list = sorted(event_list, key=lambda e: e[1])
-
-    tempo = int((60 / 120) * 10 ** 6)  # default 120 bpm
-    ss = np.empty((0, 2), dtype=np.int16)
-    fl = Synth(samplerate=float(sample_rate))
-    sfid = fl.sfload(soundfont_path)
-    last_t = 0
-    for c in range(16):
-        fl.program_select(c, sfid, 128 if c == 9 else 0, 0)
-    for event in event_list:
-        name = event[0]
-        sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
-        sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
-        last_t = event[1]
-        if sample_len > 0:
-            sample = fl.get_samples(sample_len).reshape(sample_len, 2)
-            ss = np.concatenate([ss, sample])
-        if name == "set_tempo":
-            tempo = event[2]
-        elif name == "patch_change":
-            c, p = event[2:4]
-            fl.program_select(c, sfid, 128 if c == 9 else 0, p)
-        elif name == "control_change":
-            c, cc, v = event[2:5]
-            fl.cc(c, cc, v)
-        elif name == "note_on" and event[3] > 0:
-            c, p, v = event[2:5]
-            fl.noteon(c, p, v)
-        elif name == "note_off" or (name == "note_on" and event[3] == 0):
-            c, p = event[2:4]
-            fl.noteoff(c, p)
-
-    fl.delete()
-    if ss.shape[0] > 0:
-        max_val = np.abs(ss).max()
-        if max_val != 0:
-            ss = (ss / max_val) * np.iinfo(np.int16).max
-    ss = ss.astype(np.int16)
-    
-    if output_for_gradio:
+    midi_opus = midi2opus(open(midi_file, 'rb').read())
+
+    if midi_opus[1]:
+
+      ticks_per_beat = midi_opus[0]
+      event_list = []
+      for track_idx, track in enumerate(midi_opus[1:]):
+          abs_t = 0
+          for event in track:
+              abs_t += event[1]
+              event_new = [*event]
+              event_new[1] = abs_t
+              event_list.append(event_new)
+      event_list = sorted(event_list, key=lambda e: e[1])
+
+      tempo = int((60 / 120) * 10 ** 6)  # default 120 bpm
+      ss = np.empty((0, 2), dtype=np.int16)
+      fl = Synth(samplerate=float(sample_rate))
+      sfid = fl.sfload(soundfont_path)
+      last_t = 0
+      for c in range(16):
+          fl.program_select(c, sfid, 128 if c == 9 else 0, 0)
+      for event in event_list:
+          name = event[0]
+          sample_len = int(((event[1] / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
+          sample_len -= int(((last_t / ticks_per_beat) * tempo / (10 ** 6)) * sample_rate)
+          last_t = event[1]
+          if sample_len > 0:
+              sample = fl.get_samples(sample_len).reshape(sample_len, 2)
+              ss = np.concatenate([ss, sample])
+          if name == "set_tempo":
+              tempo = event[2]
+          elif name == "patch_change":
+              c, p = event[2:4]
+              fl.program_select(c, sfid, 128 if c == 9 else 0, p)
+          elif name == "control_change":
+              c, cc, v = event[2:5]
+              fl.cc(c, cc, v)
+          elif name == "note_on" and event[3] > 0:
+              c, p, v = event[2:5]
+              fl.noteon(c, p, v)
+          elif name == "note_off" or (name == "note_on" and event[3] == 0):
+              c, p = event[2:4]
+              fl.noteoff(c, p)
+
+      fl.delete()
+      if ss.shape[0] > 0:
+          max_val = np.abs(ss).max()
+          if max_val != 0:
+              ss = (ss / max_val) * np.iinfo(np.int16).max
+      ss = ss.astype(np.int16)
+
+      if trim_silence:
+          threshold = np.std(np.abs(ss)) * silence_threshold
+          exceeded_thresh = np.abs(ss) > threshold
+          if np.any(exceeded_thresh): 
+              last_idx = np.where(exceeded_thresh)[0][-1]
+              ss = ss[:last_idx+1]
+
+      if output_for_gradio:
         return ss
 
-    ss = ss.swapaxes(1, 0)
+      ss = ss.swapaxes(1, 0)
 
-    raw_audio = normalize_volume(ss, volume_scale)
-    
-    return raw_audio
+      raw_audio = normalize_volume(ss, volume_scale)
+
+      if write_audio_to_WAV:
+
+        filename = midi_file.split('.')[-2] + '.wav'
+
+        r_audio = raw_audio.T
+
+        r_audio = np.int16(r_audio / np.max(np.abs(r_audio)) * 32767)
+
+        with wave.open(filename, 'w') as wf:
+            wf.setframerate(sample_rate)
+            wf.setsampwidth(2)
+            wf.setnchannels(r_audio.shape[1])
+            wf.writeframes(r_audio)
+
+      return raw_audio
+  
+    else:
+      return None
     
 #===================================================================================================================