一、FFmpeg 正确配置方案（直接解决问题） #

你之前用FFmpeg失败的核心原因是没配置可续播的MP3输出参数和无缝循环逻辑，以下是可行的命令和脚本：

1. 前置准备：统一所有MP3的音频参数 #

无缝切换要求音频格式完全一致（采样率、比特率、声道），先批量转码：

for file in *.mp3; do
  ffmpeg -i "$file" -c:a libmp3lame -b:a 128k -ar 44100 -ac 2 -y "normalized_$file"
done

2. 持续随机播放并写入可续播的MP3文件 #

用bash脚本循环随机选取转码后的MP3，追加写入目标文件（关键参数保证文件可被播放器识别并续播）：

TARGET_FILE="local_radio.mp3"
# 初始化目标文件（写入空的MP3头）
ffmpeg -f lavfi -i anullsrc=r=44100:cl=2 -t 0.1 -c:a libmp3lame -b:a 128k -write_xing 1 -id3v2_version 3 -y "$TARGET_FILE"

while true; do
  # 随机选一个转码后的MP3
  RANDOM_FILE=$(ls normalized_*.mp3 | shuf -n1)
  # 追加音频到目标文件，保持参数一致，更新索引
  ffmpeg -i "$TARGET_FILE" -i "$RANDOM_FILE" -filter_complex "[0:a][1:a]concat=n=2:v=0:a=1[a]" -map "[a]" -c:a libmp3lame -b:a 128k -ar 44100 -ac 2 -write_xing 1 -id3v2_version 3 -y "$TARGET_FILE.tmp"
  mv "$TARGET_FILE.tmp" "$TARGET_FILE"
done

3. 访问方式 #

• 本地文件访问：直接用播放器打开 file:///PATH_TO/local_radio.mp3
• HTTP访问：用Python起一个简单的HTTP服务器，把目标文件所在目录设为根目录：

python3 -m http.server 8000

然后访问 http://localhost:8000/local_radio.mp3，播放器会持续读取新写入的内容。

续播原理 #

• -write_xing 1 和 -id3v2_version 3 会写入MP3的索引信息，播放器能识别文件的实时长度和帧位置
• 每次循环用concat滤镜合并旧文件和新音频，替换原文件，保证播放器重启后读取的是最新的完整文件，能直接从末尾开始播放

二、Python 代码实现方案（更灵活） #

用 ffmpeg-python 和 mutagen 库实现，支持更复杂的随机逻辑和错误处理：

1. 安装依赖 #

pip install ffmpeg-python mutagen

2. 代码实现 #

import os
import random
import ffmpeg
from mutagen.mp3 import MP3

TARGET_FILE = "local_radio.mp3"
NORMALIZED_DIR = "normalized_mp3"

def normalize_mp3(input_path, output_path):
    """统一MP3参数"""
    ffmpeg.input(input_path).output(
        output_path,
        acodec="libmp3lame",
        b="128k",
        ar=44100,
        ac=2
    ).run(overwrite_output=True)

def init_target_file():
    """初始化目标MP3文件"""
    ffmpeg.input("anullsrc=r=44100:cl=2", f="lavfi").output(
        TARGET_FILE,
        acodec="libmp3lame",
        b="128k",
        write_xing=1,
        id3v2_version=3,
        t=0.1
    ).run(overwrite_output=True)

def append_audio_to_target(source_file):
    """追加音频到目标文件"""
    temp_file = f"{TARGET_FILE}.tmp"
    # 合并旧文件和新音频
    input1 = ffmpeg.input(TARGET_FILE)
    input2 = ffmpeg.input(source_file)
    ffmpeg.concat(input1, input2, v=0, a=1).output(
        temp_file,
        acodec="libmp3lame",
        b="128k",
        ar=44100,
        ac=2,
        write_xing=1,
        id3v2_version=3
    ).run(overwrite_output=True)
    # 替换原文件
    os.replace(temp_file, TARGET_FILE)

