acfunlive-remake/ass2jsonl.go

// 弹幕文件的读写与格式还原
// 上游原版只输出 .ass，这里把 .ass 还原成本程序的 jsonl，之后就能走同一套合成流程
package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"regexp"
	"sort"
	"strconv"
	"strings"
)

// ASS 的时间格式 H:MM:SS.cc
var assClockRe = regexp.MustCompile(`^(\d+):(\d{1,2}):(\d{1,2})(?:[.,](\d{1,3}))?$`)

// ASS 覆盖块里的 \move(x1,y1,x2,y2)
var assMoveRe = regexp.MustCompile(`\\move\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)`)

// Style / Dialogue 里的「昵称(uid)」
var assSpeakerRe = regexp.MustCompile(`^(.*)\((\d+)\)$`)

// 文件里没有 Format 行时按标准列序解析
// 样式必须是完整的 23 列：字号是第 3 列，后面还有颜色等字段，
// 列数给少了会把后面的内容全吞进字号那一列
var (
	defaultStyleFields = []string{
		"Name", "Fontname", "Fontsize", "PrimaryColour", "SecondaryColour", "OutlineColour",
		"BackColour", "Bold", "Italic", "Underline", "StrikeOut", "ScaleX", "ScaleY",
		"Spacing", "Angle", "BorderStyle", "Outline", "Shadow", "Alignment",
		"MarginL", "MarginR", "MarginV", "Encoding",
	}
	defaultEventFields = []string{"Layer", "Start", "End", "Style", "Name", "MarginL", "MarginR", "MarginV", "Effect", "Text"}
)

// jsonl 的摘要，检查合并参数时用
type jsonlSummary struct {
	meta      danmuMeta
	count     int
	first     float64
	last      float64
	hasAvatar bool // 记录里有没有头像链接
}

// 解析 ASS 时间（H:MM:SS.cc），返回秒数
func parseAssClock(s string) (float64, bool) {
	m := assClockRe.FindStringSubmatch(strings.TrimSpace(s))
	if m == nil {
		return 0, false
	}
	h, _ := strconv.Atoi(m[1])
	mi, _ := strconv.Atoi(m[2])
	sec, _ := strconv.Atoi(m[3])
	frac := 0.0
	if m[4] != "" {
		frac, _ = strconv.ParseFloat("0."+m[4], 64)
	}
	return float64(h)*3600 + float64(mi)*60 + float64(sec) + frac, true
}

// 按 ASS 的格式拆一行：列数按 Format 行给出的数量截断，最后一列吸收剩余的逗号
// （弹幕内容里本来就可能有逗号，不能无脑 Split）
func assFields(line string, count int) []string {
	body := line
	if i := strings.Index(line, ":"); i >= 0 {
		body = line[i+1:]
	}
	body = strings.TrimLeft(body, " \t")
	if count > 0 {
		return strings.SplitN(body, ",", count)
	}
	return strings.Split(body, ",")
}

// 这一行是不是某个 ASS 关键字开头（形如「Style: xxx」）
func isAssKey(line, key string) bool {
	i := strings.Index(line, ":")
	if i < 0 {
		return false
	}
	return strings.EqualFold(strings.TrimSpace(line[:i]), key)
}

// 字段名在 Format 行里的下标，找不到返回 -1
func assFieldIndex(format []string, name string) int {
	for i, f := range format {
		if strings.EqualFold(strings.TrimSpace(f), name) {
			return i
		}
	}
	return -1
}

// 拆开 ASS 正文开头的 {...} 覆盖块和后面的文字
func splitAssOverride(text string) (string, string) {
	if strings.HasPrefix(text, "{") {
		if i := strings.Index(text, "}"); i >= 0 {
			return text[1:i], text[i+1:]
		}
	}
	return "", text
}

// 从 \move 的 y 坐标反推弹道行号，解析不出来返回 0
func assLane(override string, fontSize int, nick bool) int {
	if fontSize <= 0 {
		return 0
	}
	m := assMoveRe.FindStringSubmatch(override)
	if m == nil {
		return 0
	}
	y, err := strconv.ParseFloat(m[2], 64)
	if err != nil {
		return 0
	}
	lane := int(math.Round(y / float64(fontSize)))
	if !nick {
		// 原格式的 y 是 fontSize*(lane+1)，昵称版是 fontSize*lane
		lane--
	}
	if lane < 0 {
		lane = 0
	}
	if lane >= laneNum {
		lane = laneNum - 1
	}
	return lane
}

