227 lines
8.0 KiB
Go
227 lines
8.0 KiB
Go
package app
|
||
|
||
import (
|
||
"bufio"
|
||
"context"
|
||
"fmt"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
type mergeMediaInfo struct {
|
||
signature string
|
||
width int
|
||
height int
|
||
audio bool
|
||
duration time.Duration
|
||
}
|
||
|
||
func probeMergeMedia(ctx context.Context, ffmpeg, path string) (mergeMediaInfo, error) {
|
||
probeCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
|
||
defer cancel()
|
||
command := exec.CommandContext(probeCtx, ffmpeg, "-hide_banner", "-nostdin", "-loglevel", "info",
|
||
"-protocol_whitelist", "file,pipe", "-i", path, "-map", "0:v:0", "-map", "0:a:0?",
|
||
"-c", "copy", "-t", "0", "-f", "framehash", "-hash", "sha256", "pipe:1")
|
||
output := &cappedStringWriter{limit: 64 * 1024}
|
||
diagnostics := &cappedStringWriter{limit: 64 * 1024}
|
||
command.Stdout, command.Stderr = output, diagnostics
|
||
if err := command.Run(); err != nil {
|
||
if probeCtx.Err() != nil {
|
||
return mergeMediaInfo{}, probeCtx.Err()
|
||
}
|
||
return mergeMediaInfo{}, fmt.Errorf("检测 %s 失败：%w %s", filepath.Base(path), err, truncate(diagnostics.String(), 1000))
|
||
}
|
||
var info mergeMediaInfo
|
||
var signature []string
|
||
for _, line := range strings.Split(output.String(), "\n") {
|
||
line = strings.TrimSpace(line)
|
||
for _, prefix := range []string{"#extradata ", "#tb ", "#media_type ", "#codec_id ", "#dimensions ", "#sar ", "#sample_rate ", "#channel_layout"} {
|
||
if strings.HasPrefix(line, prefix) {
|
||
signature = append(signature, line)
|
||
break
|
||
}
|
||
}
|
||
if strings.HasPrefix(line, "#dimensions 0:") {
|
||
_, _ = fmt.Sscanf(strings.TrimSpace(strings.TrimPrefix(line, "#dimensions 0:")), "%dx%d", &info.width, &info.height)
|
||
}
|
||
if line == "#media_type 1: audio" {
|
||
info.audio = true
|
||
}
|
||
}
|
||
if match := playbackDurationPattern.FindStringSubmatch(diagnostics.String()); len(match) == 4 {
|
||
hours, _ := strconv.ParseFloat(match[1], 64)
|
||
minutes, _ := strconv.ParseFloat(match[2], 64)
|
||
seconds, _ := strconv.ParseFloat(match[3], 64)
|
||
info.duration = time.Duration((hours*3600 + minutes*60 + seconds) * float64(time.Second))
|
||
}
|
||
if info.width <= 0 || info.height <= 0 || info.duration <= 0 {
|
||
return mergeMediaInfo{}, fmt.Errorf("%s 缺少有效的视频尺寸或时长，无法安全合并", filepath.Base(path))
|
||
}
|
||
info.signature = strings.Join(signature, "\n")
|
||
return info, nil
|
||
}
|
||
|
||
func runMergeFFmpeg(ctx context.Context, ffmpeg string, args []string, progress func(time.Duration)) error {
|
||
command := exec.CommandContext(ctx, ffmpeg, append([]string{
|
||
"-hide_banner", "-nostdin", "-nostats", "-loglevel", "error", "-progress", "pipe:1",
|
||
}, args...)...)
|
||
diagnostics := &cappedStringWriter{limit: 64 * 1024}
|
||
command.Stderr = diagnostics
|
||
output, err := command.StdoutPipe()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer output.Close()
|
||
if err := command.Start(); err != nil {
|
||
return err
|
||
}
|
||
scanner := bufio.NewScanner(output)
|
||
for scanner.Scan() {
|
||
key, value, ok := strings.Cut(scanner.Text(), "=")
|
||
if ok && key == "out_time_us" && progress != nil {
|
||
if micros, err := strconv.ParseInt(strings.TrimSpace(value), 10, 64); err == nil && micros >= 0 {
|
||
progress(time.Duration(micros) * time.Microsecond)
|
||
}
|
||
}
|
||
}
|
||
err = command.Wait()
|
||
if ctx.Err() != nil {
|
||
return ctx.Err()
|
||
}
|
||
if err != nil {
|
||
return fmt.Errorf("FFmpeg 处理失败：%w %s", err, truncate(diagnostics.String(), 1500))
|
||
}
|
||
return scanner.Err()
|
||
}
|
||
|
||
func normalizedMergeArgs(input, output string, info mergeMediaInfo, width, height int, audio bool) []string {
|
||
args := []string{"-xerror", "-threads", "2", "-protocol_whitelist", "file,pipe", "-i", input}
|
||
if audio && !info.audio {
|
||
args = append(args, "-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=48000")
|
||
}
|
||
args = append(args, "-map", "0:v:0")
|
||
if audio {
|
||
audioInput := "0:a:0"
|
||
if !info.audio {
|
||
audioInput = "1:a:0"
|
||
}
|
||
args = append(args, "-map", audioInput, "-c:a", "aac", "-b:a", "128k", "-ar", "48000", "-ac", "2",
|
||
"-af", "aresample=48000:async=1:first_pts=0,apad", "-shortest")
|
||
} else {
|
||
args = append(args, "-an")
|
||
}
|
||
filter := fmt.Sprintf("setpts=PTS-STARTPTS,fps=30,scale=%d:%d:force_original_aspect_ratio=decrease:force_divisible_by=2,pad=%d:%d:(ow-iw)/2:(oh-ih)/2,setsar=1", width, height, width, height)
|
||
return append(args, "-sn", "-dn", "-map_metadata", "-1", "-vf", filter,
|
||
"-c:v", "libx264", "-preset", "veryfast", "-crf", "18", "-profile:v", "high", "-pix_fmt", "yuv420p",
|
||
"-threads:v", "2", "-g", "60", "-sc_threshold", "0", "-video_track_timescale", "90000",
|
||
"-max_muxing_queue_size", "4096", "-t", strconv.FormatFloat(info.duration.Seconds(), 'f', 6, 64), "-f", "mp4", "-y", output)
|
||
}
|
||
|
||
func mergeMediaFiles(ctx context.Context, ffmpeg string, paths []string, output string, report func(int, string)) (string, error) {
|
||
if len(paths) == 0 {
|
||
return "", fmt.Errorf("没有可合并的分集")
|
||
}
|
||
lastProgress, lastDetail := -1, ""
|
||
notify := func(progress int, detail string) {
|
||
if progress > 99 {
|
||
progress = 99
|
||
}
|
||
if progress < lastProgress {
|
||
progress = lastProgress
|
||
}
|
||
if report != nil && (progress != lastProgress || detail != lastDetail) {
|
||
report(progress, detail)
|
||
}
|
||
lastProgress, lastDetail = progress, detail
|
||
}
|
||
metadata := make([]mergeMediaInfo, 0, len(paths))
|
||
var duration time.Duration
|
||
var width, height int
|
||
var audio, normalize bool
|
||
for index, path := range paths {
|
||
notify(index*5/len(paths), fmt.Sprintf("检测分集编码 %d/%d", index+1, len(paths)))
|
||
info, err := probeMergeMedia(ctx, ffmpeg, path)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if index > 0 && info.signature != metadata[0].signature {
|
||
normalize = true
|
||
}
|
||
metadata = append(metadata, info)
|
||
duration += info.duration
|
||
if info.width > width {
|
||
width = info.width
|
||
}
|
||
if info.height > height {
|
||
height = info.height
|
||
}
|
||
audio = audio || info.audio
|
||
}
|
||
work, err := os.MkdirTemp(filepath.Dir(output), ".merge-*")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
defer os.RemoveAll(work)
|
||
inputs := append([]string(nil), paths...)
|
||
method, start := "原编码快速合并", 5
|
||
if normalize {
|
||
method, start = "兼容合并（H.264 / AAC）", 95
|
||
width += width % 2
|
||
height += height % 2
|
||
var processed time.Duration
|
||
for index, path := range paths {
|
||
detail := fmt.Sprintf("编码不一致，统一格式 %d/%d", index+1, len(paths))
|
||
notify(5+int(processed*90/duration), detail)
|
||
temporary := filepath.Join(work, fmt.Sprintf("%06d.mp4", index+1))
|
||
err := runMergeFFmpeg(ctx, ffmpeg, normalizedMergeArgs(path, temporary, metadata[index], width, height, audio), func(elapsed time.Duration) {
|
||
if elapsed > metadata[index].duration {
|
||
elapsed = metadata[index].duration
|
||
}
|
||
notify(5+int((processed+elapsed)*90/duration), detail)
|
||
})
|
||
if err != nil {
|
||
return "", fmt.Errorf("转换 %s 失败：%w；原分集已保留", filepath.Base(path), err)
|
||
}
|
||
processed += metadata[index].duration
|
||
inputs[index] = temporary
|
||
}
|
||
}
|
||
var manifest strings.Builder
|
||
for _, path := range inputs {
|
||
absolute, err := filepath.Abs(path)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
fmt.Fprintf(&manifest, "file '%s'\n", strings.ReplaceAll(filepath.ToSlash(absolute), "'", "'\\''"))
|
||
}
|
||
list := filepath.Join(work, "inputs.ffconcat")
|
||
if err := os.WriteFile(list, []byte(manifest.String()), 0600); err != nil {
|
||
return "", err
|
||
}
|
||
notify(start, method)
|
||
err = runMergeFFmpeg(ctx, ffmpeg, []string{"-protocol_whitelist", "file,pipe", "-f", "concat", "-safe", "0", "-i", list,
|
||
"-map", "0:v:0", "-map", "0:a:0?", "-sn", "-dn", "-c", "copy", "-movflags", "+faststart", "-y", output}, func(elapsed time.Duration) {
|
||
notify(start+int(elapsed*time.Duration(99-start)/duration), method)
|
||
})
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
notify(99, "核对合并文件时长")
|
||
merged, err := probeMergeMedia(ctx, ffmpeg, output)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
tolerance := duration / 100
|
||
if tolerance < 2*time.Second {
|
||
tolerance = 2 * time.Second
|
||
}
|
||
if merged.duration < duration-tolerance || merged.duration > duration+tolerance {
|
||
return "", fmt.Errorf("合并文件时长不符（预计 %.1f 秒，实际 %.1f 秒），原分集已保留", duration.Seconds(), merged.duration.Seconds())
|
||
}
|
||
return method, nil
|
||
}
|