if __name__ == "__main__":
    # 创建归一化目录
    os.makedirs(NORMALIZED_DIR, exist_ok=True)
    # 批量归一化MP3
    for file in os.listdir("."):
        if file.endswith(".mp3") and not file.startswith("normalized_") and file != TARGET_FILE:
            normalize_mp3(file, os.path.join(NORMALIZED_DIR, file))
    # 初始化目标文件
    init_target_file()
    # 循环随机播放
    normalized_files = [os.path.join(NORMALIZED_DIR, f) for f in os.listdir(NORMALIZED_DIR) if f.endswith(".mp3")]
    while True:
        if not normalized_files:
            break
        random_file = random.choice(normalized_files)
        append_audio_to_target(random_file)

三、C# 实现方案（基于NAudio） #

用NAudio库直接操作MP3帧，实现无缝拼接和持续写入：

1. 安装NuGet包 #

Install-Package NAudio
Install-Package NAudio.Lame

2. 核心代码示例 #

using System;
using System.IO;
using System.Linq;
using System.Threading;
using NAudio.Wave;
using NAudio.Lame;

class LocalRadio
{
    static string TargetFilePath = "local_radio.mp3";
    static string NormalizedDir = "normalized_mp3";
    static WaveFormat TargetFormat = new WaveFormat(44100, 2, 16);

    static void Main(string[] args)
    {
        // 创建归一化目录
        Directory.CreateDirectory(NormalizedDir);
        // 批量归一化MP3
        NormalizeAllMp3();
        // 初始化目标文件
        InitTargetFile();
        // 循环随机播放
        var normalizedFiles = Directory.GetFiles(NormalizedDir, "*.mp3").ToList();
        while (normalizedFiles.Any())
        {
            var randomFile = normalizedFiles[new Random().Next(normalizedFiles.Count)];
            AppendAudioToTarget(randomFile);
            Thread.Sleep(100); // 避免文件占用冲突
        }
    }

    static void NormalizeAllMp3()
    {
        foreach (var file in Directory.GetFiles(".", "*.mp3"))
        {
            if (Path.GetFileName(file).StartsWith("normalized_") || file == TargetFilePath)
                continue;
            using (var reader = new Mp3FileReader(file))
            using (var writer = new LameMP3FileWriter(
                Path.Combine(NormalizedDir, Path.GetFileName(file)),
                TargetFormat,
                128))
            {
                reader.CopyTo(writer);
            }
        }
    }

    static void InitTargetFile()
    {
        using (var writer = new LameMP3FileWriter(
            TargetFilePath,
            TargetFormat,
            128))
        {
            // 写入空帧初始化文件
            var emptyBuffer = new byte[TargetFormat.AverageBytesPerSecond / 10];
            writer.Write(emptyBuffer, 0, emptyBuffer.Length);
        }
    }

    static void AppendAudioToTarget(string sourceFile)
    {
        var tempFile = $"{TargetFilePath}.tmp";
        // 合并旧文件和新音频
        using (var targetReader = new Mp3FileReader(TargetFilePath))
        using (var sourceReader = new Mp3FileReader(sourceFile))
        using (var writer = new LameMP3FileWriter(
            tempFile,
            TargetFormat,
            128))
        {
            targetReader.CopyTo(writer);
            sourceReader.CopyTo(writer);
        }
        // 替换原文件
        File.Delete(TargetFilePath);
        File.Move(tempFile, TargetFilePath);
    }
}

关键原理总结 #

1. 无缝切换：必须保证所有输入MP3的采样率、比特率、声道完全一致，否则拼接时会出现卡顿或爆音
2. 续播支持：目标MP3文件必须包含XING或ID3v2索引，播放器才能识别文件的实时长度和播放位置，重启后直接从文件末尾开始播放
3. 本地访问：无论是直接打开文件还是通过HTTP服务器，播放器都会持续读取文件的新增内容，类似实时流

内容的提问来源于stack exchange，提问作者SystemSearcher