基于NAudio实现MP3淡入淡出切换并推流至Icecast的技术求助

问题背景 #

我们有一个无限MP3列表，每首MP3会在特定时间点开始淡出（每首淡出设置不同），同时下一首MP3启动，短时间内两首音频叠加播放。由于要推流到Icecast服务器，切换过程必须在缓冲区内完成。目前仅从本地磁盘读取两首歌曲测试，后续计划支持任意来源加载音频，但当前实现遇到瓶颈，请求技术帮助。

当前代码存在的核心问题 #

static byte[] buff = new byte[64];
static int read;

static void Main(string[] args)
{
  icecast.Open();

  // to make things easier, first just take two songs out of a List
  Song actualSong = songs2play[0];
  Song nextSong = songs2play[1];

  BinaryReader actualSongReader = new BinaryReader(File.Open(actualSong.Path, FileMode.Open));
  BinaryReader nextSongReader = new BinaryReader(File.Open(nextSong.Path, FileMode.Open));
  
  DateTime start = DateTime.Now;
  while (true)
  {
     TimeSpan howLong = DateTime.Now - start;

     // if the next song starts
     if (howLong.Milliseconds > (actualSong.Length - actualSong.FadeoutStart) && (howLong.Milliseconds < (actualSong.Length - actualSong.FadeoutStart + actualSong.FadeoutLength)))
     {
         read = (actualSongReader.Read(buff, 0, buff.Length)) + nextSongReader.Read(buff, 0, buff.Length);
     }

     // the first song faded away, play only the new song
     else if (howLong.Milliseconds > (actualSong.Length))
     {
         read = nextSongReader.Read(buff, 0, buff.Length);
     }

     // only the first song, thew fade out point was not reached yet
     else
     {
         read = actualSongReader.Read(buff, 0, buff.Length);
     }

     // send buffer to icecast 
     if (read > 0)
     {
         icecast.Send(buff, read);
     }
     else 
       break;
 }


    public class Song
    {
        public string Title;
        public string Artist;
        public int Length;
        public int FadeoutStart;
        public int FadeoutLength;
        public string Path;
    }

这段代码存在以下关键问题：

• 时间判断完全错误：howLong.Milliseconds仅返回TimeSpan的毫秒部分（0-999），而非总播放时长的毫秒数，导致所有时间触发逻辑失效。
• 音频叠加逻辑错误：直接将两首MP3的字节数据写入同一缓冲区是覆盖操作，而非混音。MP3是压缩格式，无法直接字节叠加，会产生杂音。
• 资源泄漏：未使用using语句管理文件流和BinaryReader，会导致系统资源无法释放。
• 无限列表扩展性差：仅硬编码处理两首歌，没有自动加载下一首的队列逻辑。
• 缓冲区过小：64字节的缓冲区会导致推流效率极低，甚至引发断流。
• 时间精度不足：DateTime.Now受系统时间调整影响，播放时长计算不稳定。

解决方案与优化实现 #

核心修复点 #

• 替换高精度计时器：用Stopwatch替代DateTime，通过TotalMilliseconds获取准确的总播放时长。
• 正确实现音频混音：借助音频库（如NAudio）将MP3解码为PCM，对两首歌的PCM数据应用线性音量渐变，混音后重新编码为MP3再推流。
• 资源自动管理：用using语句包裹文件流和音频处理器，避免资源泄漏。
• 构建歌曲队列：设计预加载队列，支持本地/网络等任意来源，自动切换下一首。
• 调整缓冲区大小：使用4096或8192字节的缓冲区提升推流效率。

简化优化代码（基于NAudio） #

using System;
using System.Collections.Generic;
using System.Diagnostics;
using NAudio.Wave;
using NAudio.Lame;

public class Song
{
    public string Title;
    public string Artist;
    public int LengthMs; // 歌曲总时长（毫秒）
    public int FadeoutStartMs; // 淡出开始时间（相对歌曲起始的毫秒数）
    public int FadeoutLengthMs; // 淡出持续时长（毫秒）
    public string Path; // 本地路径或网络流地址
}

public class IcecastAudioStreamer
{
    private Queue<Song> _songQueue;
    private Stopwatch _playbackTimer;
    private MixingWaveProvider32 _audioMixer;
    private VolumeWaveProvider32 _currentTrackProvider;
    private VolumeWaveProvider32 _nextTrackProvider;
    private Song _currentSong;
    private const int BufferSize = 4096;

    public void Start(List<Song> initialSongs)
    {
        _songQueue = new Queue<Song>(initialSongs);
        _playbackTimer = new Stopwatch();

        // 初始化当前曲目和预加载下一曲目
        LoadCurrentTrack();
        LoadNextTrack();

        // 初始化混音器
        _audioMixer = new MixingWaveProvider32();
        _audioMixer.AddInputStream(_currentTrackProvider);

        // 启动Icecast连接（需实现Icecast客户端逻辑）
        // IcecastClient.Open("your-icecast-url", "mount-point", "username", "password");

        _playbackTimer.Start();
        RunStreamingLoop();
    }

    private void LoadCurrentTrack()
    {
        if (_songQueue.Count == 0) throw new InvalidOperationException("无可用曲目");
        _currentSong = _songQueue.Dequeue();
        // 解码MP3为PCM（支持本地文件或网络流）
        var reader = new Mp3FileReader(_currentSong.Path);
        _currentTrackProvider = new VolumeWaveProvider32(reader) { Volume = 1.0f };
    }

    private void LoadNextTrack()
    {
        if (_songQueue.Count == 0) return;
        var nextSong = _songQueue.Peek();
        var reader = new Mp3FileReader(nextSong.Path);
        _nextTrackProvider = new VolumeWaveProvider32(reader) { Volume = 0.0f };
    }

    private void RunStreamingLoop()
    {
        while (true)
        {
            UpdateFadeVolumes();
            SendAudioToIcecast();

            // 完成当前曲目播放，切换到下一曲
            if (_playbackTimer.ElapsedMilliseconds >= _currentSong.LengthMs)
            {
                SwitchToNextTrack();
            }
        }
    }

    private void UpdateFadeVolumes()
    {
        long elapsedMs = _playbackTimer.ElapsedMilliseconds;
        var song = _currentSong;

        // 进入淡出叠加阶段
        if (elapsedMs >= song.FadeoutStartMs && elapsedMs < song.FadeoutStartMs + song.FadeoutLengthMs)
        {
            float fadeProgress = (elapsedMs - song.FadeoutStartMs) / (float)song.FadeoutLengthMs;
            _currentTrackProvider.Volume = 1.0f - fadeProgress;
            _nextTrackProvider.Volume = fadeProgress;

            // 将下一曲加入混音器（首次进入时）
            if (!_audioMixer.Inputs.Contains(_nextTrackProvider))
            {
                _audioMixer.AddInputStream(_nextTrackProvider);
            }
        }
        // 淡出完成，仅保留下一曲
        else if (elapsedMs >= song.LengthMs)
        {
            _currentTrackProvider.Volume = 0.0f;
            _nextTrackProvider.Volume = 1.0f;
        }
    }

    private void SendAudioToIcecast()
    {
        byte[] buffer = new byte[BufferSize];
        int bytesRead = _audioMixer.Read(buffer, 0, buffer.Length);
        if (bytesRead > 0)
        {
            // 将PCM编码为MP3后发送到Icecast
            using (var ms = new System.IO.MemoryStream())
            {
                using (var lame = new LameMP3FileWriter(ms, _audioMixer.WaveFormat, LAMEPreset.STANDARD))
                {
                    lame.Write(buffer, 0, bytesRead);
                }
                // IcecastClient.Send(ms.ToArray());
            }
        }
    }

    private void SwitchToNextTrack()
    {
        _playbackTimer.Restart();
        // 移除当前曲目的输入流
        _audioMixer.RemoveInputStream(_currentTrackProvider);
        // 切换下一曲为当前曲目
        _currentTrackProvider = _nextTrackProvider;
        _currentSong = _songQueue.Dequeue();
        // 预加载新的下一曲
        LoadNextTrack();
    }
}

额外建议 #

1. 依赖音频库：使用NAudio处理音频解码、混音和编码，搭配NAudio.Lame实现MP3编码，简化开发流程。
2. 异步预加载：针对网络来源的音频，采用异步方式预加载，避免阻塞推流主线程。
3. 异常处理：添加文件读取失败、解码错误、Icecast连接中断等异常捕获逻辑，保证推流稳定性。
4. 环形缓冲区：实现环形缓冲区缓存混音后的音频数据，避免因编码或网络延迟导致的卡顿。

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