mms-lib 0.2.1__tar.gz → 0.3.0__tar.gz

{mms_lib-0.2.1 → mms_lib-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mms-lib
-Version: 0.2.1
+Version: 0.3.0
 Summary: Extract from MIDI-MCSTRUCTURE NEXT Project
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown

{mms_lib-0.2.1 → mms_lib-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mms-lib"
-version = "0.2.1"
+version = "0.3.0"
 description = "Extract from MIDI-MCSTRUCTURE NEXT Project"
 readme = "README.md"
 requires-python = ">=3.14"

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms/__init__.py

@@ -2,4 +2,4 @@ from .core import init, read_midi, convertor, profile
 from .dataclass import Settings, Note, Lyrics
 
 __all__ = ["init", "read_midi", "convertor", "profile", "Note", "Lyrics", "Settings"]
-__version__ = "0.2.1"
+__version__ = "0.3.0"

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms/core.py

@@ -1,8 +1,9 @@
 import os
 from . import evaltools
 from math import ceil, isclose
-from .tools import round_int, round_45, is_number, limit
+from .tools import round_int, round_45, is_number, limit, is_midi
 from .dataclass import LyricsList, Note, Lyrics, Eval, AverageNumber, Profiles, Settings
+from .nbs_reader import NBSReader
 from .midi_reader import MIDIReader
 from importlib.resources import files
 
@@ -41,7 +42,7 @@ def load_lrc(lines: list[str], time_per_tick: int = 50):
             elif tag_type == "offset":
                 offset = int(value)
 
-def read_midi(midi_reader: MIDIReader, platform_profile: dict, lyrics_data: list[str] | None = None) -> dict[int, set[Note | Lyrics]]:
+def read_midi(midi_reader: MIDIReader | NBSReader, platform_profile: dict, lyrics_data: list[str] | None = None) -> dict[int, set[Note | Lyrics]]:
     if profile.settings.max_time_error:
         tempo = profile.settings.time_per_tick
         min_error = float("INF")
@@ -105,13 +106,18 @@ def read_midi(midi_reader: MIDIReader, platform_profile: dict, lyrics_data: list
     # 歌词数据处理
     if lyrics_data is not None:
         lyrics_buffer.clear()
+
         for k, i in load_lrc(lyrics_data, best_tempo):
             if k in lyrics_buffer:
                 lyrics_buffer[k] += " " + i
             else:
                 lyrics_buffer[k] = i
 
-    # 渲染歌词字幕
+    render_lyrics(lyrics_buffer, result)
+
+    return result
+
+def render_lyrics(lyrics_buffer: dict[int, str], music_data: dict[int, set[Note | Lyrics]]) -> None:
     if lyrics_buffer:
         last_l = None
         for k, l in LyricsList(lyrics_buffer, profile.settings.smooth_progress, profile.settings.auto_join_lyrics):
@@ -120,25 +126,28 @@ def read_midi(midi_reader: MIDIReader, platform_profile: dict, lyrics_data: list
                 continue
 
             # 将歌词数据合并到结果中
-            if k not in result:
-                result[k] = set()
+            if k not in music_data:
+                music_data[k] = set()
 
-            result[k].add(l)
+            music_data[k].add(l)
             last_l = l
 
-    return result
-
 def convertor(file_data: bytes, platform: str, lyrics_data: list[str] | None = None):
     platform_profile = profile.profile[platform]
 
-    midi_data = read_midi(MIDIReader(file_data), platform_profile, lyrics_data)
+    if is_midi(file_data):
+        file_data = MIDIReader(file_data)
+    else:
+        file_data = NBSReader(file_data)
+
+    music_data = read_midi(file_data, platform_profile, lyrics_data)
 
     if profile.settings.skip:
-        time_offset = min(midi_data.keys())
+        time_offset = min(music_data.keys())
     else:
         time_offset = 0
 
-    return cmd_convertor(platform_profile, time_offset, midi_data)
+    return cmd_convertor(platform_profile, time_offset, music_data)
 
 def get_notes(midi_file: MIDIReader, platform_profile: dict, tempo: float | int):
     if not profile.settings.enable_extension:
@@ -240,7 +249,7 @@ def cmd_convertor(platform_profile: dict, start_time: int, note_data: dict[int,
         cmd = cmd.replace("{ADDRESS}", str(profile.settings.id))
         cmd = cmd.replace("{ID_SCOREBOARD}", profile.settings.id_scoreboard_name)
         cmd = cmd.replace("{TIMER_SCOREBOARD}", profile.settings.timer_scoreboard_name)
-        yield time, cmd
+        yield time, cmd.lstrip("/")
 
 def cmd_generator(platform_profile: dict, start_time: int, note_data: dict[int, set[Note | Lyrics]]):
     raw_cmd: str = platform_profile["command"][profile.settings.command_type][0]

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms/dataclass.py

@@ -237,7 +237,7 @@ class NoteData:
         "type"
     )
 
-    def __init__(self, time: float, pitch: float, program: tuple[int, int], panning: tuple[float], velocity: float):
+    def __init__(self, time: float, pitch: float, program: tuple[int, int], panning: tuple[float, float], velocity: float):
         self.type = "note"
         self.time = time
         self.pitch = pitch

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms/midi_reader.py

@@ -211,7 +211,7 @@ class MIDIReader:
                 elif message.type == "note_off" or (message.type == "note_on" and message.velocity == 0):
                     data = stack.get(channel, message.note)
 
-                # 将音符时间转为游戏tick时间并返回结果
+                # 将音符时间转为绝对时间并返回结果，时间单位为毫秒
                 if data is not None: yield tempo_info.compute_time(time), data
 
         for data in stack: yield data.time + 0.00001, data

mms_lib-0.3.0/src/mms/nbs_reader.py

@@ -0,0 +1,63 @@
+import io
+import math
+from . import pynbs
+from .tools import round_45
+from .dataclass import NoteData
+
+NBS_TO_GM_MAPPING = {
+    0:  0,
+    1:  43,
+    2:  116,
+    3:  118,
+    4:  115,
+    5:  24,
+    6:  73,
+    7:  14,
+    8:  8,
+    9:  13,
+    10: 9,
+    11: 113,
+    12: 111,
+    13: 80,
+    14: 105,
+    15: 98,
+}
+
+class NBSReader:
+    def __init__(self, data: bytes):
+        self.__nbs_file = pynbs.Parser(io.BytesIO(data)).read_file()
+        self.__nodes_cache = []
+        self.__instruments_mapping = {}
+
+    def get_time_accuracy(self, _) -> float:
+        return 0.0
+
+    def override_mapping(self, mapping: dict[int, dict[int, int]]) -> None:
+        self.__instruments_mapping = mapping
+
+    def __iter__(self):
+        volume_info = {}
+        panning_info = {}
+        for layer in  self.__nbs_file.layers:
+            volume_info[layer.id] = layer.volume
+            panning_info[layer.id] = layer.panning
+
+        for tick, notes in self.__nbs_file:
+            for note in notes:
+                if panning_info[note.layer] == 0:
+                    panning = note.panning
+                else:
+                    panning = (note.panning + panning_info[note.layer]) / 2
+
+                radian = math.radians((panning + 100) * 0.9)
+
+                note_data = NoteData(
+                    tick * 50,
+                    note.key + 21 + note.pitch / 100,
+                    (NBS_TO_GM_MAPPING.get(note.instrument, 0), ) * 2,
+                    (round_45(math.cos(radian), 2), round_45(math.sin(radian), 2)),
+                    note.velocity * volume_info[note.layer]
+                )
+
+                yield tick * 50 + 0.00001, note_data
+

mms_lib-0.3.0/src/mms/pynbs/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "1.0.0-beta.0"
+
+
+from .file import *

mms_lib-0.3.0/src/mms/pynbs/file.py

@@ -0,0 +1,306 @@
+__all__ = [
+    "read",
+    "new_file",
+    "Parser",
+    "Writer",
+    "File",
+    "Header",
+    "Note",
+    "Layer",
+    "Instrument",
+]
+
+
+from dataclasses import dataclass
+from struct import Struct
+
+CURRENT_NBS_VERSION = 5
+
+BYTE = Struct("<B")
+SHORT = Struct("<H")
+SSHORT = Struct("<h")
+INT = Struct("<I")
+
+
+@dataclass
+class Instrument:
+    id: int
+    name: str
+    file: str
+    pitch: int = 45
+    press_key: bool = True
+
+
+@dataclass
+class Note:
+    tick: int
+    layer: int
+    instrument: int
+    key: int
+    velocity: int = 100
+    panning: int = 0
+    pitch: int = 0
+
+
+@dataclass
+class Layer:
+    id: int
+    name: str = ""
+    lock: bool = False
+    volume: int = 100
+    panning: int = 0
+
+
+def read(filename):
+    with open(filename, "rb") as fileobj:
+        return Parser(fileobj).read_file()
+
+
+def new_file(**header):
+    return File(Header(**header), [], [Layer(0, "", False, 100, 0)], [])
+
+
+@dataclass
+class Header:
+    version: int = CURRENT_NBS_VERSION
+    default_instruments: int = 16
+    song_length: int = 0
+    song_layers: int = 0
+    song_name: str = ""
+    song_author: str = ""
+    original_author: str = ""
+    description: str = ""
+    tempo: float = 10.0
+    auto_save: bool = False
+    auto_save_duration: int = 10
+    time_signature: int = 4
+    minutes_spent: int = 0
+    left_clicks: int = 0
+    right_clicks: int = 0
+    blocks_added: int = 0
+    blocks_removed: int = 0
+    song_origin: str = ""
+    loop: bool = False
+    max_loop_count: int = 0
+    loop_start: int = 0
+
+
+class File:
+    def __init__(self, header, notes, layers, instruments):
+        self.header = header
+        self.notes = notes
+        self.layers = layers
+        self.instruments = instruments
+
+    def update_header(self, version):
+        self.header.version = version
+        if self.notes:
+            self.header.song_length = self.notes[-1].tick
+        self.header.song_layers = len(self.layers)
+
+    def save(self, filename, version=CURRENT_NBS_VERSION):
+        self.update_header(version)
+        with open(filename, "wb") as fileobj:
+            Writer(fileobj).encode_file(self, version)
+
+    def __iter__(self):
+        if not self.notes:
+            return
+        chord = []
+        current_tick = self.notes[0].tick
+
+        for note in sorted(self.notes, key=lambda n: n.tick):
+            if note.tick == current_tick:
+                chord.append(note)
+            else:
+                chord.sort(key=lambda n: n.layer)
+                yield current_tick, chord
+                current_tick, chord = note.tick, [note]
+        yield current_tick, chord
+
+
+class Parser:
+    def __init__(self, fileobj):
+        self.fileobj = fileobj
+
+    def read_file(self):
+        header = self.parse_header()
+        version = header.version
+        return File(
+            header,
+            list(self.parse_notes(version)),
+            list(self.parse_layers(header.song_layers, version)),
+            list(self.parse_instruments(version)),
+        )
+
+    def read_numeric(self, fmt):
+        return fmt.unpack(self.fileobj.read(fmt.size))[0]
+
+    def read_string(self):
+        length = self.read_numeric(INT)
+        return self.fileobj.read(length).decode(encoding="cp1252")
+
+    def jump(self):
+        value = -1
+        while True:
+            jump = self.read_numeric(SHORT)
+            if not jump:
+                break
+            value += jump
+            yield value
+
+    def parse_header(self):
+        song_length = self.read_numeric(SHORT)
+        if song_length == 0:
+            # A song length of 0 indicates the Open Note Block Studio format
+            version = self.read_numeric(BYTE)
+        else:
+            version = 0
+
+        return Header(
+            version=version,
+            default_instruments=self.read_numeric(BYTE) if version > 0 else 10,
+            song_length=self.read_numeric(SHORT) if version >= 3 else song_length,
+            song_layers=self.read_numeric(SHORT),
+            song_name=self.read_string(),
+            song_author=self.read_string(),
+            original_author=self.read_string(),
+            description=self.read_string(),
+            tempo=self.read_numeric(SHORT) / 100.0,
+            auto_save=self.read_numeric(BYTE) == 1,
+            auto_save_duration=self.read_numeric(BYTE),
+            time_signature=self.read_numeric(BYTE),
+            minutes_spent=self.read_numeric(INT),
+            left_clicks=self.read_numeric(INT),
+            right_clicks=self.read_numeric(INT),
+            blocks_added=self.read_numeric(INT),
+            blocks_removed=self.read_numeric(INT),
+            song_origin=self.read_string(),
+            loop=self.read_numeric(BYTE) == 1 if version >= 4 else False,
+            max_loop_count=self.read_numeric(BYTE) if version >= 4 else 0,
+            loop_start=self.read_numeric(SHORT) if version >= 4 else 0,
+        )
+
+    def parse_notes(self, version):
+        for current_tick in self.jump():
+            for current_layer in self.jump():
+                instrument = self.read_numeric(BYTE)
+                key = self.read_numeric(BYTE)
+                velocity = self.read_numeric(BYTE) if version >= 4 else 100
+                panning = self.read_numeric(BYTE) - 100 if version >= 4 else 0
+                pitch = self.read_numeric(SSHORT) if version >= 4 else 0
+                yield Note(
+                    current_tick,
+                    current_layer,
+                    instrument,
+                    key,
+                    velocity,
+                    panning,
+                    pitch,
+                )
+
+    def parse_layers(self, layers_count, version):
+        for i in range(layers_count):
+            name = self.read_string()
+            lock = self.read_numeric(BYTE) == 1 if version >= 4 else False
+            volume = self.read_numeric(BYTE)
+            panning = self.read_numeric(BYTE) - 100 if version >= 2 else 0
+            yield Layer(i, name, lock, volume, panning)
+
+    def parse_instruments(self, version):
+        for i in range(self.read_numeric(BYTE)):
+            name = self.read_string()
+            sound_file = self.read_string()
+            pitch = self.read_numeric(BYTE)
+            press_key = self.read_numeric(BYTE) == 1
+            yield Instrument(i, name, sound_file, pitch, press_key)
+
+
+class Writer:
+    def __init__(self, fileobj):
+        self.fileobj = fileobj
+
+    def encode_file(self, nbs_file, version):
+        self.write_header(nbs_file, version)
+        self.write_notes(nbs_file, version)
+        self.write_layers(nbs_file, version)
+        self.write_instruments(nbs_file, version)
+
+    def encode_numeric(self, fmt, value):
+        self.fileobj.write(fmt.pack(value))
+
+    def encode_string(self, value):
+        self.encode_numeric(INT, len(value))
+        self.fileobj.write(value.encode(encoding="cp1252"))
+
+    def write_header(self, nbs_file, version):
+        header = nbs_file.header
+
+        if version > 0:
+            self.encode_numeric(SHORT, 0)
+            self.encode_numeric(BYTE, version)
+            self.encode_numeric(BYTE, header.default_instruments)
+        else:
+            self.encode_numeric(SHORT, header.song_length)
+        if version >= 3:
+            self.encode_numeric(SHORT, header.song_length)
+        self.encode_numeric(SHORT, header.song_layers)
+        self.encode_string(header.song_name)
+        self.encode_string(header.song_author)
+        self.encode_string(header.original_author)
+        self.encode_string(header.description)
+
+        self.encode_numeric(SHORT, int(header.tempo * 100))
+        self.encode_numeric(BYTE, int(header.auto_save))
+        self.encode_numeric(BYTE, header.auto_save_duration)
+        self.encode_numeric(BYTE, header.time_signature)
+
+        self.encode_numeric(INT, header.minutes_spent)
+        self.encode_numeric(INT, header.left_clicks)
+        self.encode_numeric(INT, header.right_clicks)
+        self.encode_numeric(INT, header.blocks_added)
+        self.encode_numeric(INT, header.blocks_removed)
+        self.encode_string(header.song_origin)
+
+        if version >= 4:
+            self.encode_numeric(BYTE, int(header.loop))
+            self.encode_numeric(BYTE, header.max_loop_count)
+            self.encode_numeric(SHORT, header.loop_start)
+
+    def write_notes(self, nbs_file, version):
+        current_tick = -1
+
+        for tick, chord in nbs_file:
+            self.encode_numeric(SHORT, tick - current_tick)
+            current_tick = tick
+            current_layer = -1
+
+            for note in chord:
+                self.encode_numeric(SHORT, note.layer - current_layer)
+                current_layer = note.layer
+                self.encode_numeric(BYTE, note.instrument)
+                self.encode_numeric(BYTE, note.key)
+                if version >= 4:
+                    self.encode_numeric(BYTE, note.velocity)
+                    self.encode_numeric(BYTE, note.panning + 100)
+                    self.encode_numeric(SSHORT, note.pitch)
+
+            self.encode_numeric(SHORT, 0)
+        self.encode_numeric(SHORT, 0)
+
+    def write_layers(self, nbs_file, version):
+        for layer in nbs_file.layers:
+            self.encode_string(layer.name)
+            if version >= 4:
+                self.encode_numeric(BYTE, int(layer.lock))
+            self.encode_numeric(BYTE, layer.volume)
+            if version >= 2:
+                self.encode_numeric(BYTE, layer.panning + 100)
+
+    def write_instruments(self, nbs_file, version):
+        self.encode_numeric(BYTE, len(nbs_file.instruments))
+        for instrument in nbs_file.instruments:
+            self.encode_string(instrument.name)
+            self.encode_string(instrument.file)
+            self.encode_numeric(BYTE, instrument.pitch)
+            self.encode_numeric(BYTE, int(instrument.press_key))

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms/tools.py

@@ -25,3 +25,5 @@ def is_number(text: str) -> bool:
     length = len(str)
     return all(text[i] in "0123456789" or (text[i] == "." and 1 < i + 1 < length) for i in range(length)) and text.count(".") <= 1
 
+def is_midi(data: bytes) -> bool:
+    return data[:4] == b"MThd"

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mms-lib
-Version: 0.2.1
+Version: 0.3.0
 Summary: Extract from MIDI-MCSTRUCTURE NEXT Project
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown

{mms_lib-0.2.1 → mms_lib-0.3.0}/src/mms_lib.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/mms/core.py
 src/mms/dataclass.py
 src/mms/evaltools.py
 src/mms/midi_reader.py
+src/mms/nbs_reader.py
 src/mms/tools.py
 src/mms/assets/text/features.json
 src/mms/assets/text/mapping.json
@@ -29,6 +30,8 @@ src/mms/mido/midifiles/meta.py
 src/mms/mido/midifiles/midifiles.py
 src/mms/mido/midifiles/tracks.py
 src/mms/mido/midifiles/units.py
+src/mms/pynbs/__init__.py
+src/mms/pynbs/file.py
 src/mms_lib.egg-info/PKG-INFO
 src/mms_lib.egg-info/SOURCES.txt
 src/mms_lib.egg-info/dependency_links.txt