Upload 4 files

src/modules/Ultrastar/ultrastar_parser.py

@@ -0,0 +1,67 @@
+"""Ultrastar txt parser"""
+
+from modules.console_colors import ULTRASINGER_HEAD
+from modules.Ultrastar.ultrastar_converter import (
+    get_end_time_from_ultrastar,
+    get_start_time_from_ultrastar,
+)
+from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue, UltrastarTxtTag, UltrastarTxtNoteTypeTag, FILE_ENCODING
+
+def parse_ultrastar_txt(input_file: str) -> UltrastarTxtValue:
+    """Parse ultrastar txt file to UltrastarTxt class"""
+    print(f"{ULTRASINGER_HEAD} Parse ultrastar txt -> {input_file}")
+
+    with open(input_file, "r", encoding=FILE_ENCODING) as file:
+        txt = file.readlines()
+
+    ultrastar_class = UltrastarTxtValue()
+    count = 0
+
+    # Strips the newline character
+    for line in txt:
+        count += 1
+        if line.startswith("#"):
+            if line.startswith(f"#{UltrastarTxtTag.ARTIST}"):
+                ultrastar_class.artist = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.TITLE}"):
+                ultrastar_class.title = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.MP3}"):
+                ultrastar_class.mp3 = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.AUDIO}"):
+                ultrastar_class.audio = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.VIDEO}"):
+                ultrastar_class.video = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.GAP}"):
+                ultrastar_class.gap = line.split(":")[1].replace("\n", "")
+            elif line.startswith(f"#{UltrastarTxtTag.BPM}"):
+                ultrastar_class.bpm = line.split(":")[1].replace("\n", "")
+        elif line.startswith((
+                f"{UltrastarTxtNoteTypeTag.FREESTYLE} ",
+                f"{UltrastarTxtNoteTypeTag.NORMAL} ",
+                f"{UltrastarTxtNoteTypeTag.GOLDEN} ",
+                f"{UltrastarTxtNoteTypeTag.RAP} ",
+                f"{UltrastarTxtNoteTypeTag.RAP_GOLDEN} ")):
+            parts = line.split()
+            # [0] F : * R G
+            # [1] start beat
+            # [2] duration
+            # [3] pitch
+            # [4] word
+
+            ultrastar_class.noteType.append(parts[0])
+            ultrastar_class.startBeat.append(parts[1])
+            ultrastar_class.durations.append(parts[2])
+            ultrastar_class.pitches.append(parts[3])
+            ultrastar_class.words.append(parts[4] if len(parts) > 4 else "")
+
+            # do always as last
+            pos = len(ultrastar_class.startBeat) - 1
+            ultrastar_class.startTimes.append(
+                get_start_time_from_ultrastar(ultrastar_class, pos)
+            )
+            ultrastar_class.endTimes.append(
+                get_end_time_from_ultrastar(ultrastar_class, pos)
+            )
+            # todo: Progress?
+
+    return ultrastar_class

src/modules/Ultrastar/ultrastar_score_calculator.py

