diff --git a/docs/architecture.md b/docs/architecture.md index e66ee22..b20f591 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -400,7 +400,10 @@ Fahrtrichtung. einen `AudioStreamPlayer` auf derselben Zeitbasis. `AudioFile` erkennt MP3/OGG/WAV an den echten Dateibytes; M4A/AAC und falsch als `.mp3` benannte ISO-Container werden auf macOS mit `afconvert` zu mono - PCM-WAV (44,1 kHz) konvertiert. Start, + PCM-WAV (44,1 kHz) konvertiert. Beim Kopieren in den Kür-Ordner wird der + Inhalt verglichen: identische Tracks werden wiederverwendet (auch die + bereits referenzierte Datei der Kür bleibt erhalten), nur bei + abweichendem Inhalt gleichen Namens entsteht ein nummerierter Name. Start, Pause, Reset, Scrubbing und Geschwindigkeit wirken auf Bild und Ton. Über der Timeline liegt eine Label-Spur: Labels von Segmenten und Kürzel von Elementen ohne Freitext erscheinen schräg an ihrem Startzeitpunkt (auch diff --git a/docs/findings-2026-11-10-mac-music.md b/docs/findings-2026-11-10-mac-music.md index de6fa7e..4198255 100644 --- a/docs/findings-2026-11-10-mac-music.md +++ b/docs/findings-2026-11-10-mac-music.md @@ -57,3 +57,23 @@ Neue `tests/run_audio_tests.gd`: - Die konvertierte WAV-Datei ist deutlich größer als das M4A-Original (mono 44,1 kHz, ca. 5 MB pro Minute), bleibt aber unter dem 64-MB-Limit für übliche Kür-Musik. + +## Nachtrag: keine nummerierten Musik-Duplikate + +Jedes erneute Laden desselben Stücks legte bisher eine neue Kopie an +(`… 2.mp3`, `… 3.mp3`, …), weil der Zielname nur auf Existenz geprüft wurde. + +- `_resolve_music_copy_name()` vergleicht jetzt Größe und SHA-256 des + vorhandenen Ziels mit der Quelle. +- Identischer Inhalt → die vorhandene Datei wird weiterverwendet + (`needs_copy = false`). Das gilt auch für die Datei, die die aktuelle Kür + bereits referenziert, sodass ein erneutes Laden den Namen gar nicht ändert. +- Nur bei gleichem Namen und abweichendem Inhalt entsteht weiterhin ein + nummerierter Name. +- M4A/AAC wird zuerst in eine Scratch-Datei (`user://_music_import_*.wav`) + konvertiert und danach inhaltsbasiert einsortiert; die Scratch-Datei wird + immer entfernt. + +Tests in `run_playback_tests.gd`: zweimal dasselbe Stück laden behält den +Namen und erzeugt kein `… 2.wav`; ein anderes Stück gleichen Namens bekommt +eine Nummer, die beim erneuten Laden stabil bleibt. diff --git a/docs/manual.md b/docs/manual.md index 281f1eb..c70ced5 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -159,6 +159,10 @@ Dateiname vermerkt. (und tiefer), bei 2× schneller. - **×** entfernt die Musik aus der Kür, löscht die Datei aber nicht. So bleibt sie für andere Kürdateien erhalten. +- Dasselbe Stück kann beliebig oft geladen werden: Ist der Inhalt schon im + Kür-Ordner vorhanden, wird die vorhandene Datei weiterverwendet. Eine + Nummer im Namen (`… 2.mp3`) entsteht nur bei echt unterschiedlichem Inhalt + gleichen Namens. - Beim **Sync** wird die Musikdatei wie die Kür-JSON hoch- und heruntergeladen. Fehlt sie auf einem Gerät, zeigt die Leiste „(fehlt)“; nach dem nächsten Sync ist sie verfügbar. diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 75b8886..b57ac4f 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -4425,15 +4425,19 @@ func load_music_from_path(path: String) -> bool: var routines_absolute := ProjectSettings.globalize_path(ROUTINES_DIR) if absolute_source.get_base_dir() != routines_absolute: - file_name = _unique_music_file_name(file_name) - var target := ProjectSettings.globalize_path(ROUTINES_DIR.path_join(file_name)) - var copy_error := DirAccess.copy_absolute(absolute_source, target) - if copy_error != OK: - _show_message( - "Die Musikdatei konnte nicht kopiert werden (Fehler %d)." - % copy_error + var resolved := _resolve_music_copy_name(absolute_source, file_name) + file_name = resolved.name + if resolved.needs_copy: + var target := ProjectSettings.globalize_path( + ROUTINES_DIR.path_join(file_name) ) - return false + var copy_error := DirAccess.copy_absolute(absolute_source, target) + if copy_error != OK: + _show_message( + "Die Musikdatei konnte nicht kopiert werden (Fehler %d)." + % copy_error + ) + return false return _set_music_file(file_name) @@ -4456,30 +4460,52 @@ func _import_converted_music( if converted_name.is_empty(): _show_message("Der Dateiname der Musikdatei ist ungültig.") return false - converted_name = _unique_music_file_name(converted_name) + _ensure_routines_dir() - var target := ProjectSettings.globalize_path( - ROUTINES_DIR.path_join(converted_name) - ) + # Convert into a scratch file first so an already converted copy can be + # reused by content instead of piling up numbered duplicates. + var scratch_name := "user://_music_import_%d.wav" % Time.get_ticks_usec() + var scratch_path := ProjectSettings.globalize_path(scratch_name) var exit_code := AudioFile.convert_iso_media_to_wav( absolute_source, - target + scratch_path ) - if exit_code != 0 or not FileAccess.file_exists(target): + if exit_code != 0 or not FileAccess.file_exists(scratch_path): + if FileAccess.file_exists(scratch_path): + DirAccess.remove_absolute(scratch_path) _show_message( "Die Musikdatei konnte nicht konvertiert werden (Fehler %d)." % exit_code ) return false - var converted_size := _file_size(target) + var converted_size := _file_size(scratch_path) if converted_size <= 0 or converted_size > MAX_MUSIC_FILE_BYTES: - DirAccess.remove_absolute(target) + DirAccess.remove_absolute(scratch_path) _show_message( "Die konvertierte Musikdatei ist leer oder zu groß (max. 64 MB)." ) return false + var resolved := _resolve_music_copy_name(scratch_path, converted_name) + converted_name = resolved.name + if resolved.needs_copy: + var target := ProjectSettings.globalize_path( + ROUTINES_DIR.path_join(converted_name) + ) + var move_error := DirAccess.rename_absolute(scratch_path, target) + if move_error != OK: + move_error = DirAccess.copy_absolute(scratch_path, target) + DirAccess.remove_absolute(scratch_path) + if move_error != OK: + _show_message( + "Die Musikdatei konnte nicht gespeichert werden (Fehler %d)." + % move_error + ) + return false + else: + DirAccess.remove_absolute(scratch_path) + return _set_music_file(converted_name) @@ -4519,18 +4545,50 @@ func _clear_music() -> void: _update_music_ui() -func _unique_music_file_name(file_name: String) -> String: - if not FileAccess.file_exists(ROUTINES_DIR.path_join(file_name)): - return file_name +## Picks the file name a new music copy is stored under. A file that already +## exists with identical content is reused instead of creating a numbered +## duplicate, so loading the same track twice stays idempotent. +func _resolve_music_copy_name( + absolute_source: String, + file_name: String +) -> Dictionary: + # Keep the attachment this routine already references when it holds the + # same audio, so reloading a track does not even rename it. + var current := _routine.music_file if _routine != null else "" + if not current.is_empty(): + var current_path := ROUTINES_DIR.path_join(current) + if ( + current != file_name + and FileAccess.file_exists(current_path) + and _same_file_content(absolute_source, current_path) + ): + return {"name": current, "needs_copy": false} + + var target_path := ROUTINES_DIR.path_join(file_name) + if not FileAccess.file_exists(target_path): + return {"name": file_name, "needs_copy": true} + if _same_file_content(absolute_source, target_path): + return {"name": file_name, "needs_copy": false} + var base := file_name.get_basename() var extension := "." + file_name.get_extension() var index := 2 while true: var candidate := "%s %d%s" % [base, index, extension] - if not FileAccess.file_exists(ROUTINES_DIR.path_join(candidate)): - return candidate + var candidate_path := ROUTINES_DIR.path_join(candidate) + if not FileAccess.file_exists(candidate_path): + return {"name": candidate, "needs_copy": true} + if _same_file_content(absolute_source, candidate_path): + return {"name": candidate, "needs_copy": false} index += 1 - return file_name + return {"name": file_name, "needs_copy": true} + + +static func _same_file_content(path_a: String, path_b: String) -> bool: + var size := _file_size(path_a) + if size <= 0 or size != _file_size(path_b): + return false + return FileAccess.get_sha256(path_a) == FileAccess.get_sha256(path_b) func _load_music_stream() -> bool: diff --git a/rinkplanner/tests/run_playback_tests.gd b/rinkplanner/tests/run_playback_tests.gd index 1a8cc7f..6957277 100644 --- a/rinkplanner/tests/run_playback_tests.gd +++ b/rinkplanner/tests/run_playback_tests.gd @@ -562,6 +562,52 @@ func _run() -> void: "playback bar shows the music file" ) + # Loading the very same track again must not create a numbered duplicate. + _check( + controller.load_music_from_path(music_source), + "the same music file can be loaded again" + ) + _check( + controller.get_music_file_name() == "test_music.wav", + "reloading identical music keeps the existing file name" + ) + _check( + not FileAccess.file_exists("user://routines/test_music 2.wav"), + "reloading identical music creates no numbered duplicate" + ) + + # A different track with the same name still gets its own numbered copy. + var alt_dir := "user://music_alt" + DirAccess.make_dir_recursive_absolute( + ProjectSettings.globalize_path(alt_dir) + ) + var alt_source := alt_dir.path_join("test_music.wav") + _write_test_wav(alt_source, 16000) + _check( + controller.load_music_from_path(alt_source), + "a different track with the same name loads" + ) + _check( + controller.get_music_file_name() == "test_music 2.wav", + "a different track is stored under a numbered name" + ) + _check( + controller.load_music_from_path(alt_source), + "the numbered track can be loaded again" + ) + _check( + controller.get_music_file_name() == "test_music 2.wav", + "reloading the numbered track keeps its name" + ) + _check( + controller.load_music_from_path(music_source), + "switching back to the first track works" + ) + _check( + controller.get_music_file_name() == "test_music.wav", + "switching back reuses the existing first copy" + ) + controller.seek_playback(0.5) controller.play() _check(controller.music_player.playing, "music starts with routine playback") @@ -598,9 +644,14 @@ func _run() -> void: FileAccess.file_exists("user://routines/test_music.wav"), "clearing keeps the file for other routines" ) - DirAccess.remove_absolute( - ProjectSettings.globalize_path("user://routines/test_music.wav") - ) + for leftover: String in [ + "user://routines/test_music.wav", + "user://routines/test_music 2.wav", + ]: + if FileAccess.file_exists(leftover): + DirAccess.remove_absolute(ProjectSettings.globalize_path(leftover)) + DirAccess.remove_absolute(ProjectSettings.globalize_path(alt_source)) + DirAccess.remove_absolute(ProjectSettings.globalize_path(alt_dir)) DirAccess.remove_absolute(ProjectSettings.globalize_path(music_source)) scene.queue_free() @@ -613,27 +664,26 @@ func _run() -> void: _finish() -func _write_test_wav(path: String) -> void: - const SAMPLE_RATE := 8000 - const DATA_SIZE := SAMPLE_RATE * 2 +func _write_test_wav(path: String, sample_rate: int = 8000) -> void: + var data_size := sample_rate * 2 var file := FileAccess.open(path, FileAccess.WRITE) if file == null: return file.store_buffer("RIFF".to_ascii_buffer()) - file.store_32(36 + DATA_SIZE) + file.store_32(36 + data_size) file.store_buffer("WAVE".to_ascii_buffer()) file.store_buffer("fmt ".to_ascii_buffer()) file.store_32(16) file.store_16(1) file.store_16(1) - file.store_32(SAMPLE_RATE) - file.store_32(SAMPLE_RATE * 2) + file.store_32(sample_rate) + file.store_32(sample_rate * 2) file.store_16(2) file.store_16(16) file.store_buffer("data".to_ascii_buffer()) - file.store_32(DATA_SIZE) + file.store_32(data_size) var silence := PackedByteArray() - silence.resize(DATA_SIZE) + silence.resize(data_size) file.store_buffer(silence) file.close()