// 合成时实际的显示文字，与录制时写进 jsonl 的格式一致
func speakerText(name string, uid int64, content string) string {
	return name + "(" + strconv.FormatInt(uid, 10) + "):" + content
}

// 从 ASS 文件还原弹幕记录，支持原格式（\move）和昵称头像版（\an7\move）
func parseAssFile(path string) (danmuMeta, []danmuRecord, error) {
	var meta danmuMeta

	f, err := os.Open(path)
	if err != nil {
		return meta, nil, err
	}
	defer f.Close()

	var styleFormat, eventFormat []string
	records := make([]danmuRecord, 0, 1024)
	bad := 0
	section := ""

	scanner := bufio.NewScanner(f)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
	for scanner.Scan() {
		line := strings.TrimRight(scanner.Text(), "\r")
		// 有些编辑器/工具保存的 ASS 头上有 UTF-8 BOM，第一个 "[" 会被它挡住：
		// 整份文件进不了任何一节，最后只会报一句「可能不是弹幕文件」，跟真实原因完全对不上
		line = strings.TrimPrefix(line, "\ufeff")
		t := strings.TrimSpace(line)
		if t == "" || strings.HasPrefix(t, ";") {
			continue
		}
		if strings.HasPrefix(t, "[") && strings.HasSuffix(t, "]") {
			section = strings.ToLower(strings.Trim(t, "[]"))
			continue
		}

		switch section {
		case "script info":
			i := strings.Index(t, ":")
			if i < 0 {
				continue
			}
			val := strings.TrimSpace(t[i+1:])
			switch strings.ToLower(strings.TrimSpace(t[:i])) {
			case "playresx":
				meta.PlayResX, _ = strconv.Atoi(val)
			case "playresy":
				meta.PlayResY, _ = strconv.Atoi(val)
			}

		case "v4+ styles", "v4 styles":
			if isAssKey(t, "format") {
				styleFormat = assFields(t, 0)
				continue
			}
			if !isAssKey(t, "style") {
				continue
			}
			format := styleFormat
			if len(format) == 0 {
				format = defaultStyleFields
			}
			fields := assFields(t, len(format))
			i := assFieldIndex(format, "fontsize")
			if i < 0 || i >= len(fields) {
				continue
			}
			v, err := strconv.Atoi(strings.TrimSpace(fields[i]))
			if err != nil || v <= 0 {
				continue
			}
			// 优先用 Danmu 这个样式，其它的只在本文件还没有字号时兜底
			name := ""
			if j := assFieldIndex(format, "name"); j >= 0 && j < len(fields) {
				name = strings.TrimSpace(fields[j])
			}
			if meta.FontSize == 0 || strings.EqualFold(name, "danmu") {
				meta.FontSize = v
			}

		case "events":
			if isAssKey(t, "format") {
				eventFormat = assFields(t, 0)
				continue
			}
			if !isAssKey(t, "dialogue") {
				continue
			}
			format := eventFormat
			if len(format) == 0 {
				format = defaultEventFields
			}
			fields := assFields(t, len(format))
			get := func(name string) string {
				i := assFieldIndex(format, name)
				if i < 0 || i >= len(fields) {
					return ""
				}
				return fields[i]
			}

			start, ok := parseAssClock(get("Start"))
			if !ok {
				bad++
				continue
			}

			override, body := splitAssOverride(get("Text"))
			nick := strings.Contains(override, `\an7`)

			speaker := strings.TrimSpace(get("Name"))
			name, uid := speaker, int64(0)
			if m := assSpeakerRe.FindStringSubmatch(speaker); m != nil {
				name = m[1]
				uid, _ = strconv.ParseInt(m[2], 10, 64)
			}

			// 昵称头像版的正文前面还有一段「昵称(uid):」，原格式的正文就是弹幕内容
			content := body
			if nick && speaker != "" {
				if p := strings.Index(content, speaker+":"); p >= 0 {
					content = content[p+len(speaker)+1:]
				}
			}
			content = strings.TrimSpace(content)
			if content == "" {
				bad++
				continue
			}

			records = append(records, danmuRecord{
				Time:    start,
				UID:     uid,
				Name:    name,
				Avatar:  "", // .ass 里没有头像链接，合成时按 uid 反查
				Content: content,
				Lane:    assLane(override, meta.FontSize, nick),
				Width:   textWidth(speakerText(name, uid, content), meta.FontSize),
			})
		}
	}
	if err := scanner.Err(); err != nil {
		return meta, nil, err
	}

	if meta.PlayResX == 0 || meta.PlayResY == 0 {
		return meta, nil, errors.New("ASS 文件里没有 PlayResX / PlayResY，可能不是弹幕文件")
	}
	if meta.FontSize == 0 {
		return meta, nil, errors.New("ASS 文件里没找到字幕字号（Style: Danmu）")
	}
	if len(records) == 0 {
		if bad > 0 {
			return meta, nil, fmt.Errorf("ASS 里的 %d 行弹幕都没能解析出来", bad)
		}
		return meta, nil, errNoDanmu
	}

	// 分块渲染要求记录按时间递增，这里统一排一遍
	sort.SliceStable(records, func(i, j int) bool { return records[i].Time < records[j].Time })
	// 文件名前缀就是录制开始的时刻，用它算偏移最稳
	meta.StartTime = nameStartNs(path)
	if bad > 0 {
		lPrintWarnf("%s 里有 %d 行弹幕没能解析出来，已跳过", filepath.Base(path), bad)
	}
	lPrintf("已从 %s 还原出 %d 条弹幕（%dx%d，字号 %d，弹幕到 %s）",
		filepath.Base(path), len(records), meta.PlayResX, meta.PlayResY, meta.FontSize,
		formatSeconds(records[len(records)-1].Time))
	return meta, records, nil
}

