using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
namespace NewLife.XCoder.Tools.Mel;
/// <summary>WAV 音频数据(已按声道拆分并归一化到 [-1,1])</summary>
/// <param name="SampleRate">采样率(Hz)</param>
/// <param name="Channels">声道数</param>
/// <param name="BitsPerSample">位深</param>
/// <param name="Samples">各声道样本,长度 = 帧数</param>
/// <param name="Frames">帧数(每声道样本数)</param>
public sealed record WavData(Int32 SampleRate, Int32 Channels, Int32 BitsPerSample, Double[][] Samples, Int32 Frames)
{
/// <summary>时长(秒)</summary>
public Double Duration => SampleRate > 0 ? (Double)Frames / SampleRate : 0;
/// <summary>取指定声道;越界时回落到 0 声道</summary>
/// <param name="channel">声道索引</param>
/// <returns>样本数组</returns>
public Double[] GetChannel(Int32 channel)
{
if (Samples.Length == 0) return [];
if (channel < 0 || channel >= Samples.Length) return Samples[0];
return Samples[channel];
}
/// <summary>把多声道混成单声道</summary>
/// <returns>单声道样本</returns>
public Double[] Mixdown()
{
if (Samples.Length == 0) return [];
if (Samples.Length == 1) return Samples[0];
var result = new Double[Frames];
for (var i = 0; i < Frames; i++)
{
var sum = 0d;
foreach (var channel in Samples)
sum += channel[i];
result[i] = sum / Samples.Length;
}
return result;
}
}
/// <summary>梅尔频谱计算</summary>
/// <remarks>
/// 纯托管实现,不依赖 NAudio,因此 Windows / Linux / macOS 行为一致:
/// 1. <see cref="ReadWav(Stream)"/> 解析 RIFF/WAVE(PCM 8/16/24/32 位与 IEEE 单精度浮点);
/// 2. <see cref="Fft"/> 迭代式基 2 快速傅里叶变换;
/// 3. <see cref="MelFilterBank"/> 生成梅尔三角滤波器组;
/// 4. <see cref="Compute"/> 分帧加窗后输出对数梅尔谱,可 <see cref="ToCsv"/> 导出。
/// 只用 BCL 数学函数,帧长必须是 2 的幂。
/// </remarks>
public static class MelSpectrum
{
/// <summary>读取 WAV 文件</summary>
/// <param name="path">文件路径</param>
/// <returns>音频数据</returns>
/// <exception cref="InvalidDataException">文件不是合法的 WAV 或使用了不支持的编码</exception>
public static WavData ReadWav(String path)
{
using var stream = File.OpenRead(path);
return ReadWav(stream);
}
/// <summary>从流读取 WAV</summary>
/// <param name="stream">WAV 数据流</param>
/// <returns>音频数据</returns>
/// <exception cref="InvalidDataException">不是合法的 WAV 或使用了不支持的编码</exception>
public static WavData ReadWav(Stream stream)
{
if (stream == null) throw new ArgumentNullException(nameof(stream));
using var reader = new BinaryReader(stream, Encoding.ASCII, true);
var riff = new String(reader.ReadChars(4));
if (riff != "RIFF") throw new InvalidDataException($"不是 RIFF 文件:{riff}");
reader.ReadInt32(); // 文件长度,跳过
var wave = new String(reader.ReadChars(4));
if (wave != "WAVE") throw new InvalidDataException($"不是 WAVE 文件:{wave}");
var format = 0;
var channels = 0;
var sampleRate = 0;
var bits = 0;
Byte[]? data = null;
while (stream.Position + 8 <= stream.Length)
{
var id = new String(reader.ReadChars(4));
var size = reader.ReadInt32();
if (size < 0) break;
var next = stream.Position + size + (size % 2);
if (id == "fmt ")
{
format = reader.ReadInt16();
channels = reader.ReadInt16();
sampleRate = reader.ReadInt32();
reader.ReadInt32(); // byte rate
reader.ReadInt16(); // block align
bits = reader.ReadInt16();
// WAVE_FORMAT_EXTENSIBLE:真正的格式在子格式 GUID 前两字节
if (format == 0xFFFE && size >= 40)
{
reader.ReadInt16(); // cbSize
reader.ReadInt16(); // valid bits
reader.ReadInt32(); // channel mask
format = reader.ReadInt16();
}
}
else if (id == "data")
{
if (size <= 0 || size > Int32.MaxValue) break;
var buffer = new Byte[size];
var read = 0;
while (read < size)
{
var n = reader.Read(buffer, read, size - read);
if (n <= 0) break;
read += n;
}
data = buffer;
if (read < size) Array.Resize(ref data, read);
}
else if (id == "LIST" || id == "fact" || id == "cue ")
{
// 无关块直接跳过
}
if (next > stream.Length) break;
stream.Position = next;
}
if (channels <= 0 || sampleRate <= 0) throw new InvalidDataException("缺少 fmt 块或参数非法");
if (data == null || data.Length == 0) throw new InvalidDataException("缺少 data 块");
// audioFormat 1 = PCM,3 = IEEE 浮点
if (format != 1 && format != 3) throw new InvalidDataException($"不支持的音频编码:{format}");
var samples = Decode(data, channels, bits, format);
var frames = samples.Length > 0 ? samples[0].Length : 0;
return new WavData(sampleRate, channels, bits, samples, frames);
}
/// <summary>把 16 位 PCM 样本写成最小 WAV 字节流(用于自测与导出)</summary>
/// <param name="samples">单声道 16 位样本</param>
/// <param name="sampleRate">采样率</param>
/// <returns>完整 WAV 字节</returns>
public static Byte[] WriteWav(Int16[] samples, Int32 sampleRate = 16000)
{
if (samples == null) throw new ArgumentNullException(nameof(samples));
using var ms = new MemoryStream();
using var writer = new BinaryWriter(ms, Encoding.ASCII, true);
var dataSize = samples.Length * 2;
writer.Write(Encoding.ASCII.GetBytes("RIFF"));
writer.Write(36 + dataSize);
writer.Write(Encoding.ASCII.GetBytes("WAVE"));
writer.Write(Encoding.ASCII.GetBytes("fmt "));
writer.Write(16);
writer.Write((Int16)1); // PCM
writer.Write((Int16)1); // 单声道
writer.Write(sampleRate);
writer.Write(sampleRate * 2); // byte rate
writer.Write((Int16)2); // block align
writer.Write((Int16)16); // 位深
writer.Write(Encoding.ASCII.GetBytes("data"));
writer.Write(dataSize);
foreach (var item in samples) writer.Write(item);
writer.Flush();
return ms.ToArray();
}
/// <summary>生成等幅正弦波(用于频谱自测)</summary>
/// <param name="frequency">频率(Hz)</param>
/// <param name="sampleRate">采样率</param>
/// <param name="seconds">时长(秒)</param>
/// <param name="amplitude">幅度(0~1)</param>
/// <returns>归一化样本</returns>
public static Double[] Sine(Double frequency, Int32 sampleRate, Double seconds, Double amplitude = 0.5)
{
var count = (Int32)(sampleRate * seconds);
var result = new Double[count];
for (var i = 0; i < count; i++)
result[i] = amplitude * Math.Sin(2 * Math.PI * frequency * i / sampleRate);
return result;
}
/// <summary>就地计算复数快速傅里叶变换(长度必须是 2 的幂)</summary>
/// <param name="real">实部,长度须为 2 的幂</param>
/// <param name="imag">虚部,与实部等长</param>
/// <exception cref="ArgumentException">长度不是 2 的幂</exception>
public static void Fft(Double[] real, Double[] imag)
{
if (real == null) throw new ArgumentNullException(nameof(real));
if (imag == null) throw new ArgumentNullException(nameof(imag));
if (real.Length != imag.Length) throw new ArgumentException("实部与虚部长度必须一致");
if (real.Length == 0) return;
var n = real.Length;
if ((n & (n - 1)) != 0) throw new ArgumentException($"FFT 长度必须是 2 的幂:{n}");
// 位反转置换
for (Int32 i = 1, j = 0; i < n; i++)
{
var bit = n >> 1;
for (; (j & bit) != 0; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j)
{
(real[i], real[j]) = (real[j], real[i]);
(imag[i], imag[j]) = (imag[j], imag[i]);
}
}
for (var len = 2; len <= n; len <<= 1)
{
var angle = -2 * Math.PI / len;
var wReal = Math.Cos(angle);
var wImag = Math.Sin(angle);
for (var i = 0; i < n; i += len)
{
var curReal = 1d;
var curImag = 0d;
for (var k = 0; k < len / 2; k++)
{
var uReal = real[i + k];
var uImag = imag[i + k];
var vReal = real[i + k + len / 2] * curReal - imag[i + k + len / 2] * curImag;
var vImag = real[i + k + len / 2] * curImag + imag[i + k + len / 2] * curReal;
real[i + k] = uReal + vReal;
imag[i + k] = uImag + vImag;
real[i + k + len / 2] = uReal - vReal;
imag[i + k + len / 2] = uImag - vImag;
var nextReal = curReal * wReal - curImag * wImag;
curImag = curReal * wImag + curImag * wReal;
curReal = nextReal;
}
}
}
}
/// <summary>计算单帧幅度谱(只取前一半,长度 = 帧长/2)</summary>
/// <param name="frame">时域样本,长度须为 2 的幂</param>
/// <returns>各频点幅度</returns>
public static Double[] Magnitude(Double[] frame)
{
if (frame == null) throw new ArgumentNullException(nameof(frame));
var n = frame.Length;
var real = new Double[n];
var imag = new Double[n];
// Hann 窗,减少频谱泄漏
for (var i = 0; i < n; i++)
real[i] = frame[i] * (0.5 - 0.5 * Math.Cos(2 * Math.PI * i / (n - 1 > 0 ? n - 1 : 1)));
Fft(real, imag);
var half = n / 2;
var result = new Double[half];
for (var i = 0; i < half; i++)
result[i] = Math.Sqrt(real[i] * real[i] + imag[i] * imag[i]) / half;
return result;
}
/// <summary>把频率换算为梅尔刻度</summary>
/// <param name="hz">频率(Hz)</param>
/// <returns>梅尔值</returns>
public static Double HzToMel(Double hz) => 2595 * Math.Log10(1 + hz / 700);
/// <summary>把梅尔刻度换算回频率</summary>
/// <param name="mel">梅尔值</param>
/// <returns>频率(Hz)</returns>
public static Double MelToHz(Double mel) => 700 * (Math.Pow(10, mel / 2595) - 1);
/// <summary>生成梅尔三角滤波器组</summary>
/// <param name="sampleRate">采样率</param>
/// <param name="fftSize">帧长(决定频点数量)</param>
/// <param name="bins">滤波器个数</param>
/// <param name="minHz">最低频率,默认 20Hz,忽略直流</param>
/// <param name="maxHz">最高频率,默认采样率的一半</param>
/// <returns>每个滤波器在各频点的权重,行数 = bins,列数 = fftSize/2</returns>
public static Double[][] MelFilterBank(Int32 sampleRate, Int32 fftSize, Int32 bins = 40, Double minHz = 20, Double maxHz = 0)
{
if (sampleRate <= 0) throw new ArgumentOutOfRangeException(nameof(sampleRate));
if (bins <= 0) throw new ArgumentOutOfRangeException(nameof(bins));
var half = fftSize / 2;
if (maxHz <= 0 || maxHz > sampleRate / 2.0) maxHz = sampleRate / 2.0;
if (minHz < 0) minHz = 0;
if (minHz >= maxHz) throw new ArgumentOutOfRangeException(nameof(minHz), "最低频率必须小于最高频率");
var melMin = HzToMel(minHz);
var melMax = HzToMel(maxHz);
// bins + 2 个边界点,相邻三点构成一个三角
var points = new Double[bins + 2];
var hzPoints = new Double[bins + 2];
for (var i = 0; i < points.Length; i++)
{
points[i] = melMin + (melMax - melMin) * i / (points.Length - 1);
hzPoints[i] = MelToHz(points[i]);
}
var bank = new Double[bins][];
for (var m = 0; m < bins; m++)
{
bank[m] = new Double[half];
var left = hzPoints[m];
var center = hzPoints[m + 1];
var right = hzPoints[m + 2];
for (var k = 0; k < half; k++)
{
var hz = (Double)k * sampleRate / fftSize;
if (hz <= left || hz >= right) continue;
bank[m][k] = hz <= center
? (hz - left) / (center - left)
: (right - hz) / (right - center);
}
}
return bank;
}
/// <summary>计算对数梅尔谱</summary>
/// <param name="samples">单声道归一化样本</param>
/// <param name="sampleRate">采样率</param>
/// <param name="frameSize">帧长(2 的幂),默认 512</param>
/// <param name="hopSize">帧移,默认帧长的一半</param>
/// <param name="bins">梅尔滤波器个数</param>
/// <returns>行 = 帧,列 = 梅尔频带的对数值</returns>
public static Double[][] Compute(Double[] samples, Int32 sampleRate, Int32 frameSize = 512, Int32 hopSize = 0, Int32 bins = 40)
{
if (samples == null) throw new ArgumentNullException(nameof(samples));
if (frameSize <= 0 || (frameSize & (frameSize - 1)) != 0) throw new ArgumentException($"帧长必须是 2 的幂:{frameSize}");
if (hopSize <= 0) hopSize = frameSize / 2;
var bank = MelFilterBank(sampleRate, frameSize, bins);
var count = samples.Length <= frameSize ? 1 : 1 + (samples.Length - frameSize) / hopSize;
var result = new Double[count][];
var frame = new Double[frameSize];
for (var f = 0; f < count; f++)
{
var start = f * hopSize;
for (var i = 0; i < frameSize; i++)
{
var index = start + i;
frame[i] = index < samples.Length ? samples[index] : 0;
}
var mag = Magnitude(frame);
var row = new Double[bins];
for (var m = 0; m < bins; m++)
{
var sum = 0d;
var weights = bank[m];
for (var k = 0; k < mag.Length; k++)
sum += mag[k] * weights[k];
// 取对数,加小量避免 log(0)
row[m] = Math.Log(sum + 1e-10);
}
result[f] = row;
}
return result;
}
/// <summary>计算音量曲线(每段 RMS 转分贝)</summary>
/// <param name="samples">归一化样本</param>
/// <param name="sampleRate">采样率</param>
/// <param name="perSecond">每秒取多少个点,默认 20</param>
/// <returns>分贝值清单</returns>
public static Double[] VolumeCurve(Double[] samples, Int32 sampleRate, Int32 perSecond = 20)
{
if (samples == null) throw new ArgumentNullException(nameof(samples));
if (perSecond <= 0) throw new ArgumentOutOfRangeException(nameof(perSecond));
if (samples.Length == 0 || sampleRate <= 0) return [];
var step = Math.Max(1, sampleRate / perSecond);
var count = (samples.Length + step - 1) / step;
var result = new Double[count];
for (var i = 0; i < count; i++)
{
var start = i * step;
var end = Math.Min(start + step, samples.Length);
var sum = 0d;
for (var k = start; k < end; k++)
sum += samples[k] * samples[k];
var rms = Math.Sqrt(sum / Math.Max(1, end - start));
result[i] = 20 * Math.Log10(rms + 1e-10);
}
return result;
}
/// <summary>把梅尔谱导出为 CSV 文本</summary>
/// <param name="mel"><see cref="Compute"/> 的结果</param>
/// <returns>CSV 文本,首列为帧号,其余为各频带对数值</returns>
public static String ToCsv(Double[][] mel)
{
if (mel == null || mel.Length == 0) return "";
var sb = new StringBuilder();
sb.Append("frame");
for (var i = 0; i < mel[0].Length; i++)
sb.Append(",mel").Append(i);
sb.AppendLine();
for (var f = 0; f < mel.Length; f++)
{
sb.Append(f.ToString(CultureInfo.InvariantCulture));
foreach (var value in mel[f])
sb.Append(',').Append(value.ToString("F4", CultureInfo.InvariantCulture));
sb.AppendLine();
}
return sb.ToString();
}
#region 辅助
private static Double[][] Decode(Byte[] data, Int32 channels, Int32 bits, Int32 format)
{
var bytesPerSample = bits / 8;
if (bytesPerSample <= 0) throw new InvalidDataException($"位深非法:{bits}");
var frames = data.Length / (bytesPerSample * channels);
var result = new Double[channels][];
for (var c = 0; c < channels; c++) result[c] = new Double[frames];
var offset = 0;
for (var f = 0; f < frames; f++)
{
for (var c = 0; c < channels; c++)
{
result[c][f] = ReadSample(data, offset, bits, format);
offset += bytesPerSample;
}
}
return result;
}
private static Double ReadSample(Byte[] data, Int32 offset, Int32 bits, Int32 format)
{
if (format == 3)
{
// IEEE 单精度 / 双精度浮点
if (bits == 32) return BitConverter.ToSingle(data, offset);
if (bits == 64) return BitConverter.ToDouble(data, offset);
throw new InvalidDataException($"不支持的浮点位深:{bits}");
}
return bits switch
{
8 => (data[offset] - 128) / 128d,
16 => BitConverter.ToInt16(data, offset) / 32768d,
24 => Read24(data, offset) / 8388608d,
32 => BitConverter.ToInt32(data, offset) / 2147483648d,
_ => throw new InvalidDataException($"不支持的位深:{bits}"),
};
}
private static Int32 Read24(Byte[] data, Int32 offset)
{
var value = data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
// 符号扩展
if ((value & 0x800000) != 0) value |= unchecked((Int32)0xFF000000);
return value;
}
#endregion
}
|