@@ -0,0 +1,168 @@
+"""Ultrastar score calculator."""
+
+import librosa
+
+from modules.console_colors import (
+    ULTRASINGER_HEAD,
+    blue_highlighted,
+    cyan_highlighted,
+    gold_highlighted,
+    light_blue_highlighted,
+    underlined,
+)
+from modules.Midi.midi_creator import create_midi_note_from_pitched_data
+from modules.Ultrastar.ultrastar_converter import (
+    get_end_time_from_ultrastar,
+    get_start_time_from_ultrastar,
+    ultrastar_note_to_midi_note,
+)
+from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue
+from modules.Pitcher.pitched_data import PitchedData
+
+MAX_SONG_SCORE = 10000
+MAX_SONG_LINE_BONUS = 1000
+
+
+class Points:
+    """Docstring"""
+
+    notes = 0
+    golden_notes = 0
+    rap = 0
+    golden_rap = 0
+    line_bonus = 0
+    parts = 0
+
+
+def add_point(note_type: str, points: Points) -> Points:
+    """Add calculated points to the points object."""
+
+    if note_type == ":":
+        points.notes += 1
+    elif note_type == "*":
+        points.golden_notes += 2
+    elif note_type == "R":
+        points.rap += 1
+    elif note_type == "G":
+        points.golden_rap += 2
+    return points
+
+
+class Score:
+    """Docstring"""
+
+    max_score = 0
+    notes = 0
+    golden = 0
+    line_bonus = 0
+    score = 0
+
+
+def get_score(points: Points) -> Score:
+    """Score calculation."""
+
+    score = Score()
+    score.max_score = (
+        MAX_SONG_SCORE
+        if points.line_bonus == 0
+        else MAX_SONG_SCORE - MAX_SONG_LINE_BONUS
+    )
+    score.notes = round(
+        score.max_score * (points.notes + points.rap) / points.parts
+    )
+    score.golden = round(points.golden_notes + points.golden_rap)
+    score.score = round(score.notes + points.line_bonus + score.golden)
+    score.line_bonus = round(points.line_bonus)
+    return score
+
+
+def print_score(score: Score) -> None:
+    """Print score."""
+
+    print(
+        f"{ULTRASINGER_HEAD} Total: {cyan_highlighted(str(score.score))}, notes: {blue_highlighted(str(score.notes))}, line bonus: {light_blue_highlighted(str(score.line_bonus))}, golden notes: {gold_highlighted(str(score.golden))}"
+    )
+
+
+def calculate_score(pitched_data: PitchedData, ultrastar_class: UltrastarTxtValue) -> (Score, Score):
+    """Calculate score."""
+
+    print(ULTRASINGER_HEAD + " Calculating Ultrastar Points")
+
+    simple_points = Points()
+    accurate_points = Points()
+
+    reachable_line_bonus_per_word = MAX_SONG_LINE_BONUS / len(
+        ultrastar_class.words
+    )
+
+    for i in enumerate(ultrastar_class.words):
+        pos = i[0]
+        if ultrastar_class.words == "":
+            continue
+
+        if ultrastar_class.noteType[pos] == "F":
+            continue
+
+        start_time = get_start_time_from_ultrastar(ultrastar_class, pos)
+        end_time = get_end_time_from_ultrastar(ultrastar_class, pos)
+        duration = end_time - start_time
+        step_size = 0.09  # Todo: Whats is the step size of the game? Its not 1/bps -> one beat in seconds s = 60/bpm
+        parts = int(duration / step_size)
+        parts = 1 if parts == 0 else parts
+
+        accurate_part_line_bonus_points = 0
+        simple_part_line_bonus_points = 0
+
+        ultrastar_midi_note = ultrastar_note_to_midi_note(
+            int(ultrastar_class.pitches[pos])
+        )
+        ultrastar_note = librosa.midi_to_note(ultrastar_midi_note)
+
+        for part in range(parts):
+            start = start_time + step_size * part
+            end = start + step_size
+            if end_time < end or part == parts - 1:
+                end = end_time
+            pitch_note = create_midi_note_from_pitched_data(
+                start, end, pitched_data
+            )
+
+            if pitch_note[:-1] == ultrastar_note[:-1]:
+                # Ignore octave high
+                simple_points = add_point(
+                    ultrastar_class.noteType[pos], simple_points
+                )
+                simple_part_line_bonus_points += 1
+
+            if pitch_note == ultrastar_note:
+                # Octave high must be the same
+                accurate_points = add_point(
+                    ultrastar_class.noteType[pos], accurate_points
+                )
+                accurate_part_line_bonus_points += 1
+
+            accurate_points.parts += 1
+            simple_points.parts += 1
+
+        if accurate_part_line_bonus_points >= parts:
+            accurate_points.line_bonus += reachable_line_bonus_per_word
+
+        if simple_part_line_bonus_points >= parts:
+            simple_points.line_bonus += reachable_line_bonus_per_word
+
+    return get_score(simple_points), get_score(accurate_points)
+
+
+def print_score_calculation(simple_points: Score, accurate_points: Score) -> None:
+    """Print score calculation."""
+
+    print(
+        f"{ULTRASINGER_HEAD} {underlined('Simple (octave high ignored)')} points"
+    )
+    print_score(simple_points)
+
+    print(
+        f"{ULTRASINGER_HEAD} {underlined('Accurate (octave high matches)')} points:"
+    )
+    print_score(accurate_points)

