385 lines
12 KiB
Go
385 lines
12 KiB
Go
package sync
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"sub-cli/internal/format/lrc"
|
|
"sub-cli/internal/format/srt"
|
|
"sub-cli/internal/format/vtt"
|
|
"sub-cli/internal/model"
|
|
)
|
|
|
|
// SyncLyrics synchronizes the timeline of a source lyrics file with a target lyrics file
|
|
func SyncLyrics(sourceFile, targetFile string) error {
|
|
sourceFmt := strings.TrimPrefix(filepath.Ext(sourceFile), ".")
|
|
targetFmt := strings.TrimPrefix(filepath.Ext(targetFile), ".")
|
|
|
|
// Check for supported format combinations
|
|
if sourceFmt == "lrc" && targetFmt == "lrc" {
|
|
return syncLRCFiles(sourceFile, targetFile)
|
|
} else if sourceFmt == "srt" && targetFmt == "srt" {
|
|
return syncSRTFiles(sourceFile, targetFile)
|
|
} else if sourceFmt == "vtt" && targetFmt == "vtt" {
|
|
return syncVTTFiles(sourceFile, targetFile)
|
|
} else {
|
|
return fmt.Errorf("sync only supports files of the same format (lrc-to-lrc, srt-to-srt, or vtt-to-vtt)")
|
|
}
|
|
}
|
|
|
|
// syncLRCFiles synchronizes two LRC files
|
|
func syncLRCFiles(sourceFile, targetFile string) error {
|
|
source, err := lrc.Parse(sourceFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing source file: %w", err)
|
|
}
|
|
|
|
target, err := lrc.Parse(targetFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing target file: %w", err)
|
|
}
|
|
|
|
// Check if line counts match
|
|
if len(source.Timeline) != len(target.Content) {
|
|
fmt.Printf("Warning: Source timeline (%d entries) and target content (%d entries) have different counts. Timeline will be scaled.\n",
|
|
len(source.Timeline), len(target.Content))
|
|
}
|
|
|
|
// Apply timeline from source to target
|
|
syncedLyrics := syncLRCTimeline(source, target)
|
|
|
|
// Write the synced lyrics to the target file
|
|
return lrc.Generate(syncedLyrics, targetFile)
|
|
}
|
|
|
|
// syncSRTFiles synchronizes two SRT files
|
|
func syncSRTFiles(sourceFile, targetFile string) error {
|
|
sourceEntries, err := srt.Parse(sourceFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing source SRT file: %w", err)
|
|
}
|
|
|
|
targetEntries, err := srt.Parse(targetFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing target SRT file: %w", err)
|
|
}
|
|
|
|
// Check if entry counts match
|
|
if len(sourceEntries) != len(targetEntries) {
|
|
fmt.Printf("Warning: Source (%d entries) and target (%d entries) have different entry counts. Timeline will be adjusted.\n",
|
|
len(sourceEntries), len(targetEntries))
|
|
}
|
|
|
|
// Sync the timelines
|
|
syncedEntries := syncSRTTimeline(sourceEntries, targetEntries)
|
|
|
|
// Write the synced entries to the target file
|
|
return srt.Generate(syncedEntries, targetFile)
|
|
}
|
|
|
|
// syncVTTFiles synchronizes two VTT files
|
|
func syncVTTFiles(sourceFile, targetFile string) error {
|
|
sourceSubtitle, err := vtt.Parse(sourceFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing source VTT file: %w", err)
|
|
}
|
|
|
|
targetSubtitle, err := vtt.Parse(targetFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing target VTT file: %w", err)
|
|
}
|
|
|
|
// Check if entry counts match
|
|
if len(sourceSubtitle.Entries) != len(targetSubtitle.Entries) {
|
|
fmt.Printf("Warning: Source (%d entries) and target (%d entries) have different entry counts. Timeline will be adjusted.\n",
|
|
len(sourceSubtitle.Entries), len(targetSubtitle.Entries))
|
|
}
|
|
|
|
// Sync the timelines
|
|
syncedSubtitle := syncVTTTimeline(sourceSubtitle, targetSubtitle)
|
|
|
|
// Write the synced subtitle to the target file
|
|
return vtt.Generate(syncedSubtitle, targetFile)
|
|
}
|
|
|
|
// syncLRCTimeline applies the timeline from the source lyrics to the target lyrics
|
|
func syncLRCTimeline(source, target model.Lyrics) model.Lyrics {
|
|
result := model.Lyrics{
|
|
Metadata: target.Metadata,
|
|
Content: target.Content,
|
|
}
|
|
|
|
// Create timeline with same length as target content
|
|
result.Timeline = make([]model.Timestamp, len(target.Content))
|
|
|
|
// Use source timeline if available and lengths match
|
|
if len(source.Timeline) > 0 && len(source.Timeline) == len(target.Content) {
|
|
copy(result.Timeline, source.Timeline)
|
|
} else if len(source.Timeline) > 0 {
|
|
// If lengths don't match, scale timeline using our improved scaleTimeline function
|
|
result.Timeline = scaleTimeline(source.Timeline, len(target.Content))
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// syncSRTTimeline applies the timing from source SRT entries to target SRT entries
|
|
func syncSRTTimeline(sourceEntries, targetEntries []model.SRTEntry) []model.SRTEntry {
|
|
result := make([]model.SRTEntry, len(targetEntries))
|
|
|
|
// Copy target entries
|
|
copy(result, targetEntries)
|
|
|
|
// If source and target have the same number of entries, directly apply timings
|
|
if len(sourceEntries) == len(targetEntries) {
|
|
for i := range result {
|
|
result[i].StartTime = sourceEntries[i].StartTime
|
|
result[i].EndTime = sourceEntries[i].EndTime
|
|
}
|
|
} else {
|
|
// If entry counts differ, scale the timing
|
|
for i := range result {
|
|
// Calculate scaled index
|
|
sourceIdx := 0
|
|
if len(sourceEntries) > 1 {
|
|
sourceIdx = i * (len(sourceEntries) - 1) / (len(targetEntries) - 1)
|
|
}
|
|
|
|
// Ensure the index is within bounds
|
|
if sourceIdx >= len(sourceEntries) {
|
|
sourceIdx = len(sourceEntries) - 1
|
|
}
|
|
|
|
// Apply the scaled timing
|
|
result[i].StartTime = sourceEntries[sourceIdx].StartTime
|
|
|
|
// Calculate end time: if not the last entry, use duration from source
|
|
if i < len(result)-1 {
|
|
// If next source entry exists, calculate duration
|
|
var duration model.Timestamp
|
|
if sourceIdx+1 < len(sourceEntries) {
|
|
duration = calculateDuration(sourceEntries[sourceIdx].StartTime, sourceEntries[sourceIdx+1].StartTime)
|
|
} else {
|
|
// If no next source entry, use the source's end time (usually a few seconds after start)
|
|
duration = calculateDuration(sourceEntries[sourceIdx].StartTime, sourceEntries[sourceIdx].EndTime)
|
|
}
|
|
|
|
// Apply duration to next start time
|
|
result[i].EndTime = addDuration(result[i].StartTime, duration)
|
|
} else {
|
|
// For the last entry, add a fixed duration (e.g., 3 seconds)
|
|
result[i].EndTime = sourceEntries[sourceIdx].EndTime
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ensure proper sequence numbering
|
|
for i := range result {
|
|
result[i].Number = i + 1
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// syncVTTTimeline applies the timing from source VTT subtitle to target VTT subtitle
|
|
func syncVTTTimeline(source, target model.Subtitle) model.Subtitle {
|
|
result := model.NewSubtitle()
|
|
result.Format = "vtt"
|
|
result.Title = target.Title
|
|
result.Metadata = target.Metadata
|
|
result.Styles = target.Styles
|
|
|
|
// Create entries array with same length as target
|
|
result.Entries = make([]model.SubtitleEntry, len(target.Entries))
|
|
|
|
// Copy target entries
|
|
copy(result.Entries, target.Entries)
|
|
|
|
// 如果源字幕为空或目标字幕为空，直接返回复制的目标内容
|
|
if len(source.Entries) == 0 || len(target.Entries) == 0 {
|
|
// 确保索引编号正确
|
|
for i := range result.Entries {
|
|
result.Entries[i].Index = i + 1
|
|
}
|
|
return result
|
|
}
|
|
|
|
// If source and target have the same number of entries, directly apply timings
|
|
if len(source.Entries) == len(target.Entries) {
|
|
for i := range result.Entries {
|
|
result.Entries[i].StartTime = source.Entries[i].StartTime
|
|
result.Entries[i].EndTime = source.Entries[i].EndTime
|
|
}
|
|
} else {
|
|
// If entry counts differ, scale the timing similar to SRT sync
|
|
for i := range result.Entries {
|
|
// Calculate scaled index
|
|
sourceIdx := 0
|
|
if len(source.Entries) > 1 {
|
|
sourceIdx = i * (len(source.Entries) - 1) / (len(target.Entries) - 1)
|
|
}
|
|
|
|
// Ensure the index is within bounds
|
|
if sourceIdx >= len(source.Entries) {
|
|
sourceIdx = len(source.Entries) - 1
|
|
}
|
|
|
|
// Apply the scaled timing
|
|
result.Entries[i].StartTime = source.Entries[sourceIdx].StartTime
|
|
|
|
// Calculate end time: if not the last entry, use duration from source
|
|
if i < len(result.Entries)-1 {
|
|
// If next source entry exists, calculate duration
|
|
var duration model.Timestamp
|
|
if sourceIdx+1 < len(source.Entries) {
|
|
duration = calculateDuration(source.Entries[sourceIdx].StartTime, source.Entries[sourceIdx+1].StartTime)
|
|
} else {
|
|
duration = calculateDuration(source.Entries[sourceIdx].StartTime, source.Entries[sourceIdx].EndTime)
|
|
}
|
|
result.Entries[i].EndTime = addDuration(result.Entries[i].StartTime, duration)
|
|
} else {
|
|
// For the last entry, use the end time from source
|
|
result.Entries[i].EndTime = source.Entries[sourceIdx].EndTime
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ensure proper index numbering
|
|
for i := range result.Entries {
|
|
result.Entries[i].Index = i + 1
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// scaleTimeline scales a timeline to match a different number of entries
|
|
func scaleTimeline(timeline []model.Timestamp, targetCount int) []model.Timestamp {
|
|
if targetCount <= 0 || len(timeline) == 0 {
|
|
return []model.Timestamp{}
|
|
}
|
|
|
|
result := make([]model.Timestamp, targetCount)
|
|
|
|
if targetCount == 1 {
|
|
result[0] = timeline[0]
|
|
return result
|
|
}
|
|
|
|
sourceLength := len(timeline)
|
|
|
|
// Handle simple case: same length
|
|
if targetCount == sourceLength {
|
|
copy(result, timeline)
|
|
return result
|
|
}
|
|
|
|
// Handle case where target is longer than source
|
|
// We need to interpolate timestamps between source entries
|
|
for i := 0; i < targetCount; i++ {
|
|
if sourceLength == 1 {
|
|
// If source has only one entry, use it for all target entries
|
|
result[i] = timeline[0]
|
|
continue
|
|
}
|
|
|
|
// Calculate a floating-point position in the source timeline
|
|
floatIndex := float64(i) * float64(sourceLength-1) / float64(targetCount-1)
|
|
lowerIndex := int(floatIndex)
|
|
upperIndex := lowerIndex + 1
|
|
|
|
// Handle boundary case
|
|
if upperIndex >= sourceLength {
|
|
upperIndex = sourceLength - 1
|
|
lowerIndex = upperIndex - 1
|
|
}
|
|
|
|
// If indices are the same, just use the source timestamp
|
|
if lowerIndex == upperIndex || lowerIndex < 0 {
|
|
result[i] = timeline[upperIndex]
|
|
} else {
|
|
// Calculate the fraction between the lower and upper indices
|
|
fraction := floatIndex - float64(lowerIndex)
|
|
|
|
// Convert timestamps to milliseconds for interpolation
|
|
lowerMS := timeline[lowerIndex].Hours*3600000 + timeline[lowerIndex].Minutes*60000 +
|
|
timeline[lowerIndex].Seconds*1000 + timeline[lowerIndex].Milliseconds
|
|
|
|
upperMS := timeline[upperIndex].Hours*3600000 + timeline[upperIndex].Minutes*60000 +
|
|
timeline[upperIndex].Seconds*1000 + timeline[upperIndex].Milliseconds
|
|
|
|
// Interpolate
|
|
resultMS := int(float64(lowerMS) + fraction*float64(upperMS-lowerMS))
|
|
|
|
// Convert back to timestamp
|
|
hours := resultMS / 3600000
|
|
resultMS %= 3600000
|
|
minutes := resultMS / 60000
|
|
resultMS %= 60000
|
|
seconds := resultMS / 1000
|
|
milliseconds := resultMS % 1000
|
|
|
|
result[i] = model.Timestamp{
|
|
Hours: hours,
|
|
Minutes: minutes,
|
|
Seconds: seconds,
|
|
Milliseconds: milliseconds,
|
|
}
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// calculateDuration calculates the time difference between two timestamps
|
|
func calculateDuration(start, end model.Timestamp) model.Timestamp {
|
|
startMillis := start.Hours*3600000 + start.Minutes*60000 + start.Seconds*1000 + start.Milliseconds
|
|
endMillis := end.Hours*3600000 + end.Minutes*60000 + end.Seconds*1000 + end.Milliseconds
|
|
|
|
durationMillis := endMillis - startMillis
|
|
if durationMillis < 0 {
|
|
// Return zero duration if end is before start
|
|
return model.Timestamp{
|
|
Hours: 0,
|
|
Minutes: 0,
|
|
Seconds: 0,
|
|
Milliseconds: 0,
|
|
}
|
|
}
|
|
|
|
hours := durationMillis / 3600000
|
|
durationMillis %= 3600000
|
|
minutes := durationMillis / 60000
|
|
durationMillis %= 60000
|
|
seconds := durationMillis / 1000
|
|
milliseconds := durationMillis % 1000
|
|
|
|
return model.Timestamp{
|
|
Hours: hours,
|
|
Minutes: minutes,
|
|
Seconds: seconds,
|
|
Milliseconds: milliseconds,
|
|
}
|
|
}
|
|
|
|
// addDuration adds a duration to a timestamp
|
|
func addDuration(start, duration model.Timestamp) model.Timestamp {
|
|
startMillis := start.Hours*3600000 + start.Minutes*60000 + start.Seconds*1000 + start.Milliseconds
|
|
durationMillis := duration.Hours*3600000 + duration.Minutes*60000 + duration.Seconds*1000 + duration.Milliseconds
|
|
|
|
totalMillis := startMillis + durationMillis
|
|
|
|
hours := totalMillis / 3600000
|
|
totalMillis %= 3600000
|
|
minutes := totalMillis / 60000
|
|
totalMillis %= 60000
|
|
seconds := totalMillis / 1000
|
|
milliseconds := totalMillis % 1000
|
|
|
|
return model.Timestamp{
|
|
Hours: hours,
|
|
Minutes: minutes,
|
|
Seconds: seconds,
|
|
Milliseconds: milliseconds,
|
|
}
|
|
}
|