优化视频头尾跳过功能

2026-10-07 13:56:37 +08:00 · 2026-09-23 16:07:28 +08:00
parent 44fde6c5a0
commit 34ccf14cda
26 changed files with 1992 additions and 47 deletions
@@ -0,0 +1,349 @@
+package service
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+
+	"github.com/truewhile/MeBox/internal/helper"
+	"github.com/truewhile/MeBox/internal/model"
+	"github.com/truewhile/MeBox/internal/repository"
+)
+
+// 播放档案里可选的片头/片尾数据来源。
+const (
+	// SegmentSourceAuto 优先用文件内嵌章节（对这个片源最准），没有可用章节时
+	// 回落到 TheIntroDB。
+	SegmentSourceAuto = "auto"
+	// SegmentSourceFFprobe 只用文件内嵌章节。
+	SegmentSourceFFprobe = "ffprobe"
+	// SegmentSourceTheIntroDB 只用社区数据库。它同时是 media_segments.source 的
+	// 取值——两处必须一致，所以直接复用提供方的常量。
+	SegmentSourceTheIntroDB = IntroDBSource
+)
+
+const (
+	// mediaProbeTimeout 是一次后台探测的总预算（含把 strm 目标解析成直链）。
+	mediaProbeTimeout = 90 * time.Second
+	// mediaProbeFailureRetry 是探测失败后允许重新探测的间隔。失败的结果也会落库，
+	// 否则每次播放都会为一个坏源重跑一次。
+	mediaProbeFailureRetry = 6 * time.Hour
+	// mediaProbeErrorLimit 限制落库的错误信息长度（列宽 512 字节，错误里可能
+	// 带 URL，截断同时避免超长）。
+	mediaProbeErrorLimit = 200
+)
+
+// NormalizeSegmentSource 把任意输入收敛到合法取值；未知值一律按 auto 处理
+// （历史档案里这一列可能还是空串）。
+func NormalizeSegmentSource(raw string) string {
+	switch strings.ToLower(strings.TrimSpace(raw)) {
+	case SegmentSourceFFprobe:
+		return SegmentSourceFFprobe
+	case SegmentSourceTheIntroDB:
+		return SegmentSourceTheIntroDB
+	default:
+		return SegmentSourceAuto
+	}
+}
+
+// mediaProber 是 MediaProbeService 需要的探测能力。抽成接口是为了在测试里注入
+// 桩，避免依赖真实 ffprobe 二进制。
+type mediaProber interface {
+	ProbeFull(ctx context.Context, input ProbeInput) (*FullProbeResult, error)
+}
+
+// MediaProbeService 用 ffprobe 提取媒体的完整信息（容器、每路轨道、内嵌章节），
+// 把结果落库缓存，并把章节映射成可跳过的片头/片尾区间。
+//
+// 核心约束：一次探测要 3～4 秒（远端直链更慢，跨洋要跑三次 HTTP 事务），所以
+// 只允许异步跑。播放链路永远只读缓存，拿不到就下次再来——绝不能让一次探测挡在
+// 起播路径上。
+type MediaProbeService struct {
+	log   *zap.Logger
+	repo  *repository.Container
+	probe mediaProber
+	// resolve 把 strm 播放目标解析成最终直链（含绑定 UA 的请求头）。与转码、
+	// 内嵌字幕发现走同一条换链路径，否则会踩到网盘 CDN 的防盗链 403。
+	resolve func(ctx context.Context, raw, userAgent string) (*StrmPlayResult, error)
+
+	mu       sync.Mutex
+	inFlight map[string]struct{}
+}
+
+// NewMediaProbeService is the constructor.
+func NewMediaProbeService(log *zap.Logger, repo *repository.Container, probe *FFprobeService) *MediaProbeService {
+	svc := &MediaProbeService{
+		log:      log,
+		repo:     repo,
+		inFlight: make(map[string]struct{}),
+	}
+	if probe != nil {
+		svc.probe = probe
+	}
+	return svc
+}
+
+// SetPlayTargetResolver injects the strm → direct-link resolver.
+func (s *MediaProbeService) SetPlayTargetResolver(resolve func(ctx context.Context, raw, userAgent string) (*StrmPlayResult, error)) *MediaProbeService {
+	if s != nil {
+		s.resolve = resolve
+	}
+	return s
+}
+
+// EnsureAsync 保证这部媒体的探测已排上队，并立刻返回。
+//
+// 已经有同一条媒体的探测在跑、或服务未配置好时返回 false；这次新排上一条返回
+// true——调用方据此告诉客户端「稍后再拉一次」。
+func (s *MediaProbeService) EnsureAsync(m *model.Media) bool {
+	if s == nil || s.probe == nil || s.repo == nil || m == nil || strings.TrimSpace(m.ID) == "" {
+		return false
+	}
+	if !s.reserve(m.ID) {
+		return false
+	}
+	// 复制一份媒体行：调用方的对象可能属于请求作用域，后台协程不该继续引用它。
+	snapshot := *m
+	helper.Go(s.log, "service.mediaProbe", func() {
+		defer s.release(snapshot.ID)
+		s.run(context.Background(), &snapshot)
+	})
+	return true
+}
+
+func (s *MediaProbeService) reserve(mediaID string) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.inFlight == nil {
+		s.inFlight = make(map[string]struct{})
+	}
+	if _, running := s.inFlight[mediaID]; running {
+		return false
+	}
+	s.inFlight[mediaID] = struct{}{}
+	return true
+}
+
+func (s *MediaProbeService) release(mediaID string) {
+	s.mu.Lock()
+	delete(s.inFlight, mediaID)
+	s.mu.Unlock()
+}
+
+// run 执行一次探测并落库。它跑在后台，没有调用方能接收错误，所以任何失败都只
+// 记录、不外抛。
+func (s *MediaProbeService) run(ctx context.Context, m *model.Media) {
+	ctx, cancel := context.WithTimeout(ctx, mediaProbeTimeout)
+	defer cancel()
+
+	input, err := s.probeInput(ctx, m)
+	if err != nil {
+		s.markFailure(ctx, m.ID, err)
+		return
+	}
+	result, err := s.probe.ProbeFull(ctx, input)
+	if err != nil {
+		s.markFailure(ctx, m.ID, err)
+		return
+	}
+	if err := s.persistProbe(ctx, m, result); err != nil {
+		s.markFailure(ctx, m.ID, err)
+	}
+}
+
+// probeInput 把媒体行解析成 ffprobe 能直接打开的输入。
+//
+// 本地文件给路径；STRM / 云盘先解析成最终直链并带上绑定的请求头——直链与 UA
+// 必须配套，用错会被 CDN 拒绝。
+func (s *MediaProbeService) probeInput(ctx context.Context, m *model.Media) (ProbeInput, error) {
+	if m == nil {
+		return ProbeInput{}, ErrMediaNotFound
+	}
+	if !isStrmMediaRow(m) {
+		if _, err := os.Stat(m.Path); err != nil {
+			return ProbeInput{}, ErrMediaNotFound
+		}
+		return ProbeInput{Source: m.Path}, nil
+	}
+	raw := strings.TrimSpace(m.STRMURL)
+	if raw == "" && strings.HasSuffix(strings.ToLower(strings.TrimSpace(m.Path)), ".strm") {
+		parsed, err := readLocalSTRMTarget(m.Path)
+		if err == nil {
+			raw = strings.TrimSpace(parsed)
+		}
+	}
+	if raw == "" {
+		return ProbeInput{}, errors.New("strm play target missing")
+	}
+	if s.resolve != nil {
+		resolved, err := s.resolve(ctx, raw, "")
+		if err != nil {
+			return ProbeInput{}, err
+		}
+		in, err := transcodeInputFromPlayResult(resolved)
+		if err != nil {
+			return ProbeInput{}, err
+		}
+		return ProbeInput{Source: in.Source, Headers: in.Headers}, nil
+	}
+	if isHTTPPlaybackTarget(raw) {
+		return ProbeInput{Source: raw}, nil
+	}
+	return ProbeInput{}, errors.New("strm probe source unavailable")
+}
+
+// persistProbe 把一次成功的探测落库：先写片段区间，再写探测行。
+//
+// 顺序很重要：探测行是「已经探过」的标记，客户端靠它决定要不要继续轮询。先写
+// 它会让客户端在区间还没落库时就停止等待。
+func (s *MediaProbeService) persistProbe(ctx context.Context, m *model.Media, result *FullProbeResult) error {
+	if s.repo == nil || s.repo.MediaProbe == nil || s.repo.MediaSegment == nil {
+		return errors.New("media probe repository not wired")
+	}
+	rows := chaptersToSegments(result.Chapters)
+	for i := range rows {
+		rows[i].MediaID = m.ID
+		rows[i].SeriesID = m.SeriesID
+	}
+	if err := s.repo.MediaSegment.ReplaceForMedia(ctx, m.ID, SegmentSourceFFprobe, rows); err != nil {
+		return err
+	}
+	payload, err := result.PayloadJSON()
+	if err != nil {
+		return err
+	}
+	row := &model.MediaProbe{
+		MediaID:         m.ID,
+		Signature:       mediaProbeSignature(m),
+		Source:          mediaProbeInputKind(m),
+		Container:       result.Container,
+		DurationSec:     result.DurationSec,
+		BitRate:         result.BitRate,
+		Width:           firstStreamDimension(result, "video", true),
+		Height:          firstStreamDimension(result, "video", false),
+		VideoCodec:      firstStreamCodec(result, "video"),
+		AudioCodec:      firstStreamCodec(result, "audio"),
+		VideoStreams:    len(result.StreamsOfType("video")),
+		AudioStreams:    len(result.StreamsOfType("audio")),
+		SubtitleStreams: len(result.StreamsOfType("subtitle")),
+		ChapterCount:    len(result.Chapters),
+		Payload:         payload,
+		ProbedAt:        time.Now(),
+	}
+	if err := s.repo.MediaProbe.Upsert(ctx, row); err != nil {
+		return err
+	}
+	s.backfillDuration(ctx, m, result.DurationSec)
+	return nil
+}
+
+// backfillDuration 把探测到的时长补进 media.duration_sec。STRM / 云盘媒体在扫描
+// 阶段拿不到时长，而末段区间（end_ms = 0）要靠它才能换算出真实结束时间。
+func (s *MediaProbeService) backfillDuration(ctx context.Context, m *model.Media, durationSec int) {
+	if s.repo == nil || s.repo.DB == nil || m == nil || durationSec <= 0 || m.DurationSec > 0 {
+		return
+	}
+	err := s.repo.DB.WithContext(ctx).Model(&model.Media{}).
+		Where("id = ? AND duration_sec <= 0", m.ID).
+		Update("duration_sec", durationSec).Error
+	if err != nil && s.log != nil {
+		s.log.Debug("backfill probed duration failed", zap.String("media_id", m.ID), zap.Error(err))
+	}
+}
+
+func (s *MediaProbeService) markFailure(ctx context.Context, mediaID string, probeErr error) {
+	if s == nil || s.repo == nil || probeErr == nil {
+		return
+	}
+	message := truncateProbeError(probeErr)
+	if err := s.repo.MediaProbe.MarkFailure(ctx, mediaID, message, time.Now()); err != nil && s.log != nil {
+		s.log.Debug("record media probe failure failed", zap.String("media_id", mediaID), zap.Error(err))
+	}
+	if s.log != nil {
+		s.log.Debug("media probe failed", zap.String("media_id", mediaID), zap.Error(probeErr))
+	}
+}
+
+// truncateProbeError 限制错误信息长度。错误里可能带被拒绝的直链，落库时截断，
+// 避免超长并减少敏感内容。
+func truncateProbeError(err error) string {
+	message := strings.TrimSpace(err.Error())
+	runes := []rune(message)
+	if len(runes) > mediaProbeErrorLimit {
+		return string(runes[:mediaProbeErrorLimit])
+	}
+	return message
+}
+
+// mediaProbeInputKind 记录输入形态，供详情页判断「这个时长是本地读的还是远端读的」。
+func mediaProbeInputKind(m *model.Media) string {
+	if m == nil {
+		return ""
+	}
+	if isStrmMediaRow(m) {
+		return "strm"
+	}
+	return "local"
+}
+
+// mediaProbeSignature 是「探的是哪个文件」的指纹。
+//
+// 本地文件用路径 + 大小 + 修改时间；STRM / 云盘没有本地文件，用固化的播放目标，
+// 且绝不能用解析后的直链（每次签名都不同，缓存会永远失效）。整体做哈希：
+// 既固定长度，也不把路径或 pickcode 再抄一份进数据库。
+func mediaProbeSignature(m *model.Media) string {
+	if m == nil {
+		return ""
+	}
+	var base string
+	if isStrmMediaRow(m) {
+		target := strings.TrimSpace(m.STRMURL)
+		if target == "" {
+			target = strings.TrimSpace(m.Path)
+		}
+		base = "strm|" + target
+	} else if info, err := os.Stat(m.Path); err == nil {
+		base = fmt.Sprintf("local|%s|%d|%d", m.Path, info.Size(), info.ModTime().Unix())
+	} else {
+		base = "local|" + m.Path
+	}
+	sum := sha256.Sum256([]byte(base))
+	return hex.EncodeToString(sum[:16])
+}
+
+func firstStreamCodec(result *FullProbeResult, kind string) string {
+	if result == nil {
+		return ""
+	}
+	for _, stream := range result.Streams {
+		if stream.Type == kind && stream.Codec != "" {
+			return stream.Codec
+		}
+	}
+	return ""
+}
+
+// firstStreamDimension 取第一路指定类型轨道的宽（width=true）或高。
+func firstStreamDimension(result *FullProbeResult, kind string, width bool) int {
+	if result == nil {
+		return 0
+	}
+	for _, stream := range result.Streams {
+		if stream.Type != kind {
+			continue
+		}
+		if width {
+			return stream.Width
+		}
+		return stream.Height
+	}
+	return 0
+}