Spaces:
Runtime error
Runtime error
| from src.music.pipeline.url2audio import url2audio | |
| from src.music.pipeline.audio2midi import audio2midi | |
| from src.music.pipeline.midi2processed import midi2processed | |
| from src.music.pipeline.processed2encoded import processed2encoded | |
| from src.music.pipeline.encoded2rep import encoded2rep | |
| from src.music.config import RANDOM_CROP, NB_AUG, FROM_URL_PATH | |
| # from src.music.pipeline.synth2audio import AudioRecorder | |
| # from src.music.pipeline.processed2handcodedrep import processed2handcodedrep | |
| import time | |
| import hashlib | |
| VERBOSE = True | |
| AUGMENTATION, NOISE_INJECTED = False, False | |
| CROP = 10# crop 30s before transcription | |
| # AUDIO_RECORDER = AudioRecorder(place='home') | |
| def encode_music(url=None, | |
| audio_path=None, | |
| midi_path=None, | |
| processed_path=None, | |
| record=False, | |
| crop=CROP, | |
| random_crop=RANDOM_CROP, | |
| augmentation=AUGMENTATION, | |
| noise_injection=NOISE_INJECTED, | |
| apply_filtering=True, | |
| nb_aug=NB_AUG, | |
| level=0, | |
| verbose=VERBOSE): | |
| if not record: assert url is not None or audio_path is not None or midi_path is not None or processed_path is not None | |
| init_time = time.time() | |
| error = '' | |
| try: | |
| if record: | |
| assert audio_path is None and midi_path is None | |
| if verbose: print(' ' * level + 'Processing music, recorded from mic.') | |
| audio_path = AUDIO_RECORDER.record_one() | |
| error = '' | |
| if processed_path is None: | |
| if midi_path is None: | |
| if audio_path is None: | |
| if verbose and not record: print(' ' * level + 'Processing music, from audio source.') | |
| init_t = time.time() | |
| audio_path, _, error = url2audio(playlist_path=FROM_URL_PATH, video_url=url, verbose=verbose, level=level+2) | |
| if verbose: print(' ' * (level + 4) + f'Audio downloaded in {int(time.time() - init_t)} seconds.') | |
| else: | |
| if verbose and not record: print(' ' * level + 'Processing music, from midi source.') | |
| init_t = time.time() | |
| midi_path, error = audio2midi(audio_path, crop=crop, random_crop=random_crop, verbose=verbose, level=level+2) | |
| if verbose: print(' ' * (level + 4) + f'Audio transcribed to midi in {int(time.time() - init_t)} seconds.') | |
| init_t = time.time() | |
| processed_path, error = midi2processed(midi_path, apply_filtering=apply_filtering, verbose=verbose, level=level+2) | |
| if verbose: print(' ' * (level + 4) + f'Midi preprocessed in {int(time.time() - init_t)} seconds.') | |
| init_t = time.time() | |
| encoded_path, error = processed2encoded(processed_path, augmentation=augmentation, nb_aug=nb_aug, noise_injection=noise_injection, verbose=verbose, level=level+2) | |
| if verbose: print(' ' * (level + 4) + f'Midi encoded in {int(time.time() - init_t)} seconds.') | |
| init_t = time.time() | |
| representation_path, representation, error = encoded2rep(encoded_path, return_rep=True, level=level+2, verbose=verbose) | |
| if verbose: print(' ' * (level + 4) + f'Music representation computed in {int(time.time() - init_t)} seconds.') | |
| init_t = time.time() | |
| handcoded_rep_path, handcoded_rep, error = None, None, '' | |
| # handcoded_rep_path, handcoded_rep, error = processed2handcodedrep(processed_path, return_rep=True, level=level+2, verbose=verbose) | |
| if verbose: print(' ' * (level + 4) + f'Music handcoded representation computed in {int(time.time() - init_t)} seconds.') | |
| # assert handcoded_rep_path is not None and representation_path is not None | |
| all_paths = dict(url=url, audio_path=audio_path, midi_path=midi_path, processed_path=processed_path, encoded_path=encoded_path, | |
| representation_path=representation_path, handcoded_rep_path=handcoded_rep_path) | |
| print('audio hash: ', hashlib.md5(open(audio_path, 'rb').read()).hexdigest()) | |
| print('midi hash: ', hashlib.md5(open(midi_path, 'rb').read()).hexdigest()) | |
| print('processed hash: ', hashlib.md5(open(processed_path, 'rb').read()).hexdigest()) | |
| print('encoded hash: ', hashlib.md5(open(encoded_path, 'rb').read()).hexdigest()) | |
| print('rep hash: ', hashlib.md5(open(representation_path, 'rb').read()).hexdigest()) | |
| if verbose: print(' ' * (level + 2) + f'Music processed in {int(time.time() - init_time)} seconds.') | |
| except: | |
| if verbose: print(' ' * (level + 2) + f'Music FAILED to process in {int(time.time() - init_time)} seconds.') | |
| representation = None | |
| handcoded_rep = None | |
| all_paths = dict() | |
| return representation, handcoded_rep, all_paths, error | |
| if __name__ == '__main__': | |
| representation = encode_music(url="https://www.youtube.com/watch?v=a2LFVWBmoiw")[0] | |
| # representation = encode_music(record=True)[0] |