acep: update project version compatibility

libresvip/plugins/acep/ace_studio_generator.py

@@ -104,24 +104,9 @@ def generate_track(self, track: Track) -> Optional[AcepTrack]:
         if isinstance(track, InstrumentalTrack):
             ace_audio_track = AcepAudioTrack()
             audio_pattern = AcepAudioPattern(path=track.audio_file_path)
-            actual_original_offset = self.generate_audio_offset(track.offset)
-            if actual_original_offset < 0:
-                audio_pattern.clip_dur = round(-actual_original_offset)
-                audio_pattern.pos = -audio_pattern.clip_dur
-            else:
-                audio_pattern.pos = round(actual_original_offset)
+            audio_pattern.pos = self.synchronizer.get_actual_secs_from_ticks(track.offset)
             if (track_info := audio_track_info(track.audio_file_path)) is not None:
-                offset = (
-                    self.synchronizer.get_actual_secs_from_ticks(audio_pattern.pos)
-                    if audio_pattern.pos > 0
-                    else audio_pattern.pos / self.first_bar_tempo[0].bpm / 8
-                )
-                audio_pattern.dur = round(
-                    self.synchronizer.get_actual_ticks_from_secs(
-                        offset + track_info.duration / 1000
-                    )
-                    - audio_pattern.pos
-                )
+                audio_pattern.dur = track_info.duration / 1000
                 audio_pattern.clip_dur = audio_pattern.dur - audio_pattern.clip_pos
             else:
                 return None
@@ -185,23 +170,6 @@ def generate_vocal_pattern() -> None:
         ace_track.gain = min(6.0, 20 * math.log10(track.volume))
         return ace_track
 
-    def generate_audio_offset(self, offset: int) -> int:
-        if offset > 0:
-            return offset
-        current_pos = self.first_bar_ticks
-        actual_pos = self.first_bar_ticks + offset
-        res = 0.0
-        i = len(self.first_bar_tempo) - 1
-        while i >= 0 and actual_pos <= self.first_bar_tempo[i].position:
-            res -= current_pos - self.first_bar_tempo[i].position
-            current_pos = self.first_bar_tempo[i].position
-            i -= 1
-        if i >= 0:
-            res -= current_pos - actual_pos
-        else:
-            res += actual_pos
-        return round(res)
-
     @staticmethod
     def adjust_breath_tags(notes: list[AcepNote]) -> None:
         for i in range(1, len(notes)):
@@ -230,14 +198,7 @@ def generate_note(self, note: Note, pinyin: Optional[str] = None) -> None:
                 note.pronunciation if note.pronunciation is not None else pinyin or ""
             )
             if note.edited_phones is not None and note.edited_phones.head_length_in_secs >= 0:
-                phone_start_in_secs = (
-                    self.synchronizer.get_actual_secs_from_ticks(note.start_pos)
-                    - note.edited_phones.head_length_in_secs
-                )
-                phone_start_in_ticks = self.synchronizer.get_actual_ticks_from_secs(
-                    phone_start_in_secs
-                )
-                ace_note.head_consonants = [round(note.start_pos - phone_start_in_ticks)]
+                ace_note.head_consonants = [note.edited_phones.head_length_in_secs]
             elif self.options.default_consonant_length:
                 ace_note.head_consonants = [self.options.default_consonant_length]
         elif (

libresvip/plugins/acep/ace_studio_parser.py

@@ -91,7 +91,12 @@ def parse_track(self, ace_track: AcepTrack) -> Optional[Track]:
             and isinstance(ace_track, AcepAudioTrack)
             and len(ace_track.patterns)
         ):
-            track = InstrumentalTrack(audio_file_path=ace_track.patterns[0].path)
+            track = InstrumentalTrack(
+                audio_file_path=ace_track.patterns[0].path,
+                offset=int(ace_track.patterns[0].pos)
+                if self.content_version < 7
+                else self.synchronizer.get_actual_ticks_from_secs(ace_track.patterns[0].pos),
+            )
         elif isinstance(ace_track, AcepVocalTrack):
             track = SingingTrack(
                 ai_singer_name=(id2singer.get(ace_track.singer.singer_id, None) or "")
@@ -188,7 +193,13 @@ def parse_note(self, ace_note: AcepNote, pinyin: Optional[str] = None) -> Note:
         if ace_note.br_len > 0:
             note.head_tag = "V"
         if ace_note.head_consonants:
-            note.edited_phones = Phones(head_length_in_secs=ace_note.head_consonants[0])
+            note.edited_phones = Phones(
+                head_length_in_secs=self.synchronizer.get_duration_secs_from_ticks(
+                    note.start_pos - int(ace_note.head_consonants[0]), note.start_pos
+                )
+                if self.content_version < 7
+                else ace_note.head_consonants[0]
+            )
         return note
 
     def parse_params(self, ace_params: AcepParams, ace_note_list: list[AcepNote]) -> Params:
@@ -342,23 +353,20 @@ def parse_pitch_curve(
             for ace_curve in ace_curves.root:
                 pos = ace_curve.offset
                 curve.points.append(Point(pos + self.first_bar_ticks, -100))
-                if ace_curve.curve_type == "anchor":
-                    for value in ace_curve.values:
+                for value in ace_curve.values:
+                    if ace_curve.curve_type == "anchor":
                         curve.points.append(Point(pos + self.first_bar_ticks, round(value * 100)))
-                        pos += 1
-                else:
-                    for value in ace_curve.values:
-                        if not math.isnan(value):
-                            abs_semitone = (
-                                base_pitch.semitone_value_at(
-                                    self.synchronizer.get_actual_secs_from_ticks(pos)
-                                )
-                                + value
+                    elif not math.isnan(value):
+                        abs_semitone = (
+                            base_pitch.semitone_value_at(
+                                self.synchronizer.get_actual_secs_from_ticks(pos)
                             )
-                            curve.points.append(
-                                Point(pos + self.first_bar_ticks, round(abs_semitone * 100))
-                            )
-                        pos += 1
+                            + value
+                        )
+                        curve.points.append(
+                            Point(pos + self.first_bar_ticks, round(abs_semitone * 100))
+                        )
+                    pos += 1
                 curve.points.append(Point(pos - 1 + self.first_bar_ticks, -100))
         curve.points.append(Point.end_point())
         if self.options.curve_sample_interval > 0:

libresvip/plugins/acep/model.py

@@ -373,7 +373,7 @@ class AcepProject(BaseModel):
     loop: Optional[bool] = False
     loop_start: Optional[int] = Field(0, alias="loopStart")
     loop_end: Optional[int] = Field(7680, alias="loopEnd")
-    version: int = 6
+    version: int = 7
     version_revision: Optional[int] = Field(0, alias="versionRevision")
     merged_pattern_index: int = Field(0, alias="mergedPatternIndex")
     record_pattern_index: int = Field(0, alias="recordPatternIndex")

libresvip/plugins/acep/options.py

@@ -205,8 +205,8 @@ class OutputOptions(BaseModel):
             "ACE Studio supports three languages of lyrics. This option is used to set the language of lyrics."
         ),
     )
-    default_consonant_length: int = Field(
-        default=0,
-        title=_("Default consonant length (ticks)"),
+    default_consonant_length: float = Field(
+        default=0.0,
+        title=_("Default consonant length (secs)"),
         description=_("Set default consonant length for notes if not specified"),
     )