// 按本程序的 jsonl 格式写文件（首行是元数据）
func writeJsonlFile(path string, meta danmuMeta, records []danmuRecord) error {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer f.Close()

	w := bufio.NewWriter(f)
	b, err := json.Marshal(meta)
	if err != nil {
		return err
	}
	w.Write(b)
	w.WriteByte('\n')
	for _, r := range records {
		if b, err := json.Marshal(r); err == nil {
			w.Write(b)
			w.WriteByte('\n')
		}
	}
	return w.Flush()
}

// 读取 jsonl 的摘要
func scanJsonlSummary(path string) (jsonlSummary, error) {
	var s jsonlSummary

	f, err := os.Open(path)
	if err != nil {
		return s, err
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
	first := true
	for scanner.Scan() {
		line := scanner.Bytes()
		if len(line) == 0 {
			continue
		}
		if first {
			first = false
			if err := json.Unmarshal(line, &s.meta); err != nil {
				return s, fmt.Errorf("jsonl 的首行不是元数据，文件可能已损坏：%v", err)
			}
			continue
		}
		var r danmuRecord
		if json.Unmarshal(line, &r) != nil || r.Content == "" {
			continue
		}
		if s.count == 0 {
			s.first = r.Time
		}
		s.last = r.Time
		s.count++
		if r.Avatar != "" {
			s.hasAvatar = true
		}
	}
	if err := scanner.Err(); err != nil {
		return s, err
	}
	if s.meta.PlayResX == 0 || s.meta.FontSize == 0 {
		return s, errors.New("jsonl 文件格式不对，首行必须包含 playResX、playResY、fontSize")
	}
	return s, nil
}

// 弹幕文件对应的 jsonl 路径：xxx.ass 和 xxx.nick.ass 都对应 xxx.jsonl
func assSiblingJsonl(path string) string {
	base, low := path, strings.ToLower(path)
	switch {
	case strings.HasSuffix(low, ".nick.ass"):
		base = base[:len(base)-len(".nick.ass")]
	case strings.HasSuffix(low, ".ass"):
		base = base[:len(base)-len(".ass")]
	default:
		return ""
	}
	return base + ".jsonl"
}

// 弹幕文件名去掉扩展名（.nick.ass 也一起去掉），用来拼默认的输出名
func danmuBaseName(path string) string {
	name := filepath.Base(path)
	low := strings.ToLower(name)
	switch {
	case strings.HasSuffix(low, ".nick.ass"):
		return name[:len(name)-len(".nick.ass")]
	case strings.HasSuffix(low, ".ass"), strings.HasSuffix(low, ".jsonl"):
		return name[:len(name)-len(filepath.Ext(name))]
	}
	return name
}