src/modules/Ultrastar/ultrastar_txt.py

@@ -0,0 +1,102 @@
+"""Ultrastar TXT"""
+
+from enum import Enum
+
+FILE_ENCODING = "utf-8"
+
+
+class UltrastarTxtTag(str, Enum):
+    """Tags for Ultrastar TXT files."""
+
+    # 0.2.0
+    VERSION = 'VERSION'  # Version of the file format: See https://usdx.eu/format/
+    ARTIST = 'ARTIST'
+    TITLE = 'TITLE'
+    MP3 = 'MP3'  # Removed in v2.0.0
+    GAP = 'GAP'
+    BPM = 'BPM'
+    LANGUAGE = 'LANGUAGE'  # Multi-language support since v1.1.0
+    GENRE = 'GENRE'  # Multi-language support since v1.1.0
+    YEAR = 'YEAR'  # Multi-language support since v1.1.0
+    COVER = 'COVER'  # Path to cover. Should end with `*[CO].jpg`
+    CREATOR = 'CREATOR'  # Multi-language support since v1.1.0
+    COMMENT = 'COMMENT'
+    VIDEO = 'VIDEO'
+    FILE_END = 'E'
+    LINEBREAK = '-'
+
+    # 1.1.0
+    AUDIO = 'AUDIO'  # Its instead of MP3. Just renamed
+    VOCALS = 'VOCALS'  # Vocals only audio
+    INSTRUMENTAL = 'INSTRUMENTAL'  # Instrumental only audio
+    TAGS = 'TAGS'  # Tags for the song. Can be used for filtering
+
+    # Unused 0.2.0
+    BACKGROUND = 'BACKGROUND'  # Path to background. Is shown when there is no video. Should end with `*[BG].jpg`
+    VIDEOGAP = 'VIDEOGAP'
+    EDITION = 'EDITION'  # Multi-language support since v1.1.0
+    START = 'START'
+    END = 'END'
+    PREVIEWSTART = 'PREVIEWSTART'
+    MEDLEYSTARTBEAT = 'MEDLEYSTARTBEAT'  # Removed in 2.0.0
+    MEDLEYENDBEAT = 'MEDLEYENDBEAT'  # Removed in v2.0.0
+    CALCMEDLEY = 'CALCMEDLEY'
+    P1 = 'P1'  # Only for UltraStar Deluxe
+    P2 = 'P2'  # Only for UltraStar Deluxe
+    DUETSINGERP1 = 'DUETSINGERP1'  # Removed in 1.0.0 (Used by UltraStar WorldParty)
+    DUETSINGERP2 = 'DUETSINGERP2'  # Removed in 1.0.0 (Used by UltraStar WorldParty)
+    RESOLUTION = 'RESOLUTION'  # Changes the grid resolution of the editor. Only for the editor and nothing for singing. # Removed in 1.0.0
+    NOTESGAP = 'NOTESGAP'  # Removed in 1.0.0
+    RELATIVE = 'RELATIVE'  # Removed in 1.0.0
+    ENCODING = 'ENCODING'  # Removed in 1.0.0
+
+    # (Unused) 1.1.0
+    PROVIDEDBY = 'PROVIDEDBY'  # Should the URL from hoster server
+
+    # (Unused) New in (unreleased) 1.2.0
+    AUDIOURL = 'AUDIOURL'  # URL to the audio file
+    COVERURL = 'COVERURL'  # URL to the cover file
+    BACKGROUNDURL = 'BACKGROUNDURL'  # URL to the background file
+    VIDEOURL = 'VIDEOURL'  # URL to the video file
+
+    # (Unused) New in (unreleased) 2.0.0
+    MEDLEYSTART = 'MEDLEYSTART'  # Rename of MEDLEYSTARTBEAT
+    MEDLEYEND = 'MEDLEYEND'  # Renmame of MEDLEYENDBEAT
+
+
+class UltrastarTxtNoteTypeTag(str, Enum):
+    """Note types for Ultrastar TXT files."""
+    NORMAL = ':'
+    RAP = 'R'
+    RAP_GOLDEN = 'G'
+    FREESTYLE = 'F'
+    GOLDEN = '*'
+
+
+class UltrastarTxtValue:
+    """Vaules for Ultrastar TXT files."""
+
+    version = "1.0.0"
+    artist = ""
+    title = ""
+    year = None
+    genre = ""
+    mp3 = ""
+    audio = ""
+    video = None
+    gap = ""
+    bpm = ""
+    language = None
+    cover = None
+    vocals = None
+    instrumental = None
+    tags = None
+    creator = "UltraSinger [GitHub]"
+    comment = "UltraSinger [GitHub]"
+    startBeat = []
+    startTimes = []
+    endTimes = []
+    durations = []
+    pitches = []
+    words = []
+    noteType = []  # F, R, G, *, :

