This commit is contained in:
Vadim committed 2024-07-22 23:40:05 +02:00
1 parent 1a819dfbd0
commit e293587f30
14 files changed
+320 -272

No files matched your search

@@ -1,6 +1,6 @@
"""Tests for ultrastar_converter.py"""
from src.modules.Ultrastar.ultrastar_converter import real_bpm_to_ultrastar_bpm
from modules.Ultrastar.coverter.ultrastar_converter import real_bpm_to_ultrastar_bpm
def test_real_bpm_to_ultrastar_bpm():
+6 -7
View File
@@ -4,8 +4,7 @@ import unittest
import os
from unittest.mock import patch, MagicMock
from modules.Ultrastar.ultrastar_writer import format_separated_string
from src.UltraSinger import extract_year
from src.UltraSinger import parse_ultrastar_txt
from modules.Ultrastar.ultrastar_parser import parse_ultrastar_txt
from src import UltraSinger
class TestUltraSinger(unittest.TestCase):
@@ -18,11 +17,11 @@ class TestUltraSinger(unittest.TestCase):
self.assertEqual(format_separated_string('rock, pop, rock-pop, '), 'Rock, Pop, Rock-Pop')
def test_extract_year(self):
years = {extract_year("2023-12-31"), extract_year("2023-12-31 23:59:59"), extract_year("2023/12/31"),
extract_year("2023\\12\\31"), extract_year("2023.12.31"), extract_year("2023 12 31"),
extract_year("12-31-2023"), extract_year("12/31/2023"), extract_year("12\\31\\2023"),
extract_year("12.31.2023"), extract_year("12 31 2023"), extract_year("12-2023"),
extract_year("12/2023"), extract_year("2023")}
years = {__extract_year("2023-12-31"), __extract_year("2023-12-31 23:59:59"), __extract_year("2023/12/31"),
__extract_year("2023\\12\\31"), __extract_year("2023.12.31"), __extract_year("2023 12 31"),
__extract_year("12-31-2023"), __extract_year("12/31/2023"), __extract_year("12\\31\\2023"),
__extract_year("12.31.2023"), __extract_year("12 31 2023"), __extract_year("12-2023"),
__extract_year("12/2023"), __extract_year("2023")}
for year in years:
self.assertEqual(year, "2023")
+2 -1
View File
@@ -4,6 +4,7 @@ from dataclasses_json import dataclass_json
from modules.Audio.separation import DemucsModel
from modules.Speech_Recognition.Whisper import WhisperModel
from modules.Ultrastar.ultrastar_txt import FormatVersion
@dataclass_json
@@ -26,7 +27,7 @@ class Settings:
output_folder_path = ""
language = None
format_version = "1.0.0"
format_version = FormatVersion.V1_0_0
# Demucs
demucs_model = DemucsModel.HTDEMUCS # htdemucs|htdemucs_ft|htdemucs_6s|hdemucs_mmi|mdx|mdx_extra|mdx_q|mdx_extra_q|SIG
+42 -179
View File
@@ -1,7 +1,6 @@
"""UltraSinger uses AI to automatically create UltraStar song files"""
import copy
import re
import getopt
import os
import sys
@@ -22,7 +21,7 @@ from modules.Audio.convert_audio import convert_audio_to_mono_wav, convert_wav_t
from modules.Audio.youtube import (
download_from_youtube,
)
from modules.Ultrastar.ultrastar_writer import format_separated_string
from modules.console_colors import (
ULTRASINGER_HEAD,
blue_highlighted,
@@ -31,33 +30,35 @@ from modules.console_colors import (
green_highlighted,
)
from modules.Midi.midi_creator import (
convert_midi_notes_to_ultrastar_notes,
create_midi_segments_from_transcribed_data,
create_repitched_midi_segments_from_ultrastar_txt,
create_midi_file,
)
from modules.Pitcher.pitcher import (
get_pitch_with_crepe_file,
)
from modules.Pitcher.pitched_data import PitchedData
from modules.Speech_Recognition.TranscriptionResult import TranscriptionResult
from modules.Speech_Recognition.hyphenation import (
hyphenate_each_word,
)
from modules.Speech_Recognition.Whisper import transcribe_with_whisper
from modules.Ultrastar import (
ultrastar_score_calculator,
ultrastar_writer,
ultrastar_parser,
)
from modules.Ultrastar.ultrastar_score_calculator import Score
from modules.Ultrastar.ultrastar_txt import FILE_ENCODING
from modules.Speech_Recognition.TranscribedData import TranscribedData
from modules.Ultrastar.ultrastar_score_calculator import Score, calculate_score_points
from modules.Ultrastar.ultrastar_txt import FILE_ENCODING, FormatVersion
from modules.Ultrastar.coverter.ultrastar_txt_converter import from_ultrastar_txt, \
create_ultrastar_txt_from_midi_segments, create_ultrastar_txt_from_automation
from modules.Ultrastar.ultrastar_parser import parse_ultrastar_txt
from modules.common_print import print_support, print_help, print_version
from modules.os_helper import check_file_exists, get_unused_song_output_dir
from modules.plot import create_plots
from modules.musicbrainz_client import get_music_infos
from modules.sheet import create_sheet
from modules.ProcessData import *
from modules.ProcessData import ProcessData, ProcessDataPaths, MediaInfo
from modules.DeviceDetection.device_detection import check_gpu_support
from modules.Audio.bpm import get_bpm_from_file
@@ -65,6 +66,7 @@ from Settings import Settings
settings = Settings()
def add_hyphen_to_data(
transcribed_data: list[TranscribedData], hyphen_words: list[list[str]]
):
@@ -97,6 +99,7 @@ def add_hyphen_to_data(
return new_data
# Todo: Unused
def correct_words(recognized_words, word_list_file):
"""Docstring"""
@@ -151,9 +154,11 @@ def run() -> tuple[str, Score, Score]:
# Create Midi_Segments
if not settings.ignore_audio:
process_data.midi_segments = create_midi_segments_from_transcribed_data(process_data.transcribed_data, process_data.pitched_data)
process_data.midi_segments = create_midi_segments_from_transcribed_data(process_data.transcribed_data,
process_data.pitched_data)
else:
process_data.midi_segments = create_repitched_midi_segments_from_ultrastar_txt(process_data.pitched_data, process_data.parsed_file)
process_data.midi_segments = create_repitched_midi_segments_from_ultrastar_txt(process_data.pitched_data,
process_data.parsed_file)
# Create plot
if settings.create_plot:
@@ -202,7 +207,7 @@ def InitProcessData():
settings.output_folder_path,
audio_file_path,
ultrastar_class,
) = parse_ultrastar_txt()
) = parse_ultrastar_txt(settings.input_file_path, settings.output_folder_path)
process_data = from_ultrastar_txt(ultrastar_class)
process_data.basename = basename
process_data.process_data_paths.audio_output_file_path = audio_file_path
@@ -257,11 +262,11 @@ def TranscribeAudio(process_data):
def CreateUltraStarTxt(process_data: ProcessData):
# Move instrumental and vocals
if settings.create_karaoke and version.parse(settings.format_version) < version.parse("1.1.0"):
if settings.create_karaoke and version.parse(settings.format_version.value) < version.parse(FormatVersion.V1_1_0.value):
karaoke_output_path = os.path.join(settings.output_folder_path, process_data.basename + " [Karaoke].mp3")
convert_wav_to_mp3(process_data.process_data_paths.instrumental_audio_file_path, karaoke_output_path)
if version.parse(settings.format_version) >= version.parse("1.1.0"):
if version.parse(settings.format_version.value) >= version.parse(FormatVersion.V1_1_0.value):
instrumental_output_path = os.path.join(settings.output_folder_path,
process_data.basename + " [Instrumental].mp3")
convert_wav_to_mp3(process_data.process_data_paths.instrumental_audio_file_path, instrumental_output_path)
@@ -274,20 +279,21 @@ def CreateUltraStarTxt(process_data: ProcessData):
process_data.basename,
settings.output_folder_path,
process_data.midi_segments,
process_data.media_info
process_data.media_info,
settings.format_version,
settings.create_karaoke,
settings.APP_VERSION
)
else:
ultrastar_file_output = create_ultrastar_txt_from_ultrastar_data(
settings.output_folder_path, process_data.media_info.title, process_data.midi_segments
ultrastar_file_output = create_ultrastar_txt_from_midi_segments(
settings.output_folder_path, settings.input_file_path, process_data.media_info.title, process_data.midi_segments
)
# Calc Points
simple_score = None
accurate_score = None
if settings.calculate_score:
ultrastar_class, simple_score, accurate_score = calculate_score_points(
process_data, ultrastar_file_output
)
simple_score, accurate_score = calculate_score_points(process_data, ultrastar_file_output)
# Add calculated score to Ultrastar txt
#Todo: Missing Karaoke
@@ -372,121 +378,6 @@ def transcribe_audio(cache_folder_path: str, processing_audio_path: str) -> Tran
return transcription_result
def calculate_score_points(
processed_data: ProcessData,
ultrastar_file_output: str,
):
"""Calculate score points"""
if not settings.ignore_audio:
ultrastar_txt = ultrastar_parser.parse_ultrastar_txt(ultrastar_file_output)
(
simple_score,
accurate_score,
) = ultrastar_score_calculator.calculate_score(processed_data.pitched_data, ultrastar_txt)
ultrastar_score_calculator.print_score_calculation(simple_score, accurate_score)
else:
print(
f"{ULTRASINGER_HEAD} {blue_highlighted('Score of original Ultrastar txt')}"
)
(
simple_score,
accurate_score,
) = ultrastar_score_calculator.calculate_score(processed_data.pitched_data, processed_data.parsed_file)
ultrastar_score_calculator.print_score_calculation(simple_score, accurate_score)
print(
f"{ULTRASINGER_HEAD} {blue_highlighted('Score of re-pitched Ultrastar txt')}"
)
ultrastar_txt = ultrastar_parser.parse_ultrastar_txt(ultrastar_file_output)
(
simple_score,
accurate_score,
) = ultrastar_score_calculator.calculate_score(processed_data.pitched_data, ultrastar_txt)
ultrastar_score_calculator.print_score_calculation(simple_score, accurate_score)
return ultrastar_txt, simple_score, accurate_score
def create_ultrastar_txt_from_ultrastar_data(
song_output: str,
title: str,
midi_segments: list[MidiSegment],
) -> str:
"""Create Ultrastar txt from Ultrastar data"""
output_repitched_ultrastar = os.path.join(
song_output, title + ".txt"
)
ultrastar_note_numbers = convert_midi_notes_to_ultrastar_notes(midi_segments)
ultrastar_writer.create_repitched_txt_from_ultrastar_data(
settings.input_file_path,
ultrastar_note_numbers,
output_repitched_ultrastar,
)
return output_repitched_ultrastar
def create_ultrastar_txt_from_automation(
basename: str,
song_output: str,
midi_segments: list[MidiSegment],
media_info: MediaInfo
):
"""Create Ultrastar txt from automation"""
print(f"{ULTRASINGER_HEAD} Using UltraStar {blue_highlighted(f'Format Version {settings.format_version}')}")
ultrastar_txt = UltrastarTxtValue()
ultrastar_txt.version = settings.format_version
ultrastar_txt.mp3 = basename + ".mp3"
ultrastar_txt.audio = basename + ".mp3"
ultrastar_txt.vocals = basename + " [Vocals].mp3"
ultrastar_txt.instrumental = basename + " [Instrumental].mp3"
ultrastar_txt.video = basename + ".mp4"
ultrastar_txt.language = media_info.language
cover = basename + " [CO].jpg"
ultrastar_txt.cover = (
cover if os_helper.check_file_exists(os.path.join(song_output, cover)) else None
)
ultrastar_txt.creator = f"{ultrastar_txt.creator} {Settings.APP_VERSION}"
ultrastar_txt.comment = f"{ultrastar_txt.comment} {Settings.APP_VERSION}"
# Additional data
ultrastar_txt.title = media_info.title
ultrastar_txt.artist = media_info.artist
if media_info.year is not None:
ultrastar_txt.year = extract_year(media_info.year)
if media_info.genre is not None:
ultrastar_txt.genre = format_separated_string(media_info.genre)
ultrastar_file_output = os.path.join(song_output, basename + ".txt")
ultrastar_writer.create_ultrastar_txt(
midi_segments,
ultrastar_file_output,
ultrastar_txt,
media_info.bpm,
)
if settings.create_karaoke and version.parse(settings.format_version) < version.parse("1.1.0"):
title = basename + " [Karaoke]"
ultrastar_txt.title = title
ultrastar_txt.mp3 = title + ".mp3"
karaoke_output_path = os.path.join(song_output, title)
karaoke_txt_output_path = karaoke_output_path + ".txt"
ultrastar_writer.create_ultrastar_txt(
midi_segments,
karaoke_txt_output_path,
ultrastar_txt,
media_info.bpm,
)
return ultrastar_file_output
# Todo: Isnt it MusicBrainz? + Sanitize when parsing UltraStar?
def extract_year(date: str) -> str:
match = re.search(r'\b\d{4}\b', date)
if match:
return match.group(0)
else:
return date
def infos_from_audio_input_file() -> tuple[str, str, str, MediaInfo]:
"""Infos from audio input file"""
basename = os.path.basename(settings.input_file_path)
@@ -514,58 +405,25 @@ def infos_from_audio_input_file() -> tuple[str, str, str, MediaInfo]:
extension = os.path.splitext(basename)[1]
basename = f"{basename_without_ext}{extension}"
song_output = os.path.join(settings.output_folder_path, basename_without_ext)
song_output = get_unused_song_output_dir(song_output)
os_helper.create_folder(song_output)
os_helper.copy(settings.input_file_path, song_output)
song_folder_output_path = os.path.join(settings.output_folder_path, basename_without_ext)
song_folder_output_path = get_unused_song_output_dir(song_folder_output_path)
os_helper.create_folder(song_folder_output_path)
os_helper.copy(settings.input_file_path, song_folder_output_path)
os_helper.rename(
os.path.join(song_output, os.path.basename(settings.input_file_path)),
os.path.join(song_output, basename),
os.path.join(song_folder_output_path, os.path.basename(settings.input_file_path)),
os.path.join(song_folder_output_path, basename),
)
# Todo: Read ID3 tags
ultrastar_audio_input_path = os.path.join(song_output, basename)
ultrastar_audio_input_path = os.path.join(song_folder_output_path, basename)
real_bpm = get_bpm_from_file(settings.input_file_path)
return (
basename_without_ext,
song_output,
song_folder_output_path,
ultrastar_audio_input_path,
MediaInfo(artist=artist, title=title, year=year_info, genre=genre_info, bpm=real_bpm),
)
def parse_ultrastar_txt() -> tuple[str, str, str, UltrastarTxtValue]:
"""Parse Ultrastar txt"""
ultrastar_class = ultrastar_parser.parse_ultrastar_txt(settings.input_file_path)
if ultrastar_class.mp3:
ultrastar_mp3_name = ultrastar_class.mp3
elif ultrastar_class.audio:
ultrastar_mp3_name = ultrastar_class.audio
else:
print(
f"{ULTRASINGER_HEAD} {red_highlighted('Error!')} The provided text file does not have a reference to "
f"an audio file."
)
exit(1)
dirname = os.path.dirname(settings.input_file_path)
song_output = os.path.join(
settings.output_folder_path,
ultrastar_class.artist.strip() + " - " + ultrastar_class.title.strip(),
)
song_output = get_unused_song_output_dir(str(song_output))
os_helper.create_folder(song_output)
basename_without_ext = f"{ultrastar_class.artist.strip()} - {ultrastar_class.title.strip()}"
audio_file_path = os.path.join(dirname, ultrastar_mp3_name)
return (
basename_without_ext,
song_output,
str(audio_file_path),
ultrastar_class,
)
def pitch_audio(
process_data_paths: ProcessDataPaths) -> PitchedData:
"""Pitch audio"""
@@ -607,7 +465,7 @@ def remove_cache_folder(cache_folder_path: str) -> None:
os_helper.remove_folder(cache_folder_path)
def init_settings(argv: list[str]) -> None:
def init_settings(argv: list[str]) -> Settings:
"""Init settings"""
long, short = arg_options()
opts, args = getopt.getopt(argv, short, long)
@@ -660,12 +518,17 @@ def init_settings(argv: list[str]) -> None:
elif opt in ("--force_crepe_cpu"):
settings.force_crepe_cpu = eval(arg.title())
elif opt in ("--format_version"):
if arg != '0.3.0' and arg != '1.0.0' and arg != '1.1.0':
if arg == FormatVersion.V0_3_0.value:
settings.format_version = FormatVersion.V0_3_0
elif arg == FormatVersion.V1_0_0.value:
settings.format_version = FormatVersion.V1_0_0
elif arg == FormatVersion.V1_1_0.value:
settings.format_version = FormatVersion.V1_1_0
else:
print(
f"{ULTRASINGER_HEAD} {red_highlighted('Error: Format version')} {blue_highlighted(arg)} {red_highlighted('is not supported.')}"
)
sys.exit(1)
settings.format_version = arg
elif opt in ("--keep_cache"):
settings.keep_cache = arg
elif opt in ("--musescore_path"):
+1 -1
View File
@@ -11,7 +11,7 @@ from modules.Speech_Recognition.TranscribedData import TranscribedData
from modules.console_colors import ULTRASINGER_HEAD
from modules.csv_handler import export_transcribed_data_to_csv
from modules.os_helper import create_folder
from modules.Ultrastar.ultrastar_converter import (
from modules.Ultrastar.coverter.ultrastar_converter import (
get_end_time_from_ultrastar,
get_start_time_from_ultrastar,
)
-41
View File
@@ -11,10 +11,6 @@ import unidecode
from modules.Midi.MidiSegment import MidiSegment
from modules.Speech_Recognition.TranscribedData import TranscribedData
from modules.Ultrastar.ultrastar_converter import (
midi_note_to_ultrastar_note,
ultrastar_note_to_midi_note
)
from modules.console_colors import (
ULTRASINGER_HEAD, blue_highlighted,
)
@@ -37,22 +33,6 @@ def create_midi_instrument(midi_segments: list[MidiSegment]) -> object:
return instrument
# Todo: delete?
def convert_ultrastar_to_midi_instrument(ultrastar_class: UltrastarTxtValue) -> object:
"""Converts an Ultrastar data to a midi instrument"""
print(f"{ULTRASINGER_HEAD} Creating midi instrument from Ultrastar txt")
instrument = pretty_midi.Instrument(program=0, name="Vocals")
velocity = 100
for i, note_line in enumerate(ultrastar_class.UltrastarNoteLines):
note = pretty_midi.Note(velocity, ultrastar_note_to_midi_note(note_line.pitch), note_line.startTime, note_line.endTime)
instrument.notes.append(note)
return instrument
def sanitize_for_midi(text):
"""
Sanitize text for MIDI compatibility.
@@ -143,27 +123,6 @@ def create_midi_note_from_pitched_data(start_time: float, end_time: float, pitch
return MidiSegment(note, start_time, end_time, word)
def convert_midi_notes_to_ultrastar_notes(midi_segments: list[MidiSegment]) -> list[int]:
"""Convert midi notes to ultrastar notes"""
print(f"{ULTRASINGER_HEAD} Creating Ultrastar notes from midi data")
ultrastar_note_numbers = []
for i, midi_segment in enumerate(midi_segments):
ultrastar_note = convert_midi_note_to_ultrastar_note(midi_segment)
ultrastar_note_numbers.append(ultrastar_note)
# todo: Progress?
# print(
# f"Note: {midi_notes[i]} midi_note: {str(note_number_librosa)} pitch: {str(pitch)}"
# )
return ultrastar_note_numbers
def convert_midi_note_to_ultrastar_note(midi_segment: MidiSegment) -> int:
"""Convert midi notes to ultrastar notes"""
note_number_librosa = librosa.note_to_midi(midi_segment.note)
ultrastar_note = midi_note_to_ultrastar_note(note_number_librosa)
return ultrastar_note
def create_midi_segments_from_transcribed_data(transcribed_data: list[TranscribedData], pitched_data: PitchedData) -> list[MidiSegment]:
start_times = []
-18
View File
@@ -2,7 +2,6 @@ from dataclasses import dataclass, field
from modules.Speech_Recognition.TranscribedData import TranscribedData
from modules.Pitcher.pitched_data import PitchedData
from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue
from modules.Ultrastar import ultrastar_converter
from modules.Midi.MidiSegment import MidiSegment
from typing import Optional, List
@@ -38,20 +37,3 @@ class ProcessData:
parsed_file: Optional[UltrastarTxtValue] = None
def from_ultrastar_txt(ultrastar_txt: UltrastarTxtValue) -> ProcessData:
"""Converts an Ultrastar txt to ProcessData"""
process_data = ProcessData()
process_data.parsed_file = ultrastar_txt
# todo: is this the real bpm? or calculate it from file?
real_bpm = ultrastar_converter.ultrastar_bpm_to_real_bpm(float(ultrastar_txt.bpm.replace(",", ".")))
process_data.media_info = MediaInfo(
title=ultrastar_txt.title,
artist=ultrastar_txt.artist,
year=ultrastar_txt.year,
genre=ultrastar_txt.genre,
language=ultrastar_txt.language,
bpm=real_bpm
)
process_data.midi_segments = ultrastar_converter.ultrastar_to_midi_segments(ultrastar_txt)
return process_data
@@ -1,7 +1,7 @@
"""Ultrastar Converter"""
import librosa
import re
from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue
from modules.Midi.MidiSegment import MidiSegment
def real_bpm_to_ultrastar_bpm(real_bpm: float) -> float:
@@ -100,17 +100,12 @@ def __convert_bpm(ultrastar_bpm: str) -> float:
return real_bpm
def ultrastar_to_midi_segments(ultrastar_txt: UltrastarTxtValue) -> list[MidiSegment]:
"""Converts an Ultrastar txt to Midi segments"""
midi_segments = []
for i, data in enumerate(ultrastar_txt.UltrastarNoteLines):
start_time = get_start_time_from_ultrastar(ultrastar_txt, i)
end_time = get_end_time_from_ultrastar(ultrastar_txt, i)
midi_segments.append(
MidiSegment(librosa.midi_to_note(ultrastar_note_to_midi_note(data.pitch)),
start_time,
end_time,
data.word,
)
)
return midi_segments
# Todo: Isnt it MusicBrainz? + Sanitize when parsing UltraStar?
def __extract_year(date: str) -> str:
match = re.search(r'\b\d{4}\b', date)
if match:
return match.group(0)
else:
return date
@@ -0,0 +1,63 @@
import librosa
import pretty_midi
from modules.Midi.MidiSegment import MidiSegment
from modules.Ultrastar.coverter.ultrastar_converter import midi_note_to_ultrastar_note, ultrastar_note_to_midi_note, \
get_start_time_from_ultrastar, get_end_time_from_ultrastar
from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue
from modules.console_colors import ULTRASINGER_HEAD
def convert_midi_note_to_ultrastar_note(midi_segment: MidiSegment) -> int:
"""Convert midi notes to ultrastar notes"""
note_number_librosa = librosa.note_to_midi(midi_segment.note)
ultrastar_note = midi_note_to_ultrastar_note(note_number_librosa)
return ultrastar_note
def convert_ultrastar_to_midi_instrument(ultrastar_class: UltrastarTxtValue) -> object:
"""Converts an Ultrastar data to a midi instrument"""
# Todo: delete?
print(f"{ULTRASINGER_HEAD} Creating midi instrument from Ultrastar txt")
instrument = pretty_midi.Instrument(program=0, name="Vocals")
velocity = 100
for i, note_line in enumerate(ultrastar_class.UltrastarNoteLines):
note = pretty_midi.Note(velocity, ultrastar_note_to_midi_note(note_line.pitch), note_line.startTime, note_line.endTime)
instrument.notes.append(note)
return instrument
def convert_midi_notes_to_ultrastar_notes(midi_segments: list[MidiSegment]) -> list[int]:
"""Convert midi notes to ultrastar notes"""
print(f"{ULTRASINGER_HEAD} Creating Ultrastar notes from midi data")
ultrastar_note_numbers = []
for i, midi_segment in enumerate(midi_segments):
ultrastar_note = convert_midi_note_to_ultrastar_note(midi_segment)
ultrastar_note_numbers.append(ultrastar_note)
# todo: Progress?
# print(
# f"Note: {midi_notes[i]} midi_note: {str(note_number_librosa)} pitch: {str(pitch)}"
# )
return ultrastar_note_numbers
def ultrastar_to_midi_segments(ultrastar_txt: UltrastarTxtValue) -> list[MidiSegment]:
"""Converts an Ultrastar txt to Midi segments"""
midi_segments = []
for i, data in enumerate(ultrastar_txt.UltrastarNoteLines):
start_time = get_start_time_from_ultrastar(ultrastar_txt, i)
end_time = get_end_time_from_ultrastar(ultrastar_txt, i)
midi_segments.append(
MidiSegment(librosa.midi_to_note(ultrastar_note_to_midi_note(data.pitch)),
start_time,
end_time,
data.word,
)
)
return midi_segments
@@ -0,0 +1,108 @@
import os
from packaging import version
from modules import os_helper
from modules.Midi.MidiSegment import MidiSegment
from modules.ProcessData import ProcessData, MediaInfo
from modules.Ultrastar.coverter.ultrastar_converter import ultrastar_bpm_to_real_bpm, __extract_year
from modules.Ultrastar.coverter.ultrastar_midi_converter import ultrastar_to_midi_segments, \
convert_midi_notes_to_ultrastar_notes
from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue, FormatVersion
from modules.Ultrastar.ultrastar_writer import create_repitched_txt_from_ultrastar_data, format_separated_string, \
create_ultrastar_txt
from modules.console_colors import ULTRASINGER_HEAD, blue_highlighted
def from_ultrastar_txt(ultrastar_txt: UltrastarTxtValue) -> ProcessData:
"""Converts an Ultrastar txt to ProcessData"""
process_data = ProcessData()
process_data.parsed_file = ultrastar_txt
# todo: is this the real bpm? or calculate it from file?
real_bpm = ultrastar_bpm_to_real_bpm(float(ultrastar_txt.bpm.replace(",", ".")))
process_data.media_info = MediaInfo(
title=ultrastar_txt.title,
artist=ultrastar_txt.artist,
year=ultrastar_txt.year,
genre=ultrastar_txt.genre,
language=ultrastar_txt.language,
bpm=real_bpm
)
process_data.midi_segments = ultrastar_to_midi_segments(ultrastar_txt)
return process_data
def create_ultrastar_txt_from_midi_segments(
song_folder_output_path: str,
input_file_path: str,
title: str,
midi_segments: list[MidiSegment],
) -> str:
"""Create Ultrastar txt from Ultrastar data"""
output_repitched_ultrastar = os.path.join(song_folder_output_path, title + ".txt")
ultrastar_note_numbers = convert_midi_notes_to_ultrastar_notes(midi_segments)
create_repitched_txt_from_ultrastar_data(
input_file_path,
ultrastar_note_numbers,
output_repitched_ultrastar,
)
return output_repitched_ultrastar
def create_ultrastar_txt_from_automation(
basename: str,
song_folder_output_path: str,
midi_segments: list[MidiSegment],
media_info: MediaInfo,
format_version: FormatVersion,
create_karaoke: bool,
app_version: str,
):
"""Create Ultrastar txt from automation"""
print(f"{ULTRASINGER_HEAD} Using UltraStar {blue_highlighted(f'Format Version {format_version.value}')}")
ultrastar_txt = UltrastarTxtValue()
ultrastar_txt.version = format_version.value
ultrastar_txt.mp3 = basename + ".mp3"
ultrastar_txt.audio = basename + ".mp3"
ultrastar_txt.vocals = basename + " [Vocals].mp3"
ultrastar_txt.instrumental = basename + " [Instrumental].mp3"
ultrastar_txt.video = basename + ".mp4"
ultrastar_txt.language = media_info.language
cover = basename + " [CO].jpg"
ultrastar_txt.cover = (
cover if os_helper.check_file_exists(os.path.join(song_folder_output_path, cover)) else None
)
ultrastar_txt.creator = f"{ultrastar_txt.creator} {app_version}"
ultrastar_txt.comment = f"{ultrastar_txt.comment} {app_version}"
# Additional data
ultrastar_txt.title = media_info.title
ultrastar_txt.artist = media_info.artist
if media_info.year is not None:
ultrastar_txt.year = __extract_year(media_info.year)
if media_info.genre is not None:
ultrastar_txt.genre = format_separated_string(media_info.genre)
ultrastar_file_output_path = os.path.join(song_folder_output_path, basename + ".txt")
create_ultrastar_txt(
midi_segments,
ultrastar_file_output_path,
ultrastar_txt,
media_info.bpm,
)
if create_karaoke and version.parse(format_version.value) < version.parse(FormatVersion.V1_1_0.value):
title = basename + " [Karaoke]"
ultrastar_txt.title = title
ultrastar_txt.mp3 = title + ".mp3"
karaoke_output_path = os.path.join(song_folder_output_path, title)
karaoke_txt_output_path = karaoke_output_path + ".txt"
create_ultrastar_txt(
midi_segments,
karaoke_txt_output_path,
ultrastar_txt,
media_info.bpm,
)
return ultrastar_file_output_path
+42 -3
View File
@@ -1,7 +1,10 @@
"""Ultrastar txt parser"""
import os
from modules.console_colors import ULTRASINGER_HEAD
from modules.Ultrastar.ultrastar_converter import (
from modules import os_helper
from modules.console_colors import ULTRASINGER_HEAD, red_highlighted
from modules.Ultrastar.coverter.ultrastar_converter import (
get_end_time,
get_start_time,
)
@@ -13,9 +16,10 @@ from modules.Ultrastar.ultrastar_txt import (
UltrastarNoteLine,
get_note_type_from_string
)
from modules.os_helper import get_unused_song_output_dir
def parse_ultrastar_txt(input_file: str) -> UltrastarTxtValue:
def parse(input_file: str) -> UltrastarTxtValue:
"""Parse ultrastar txt file to UltrastarTxt class"""
print(f"{ULTRASINGER_HEAD} Parse ultrastar txt -> {input_file}")
@@ -80,3 +84,38 @@ def parse_ultrastar_txt(input_file: str) -> UltrastarTxtValue:
# todo: Progress?
return ultrastar_class
def parse_ultrastar_txt(input_file_path: str, output_folder_path: str) -> tuple[str, str, str, UltrastarTxtValue]:
"""Parse Ultrastar txt"""
ultrastar_class = parse(input_file_path)
if ultrastar_class.mp3:
ultrastar_mp3_name = ultrastar_class.mp3
elif ultrastar_class.audio:
ultrastar_mp3_name = ultrastar_class.audio
else:
print(
f"{ULTRASINGER_HEAD} {red_highlighted('Error!')} The provided text file does not have a reference to "
f"an audio file."
)
exit(1)
song_output = os.path.join(
output_folder_path,
ultrastar_class.artist.strip() + " - " + ultrastar_class.title.strip(),
)
# todo: get_unused_song_output_dir should be in the runner
song_output = get_unused_song_output_dir(str(song_output))
os_helper.create_folder(song_output)
dirname = os.path.dirname(input_file_path)
audio_file_path = os.path.join(dirname, ultrastar_mp3_name)
basename_without_ext = f"{ultrastar_class.artist.strip()} - {ultrastar_class.title.strip()}"
return (
basename_without_ext,
song_output,
str(audio_file_path),
ultrastar_class,
)
@@ -5,6 +5,9 @@ from dataclasses_json import dataclass_json
import librosa
from modules.ProcessData import ProcessData
from modules.Ultrastar import ultrastar_parser
from modules.console_colors import (
ULTRASINGER_HEAD,
blue_highlighted,
@@ -14,7 +17,7 @@ from modules.console_colors import (
underlined,
)
from modules.Midi.midi_creator import create_midi_note_from_pitched_data
from modules.Ultrastar.ultrastar_converter import (
from modules.Ultrastar.coverter.ultrastar_converter import (
get_end_time_from_ultrastar,
get_start_time_from_ultrastar,
ultrastar_note_to_midi_note,
@@ -162,3 +165,31 @@ def print_score_calculation(simple_points: Score, accurate_points: Score) -> Non
f"{ULTRASINGER_HEAD} {underlined('Accurate (octave high matches)')} points:"
)
print_score(accurate_points)
def calculate_score_points_from_txt(pitched_data: PitchedData,
ultrastar_txt: UltrastarTxtValue) -> tuple[Score, Score]:
(
simple_score,
accurate_score,
) = calculate_score(pitched_data, ultrastar_txt)
print_score_calculation(simple_score, accurate_score)
return simple_score, accurate_score
def calculate_score_points(
processed_data: ProcessData,
ultrastar_file_output_path: str,
ignore_audio: bool = False,
) -> tuple[Score, Score]:
"""Calculate score points"""
if not ignore_audio:
ultrastar_txt = ultrastar_parser.parse(ultrastar_file_output_path)
(simple_score, accurate_score) = calculate_score_points_from_txt(processed_data.pitched_data, ultrastar_txt)
else:
print(f"{ULTRASINGER_HEAD} {blue_highlighted('Score of original Ultrastar txt')}")
(_, _) = calculate_score_points_from_txt(processed_data.pitched_data, processed_data.parsed_file)
print(f"{ULTRASINGER_HEAD} {blue_highlighted('Score of re-pitched Ultrastar txt')}")
ultrastar_txt = ultrastar_parser.parse(ultrastar_file_output_path)
(simple_score, accurate_score) = calculate_score_points_from_txt(processed_data.pitched_data, ultrastar_txt)
return simple_score, accurate_score
+9
View File
@@ -125,3 +125,12 @@ class UltrastarTxtValue:
creator = "UltraSinger [GitHub]"
comment = "UltraSinger [GitHub]"
UltrastarNoteLines: List[UltrastarNoteLine] = field(default_factory=list)
class FormatVersion(Enum):
V0_2_0 = "0.2.0"
V0_3_0 = "0.3.0"
V1_0_0 = "1.0.0"
V1_1_0 = "1.1.0"
V1_2_0 = "1.2.0" # Not released yet
V2_0_0 = "2.0.0" # Not released yet
+3 -4
View File
@@ -5,15 +5,14 @@ import langcodes
from packaging import version
from modules.console_colors import ULTRASINGER_HEAD
from modules.Ultrastar.ultrastar_converter import (
from modules.Ultrastar.coverter.ultrastar_converter import (
real_bpm_to_ultrastar_bpm,
second_to_beat,
)
second_to_beat, )
from modules.Ultrastar.coverter.ultrastar_midi_converter import convert_midi_note_to_ultrastar_note
from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue, UltrastarTxtTag, UltrastarTxtNoteTypeTag, \
FILE_ENCODING
from modules.Ultrastar.ultrastar_score_calculator import Score
from modules.Midi.MidiSegment import MidiSegment
from modules.Midi.midi_creator import convert_midi_note_to_ultrastar_note
def get_thirtytwo_note_second(real_bpm: float):