借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
18.84 KiB
XCoder
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
}