src/modules/Ultrastar/ultrastar_writer.py

@@ -0,0 +1,268 @@
+"""Ultrastar writer module"""
+
+import re
+import langcodes
+from packaging import version
+
+from modules.console_colors import ULTRASINGER_HEAD
+from modules.Ultrastar.ultrastar_converter import (
+    real_bpm_to_ultrastar_bpm,
+    second_to_beat,
+    beat_to_second,
+)
+from modules.Ultrastar.ultrastar_txt import UltrastarTxtValue, UltrastarTxtTag, UltrastarTxtNoteTypeTag, \
+    FILE_ENCODING
+from modules.Speech_Recognition.TranscribedData import TranscribedData
+from modules.Ultrastar.ultrastar_score_calculator import Score
+
+
+def get_thirtytwo_note_second(real_bpm: float):
+    """Converts a beat to a 1/32 note in second"""
+    return 60 / real_bpm / 8
+
+
+def get_sixteenth_note_second(real_bpm: float):
+    """Converts a beat to a 1/16 note in second"""
+    return 60 / real_bpm / 4
+
+
+def get_eighth_note_second(real_bpm: float):
+    """Converts a beat to a 1/8 note in second"""
+    return 60 / real_bpm / 2
+
+
+def get_quarter_note_second(real_bpm: float):
+    """Converts a beat to a 1/4 note in second"""
+    return 60 / real_bpm
+
+
+def get_half_note_second(real_bpm: float):
+    """Converts a beat to a 1/2 note in second"""
+    return 60 / real_bpm * 2
+
+
+def get_whole_note_second(real_bpm: float):
+    """Converts a beat to a 1/1 note in second"""
+    return 60 / real_bpm * 4
+
+
+def get_multiplier(real_bpm: float) -> int:
+    """Calculates the multiplier for the BPM"""
+
+    if real_bpm == 0:
+        raise Exception("BPM is 0")
+
+    multiplier = 1
+    result = 0
+    while result < 400:
+        result = real_bpm * multiplier
+        multiplier += 1
+    return multiplier - 2
+
+
+def get_language_name(language: str) -> str:
+    """Creates the language name from the language code"""
+
+    return langcodes.Language.make(language=language).display_name()
+
+
+def create_ultrastar_txt_from_automation(
+        transcribed_data: list[TranscribedData],
+        note_numbers: list[int],
+        ultrastar_file_output: str,
+        ultrastar_class: UltrastarTxtValue,
+        real_bpm=120,
+) -> None:
+    """Creates an Ultrastar txt file from the automation data"""
+
+    print(
+        f"{ULTRASINGER_HEAD} Creating {ultrastar_file_output} from transcription."
+    )
+
+    ultrastar_bpm = real_bpm_to_ultrastar_bpm(real_bpm)
+    multiplication = get_multiplier(ultrastar_bpm)
+    ultrastar_bpm = ultrastar_bpm * get_multiplier(ultrastar_bpm)
+    silence_split_duration = calculate_silent_beat_length(transcribed_data)
+
+    with open(ultrastar_file_output, "w", encoding=FILE_ENCODING) as file:
+        gap = transcribed_data[0].start
+
+        if version.parse(ultrastar_class.version) >= version.parse("1.0.0"):
+            file.write(f"#{UltrastarTxtTag.VERSION}:{ultrastar_class.version}\n"),
+        file.write(f"#{UltrastarTxtTag.ARTIST}:{ultrastar_class.artist}\n")
+        file.write(f"#{UltrastarTxtTag.TITLE}:{ultrastar_class.title}\n")
+        if ultrastar_class.year is not None:
+            file.write(f"#{UltrastarTxtTag.YEAR}:{ultrastar_class.year}\n")
+        if ultrastar_class.language is not None:
+            file.write(f"#{UltrastarTxtTag.LANGUAGE}:{get_language_name(ultrastar_class.language)}\n")
+        if ultrastar_class.genre:
+            file.write(f"#{UltrastarTxtTag.GENRE}:{ultrastar_class.genre}\n")
+        if ultrastar_class.cover is not None:
+            file.write(f"#{UltrastarTxtTag.COVER}:{ultrastar_class.cover}\n")
+        file.write(f"#{UltrastarTxtTag.MP3}:{ultrastar_class.mp3}\n")
+        if version.parse(ultrastar_class.version) >= version.parse("1.1.0"):
+            file.write(f"#{UltrastarTxtTag.AUDIO}:{ultrastar_class.audio}\n")
+            if ultrastar_class.vocals is not None:
+                file.write(f"#{UltrastarTxtTag.VOCALS}:{ultrastar_class.vocals}\n")
+            if ultrastar_class.instrumental is not None:
+                file.write(f"#{UltrastarTxtTag.INSTRUMENTAL}:{ultrastar_class.instrumental}\n")
+            if ultrastar_class.tags is not None:
+                file.write(f"#{UltrastarTxtTag.TAGS}:{ultrastar_class.tags}\n")
+        file.write(f"#{UltrastarTxtTag.VIDEO}:{ultrastar_class.video}\n")
+        file.write(f"#{UltrastarTxtTag.BPM}:{round(ultrastar_bpm, 2)}\n")  # not the real BPM!
+        file.write(f"#{UltrastarTxtTag.GAP}:{int(gap * 1000)}\n")
+        file.write(f"#{UltrastarTxtTag.CREATOR}:{ultrastar_class.creator}\n")
+        file.write(f"#{UltrastarTxtTag.COMMENT}:{ultrastar_class.comment}\n")
+
+        # Write the singing part
+        previous_end_beat = 0
+        separated_word_silence = []  # This is a workaround for separated words that get his ends to far away
+
+        for i, data in enumerate(transcribed_data):
+            start_time = (data.start - gap) * multiplication
+            end_time = (
+                               data.end - data.start
+                       ) * multiplication
+            start_beat = round(second_to_beat(start_time, real_bpm))
+            duration = round(second_to_beat(end_time, real_bpm))
+
+            # Fix the round issue, so the beats don’t overlap
+            start_beat = max(start_beat, previous_end_beat)
+            previous_end_beat = start_beat + duration
+
+            # Calculate the silence between the words
+            if i < len(transcribed_data) - 1:
+                silence = (transcribed_data[i + 1].start - data.end)
+            else:
+                silence = 0
+
+            # : 10 10 10 w
+            # ':'   start midi part
+            # 'n1'  start at real beat
+            # 'n2'  duration at real beat
+            # 'n3'  pitch where 0 == C4
+            # 'w'   lyric
+            line = f"{UltrastarTxtNoteTypeTag.NORMAL} " \
+                   f"{str(start_beat)} " \
+                   f"{str(duration)} " \
+                   f"{str(note_numbers[i])} " \
+                   f"{data.word}\n"
+
+            file.write(line)
+
+            # detect silence between words
+            if not transcribed_data[i].is_word_end:
+                separated_word_silence.append(silence)
+                continue
+
+            if silence_split_duration != 0 and silence > silence_split_duration or any(
+                    s > silence_split_duration for s in separated_word_silence) and i != len(transcribed_data) - 1:
+                # - 10
+                # '-' end of current sing part
+                # 'n1' show next at time in real beat
+                show_next = (
+                        second_to_beat(data.end - gap, real_bpm)
+                        * multiplication
+                )
+                linebreak = f"{UltrastarTxtTag.LINEBREAK} " \
+                            f"{str(round(show_next))}\n"
+                file.write(linebreak)
+            separated_word_silence = []
+        file.write(f"{UltrastarTxtTag.FILE_END}")
+
+
+def deviation(silence_parts):
+    """Calculates the deviation of the silence parts"""
+
+    if len(silence_parts) < 5:
+        return 0
+
+    # Remove the longest part so the deviation is not that high
+    sorted_parts = sorted(silence_parts)
+    filtered_parts = [part for part in sorted_parts if part < sorted_parts[-1]]
+
+    sum_parts = sum(filtered_parts)
+    if sum_parts == 0:
+        return 0
+
+    mean = sum_parts / len(filtered_parts)
+    return mean
+
+
+def calculate_silent_beat_length(transcribed_data: list[TranscribedData]):
+    print(f"{ULTRASINGER_HEAD} Calculating silence parts for linebreaks.")
+
+    silent_parts = []
+    for i, data in enumerate(transcribed_data):
+        if i < len(transcribed_data) - 1:
+            silent_parts.append(transcribed_data[i + 1].start - data.end)
+
+    return deviation(silent_parts)
+
+
+def create_repitched_txt_from_ultrastar_data(
+        input_file: str, note_numbers: list[int], output_repitched_ultrastar: str
+) -> None:
+    """Creates a repitched ultrastar txt file from the original one"""
+    # todo: just add '_repitched' to input_file
+    print(
+        "{PRINT_ULTRASTAR} Creating repitched ultrastar txt -> {input_file}_repitch.txt"
+    )
+
+    # todo: to reader
+    with open(input_file, "r", encoding=FILE_ENCODING) as file:
+        txt = file.readlines()
+
+    i = 0
+    # todo: just add '_repitched' to input_file
+    with open(output_repitched_ultrastar, "w", encoding=FILE_ENCODING) as file:
+        for line in txt:
+            if line.startswith(f"{UltrastarTxtNoteTypeTag.NORMAL} "):
+                parts = re.findall(r"\S+|\s+", line)
+                # between are whitespaces
+                # [0] :
+                # [2] start beat
+                # [4] duration
+                # [6] pitch
+                # [8] word
+                parts[6] = str(note_numbers[i])
+                delimiter = ""
+                file.write(delimiter.join(parts))
+                i += 1
+            else:
+                file.write(line)
+
+
+def add_score_to_ultrastar_txt(ultrastar_file_output: str, score: Score) -> None:
+    """Adds the score to the ultrastar txt file"""
+    with open(ultrastar_file_output, "r", encoding=FILE_ENCODING) as file:
+        text = file.read()
+    text = text.split("\n")
+
+    for i, line in enumerate(text):
+        if line.startswith(f"#{UltrastarTxtTag.COMMENT}:"):
+            text[
+                i
+            ] = f"{line} | Score: total: {score.score}, notes: {score.notes} line: {score.line_bonus}, golden: {score.golden}"
+            break
+
+        if line.startswith((
+                f"{UltrastarTxtNoteTypeTag.FREESTYLE} ",
+                f"{UltrastarTxtNoteTypeTag.NORMAL} ",
+                f"{UltrastarTxtNoteTypeTag.GOLDEN} ",
+                f"{UltrastarTxtNoteTypeTag.RAP} ",
+                f"{UltrastarTxtNoteTypeTag.RAP_GOLDEN} ")):
+            text.insert(
+                i,
+                f"#{UltrastarTxtTag.COMMENT}: UltraSinger [GitHub] | Score: total: {score.score}, notes: {score.notes} line: {score.line_bonus}, golden: {score.golden}",
+            )
+            break
+
+    text = "\n".join(text)
+
+    with open(ultrastar_file_output, "w", encoding=FILE_ENCODING) as file:
+        file.write(text)
+
+
+class UltraStarWriter:
+    """Docstring"""