1
public class PcmBuilder
2
{
3
    private PcmBuilder() { }
4

5
    public float SampleRate { get; set; } = 44100;
6
    public float Frequency { get; set; } = 4000;
7
    public float Amplitude { get; set; } = 1;
8

9
    public PcmBuilder WithSampleRate(long sampleRate)
10
    {
11
        SampleRate = sampleRate;
12
        return this;
13
    }
14

15
    public PcmBuilder WithFrequency(float frequency)
16
    {
17
        Frequency = frequency;
18
        return this;
19
    }
20

21
    public PcmBuilder WithAmplitude(float amplitude)
22
    {
23
        Amplitude = amplitude;
24
        return this;
25
    }
26

27
    public IEnumerable<float> Build()
28
    {
29
        float current = 0;
30
        while (true)
31
        {
32
            yield return MathF.Sin(current / SampleRate * Frequency) * Amplitude;
33

34
            current++;
35
        }
36
    }
37

38
    public static PcmBuilder CreateNew() => new PcmBuilder();
39
}

1
var pcm = PcmBuilder.CreateNew()
2
    .WithSampleRate(44100)
3
    .WithFrequency(8000)
4
    .Build();

1
public unsafe struct WaveHeader
2
{
3
    private fixed byte _chunkId[4];
4
    private uint _chunkSize;
5
    private fixed byte _format[4];
6

7
    private fixed byte _subChunk1Id[4];
8
    private uint _subChunk1Size;
9
    private WaveAudioFormat _audioFormat;
10
    private ushort _numChannels;
11
    private uint _sampleRate;
12
    private uint _byteRate;
13
    private ushort _blockAlign;
14
    private ushort _bitsPerSample;
15

16
    private fixed byte _subChunk2Id[4];
17
    private uint _subChunk2Size;
18

19
    public unsafe string ChunkId
20
    {
21
        get
22
        {
23
            fixed (byte* ptr = _chunkId)
24
            {
25
                return CreateString(ptr, 4);
26
            }
27
        }
28
        set
29
        {
30
            fixed (byte* ptr = _chunkId)
31
            {
32
                FillString(ptr, value, 4);
33
            }
34
        }
35
    }
36

37
    public uint ChunkSize
38
    {
39
        get => _chunkSize;
40
        set => _chunkSize = value;
41
    }
42

43
    public string Format
44
    {
45
        get
46
        {
47
            fixed (byte* ptr = _format)
48
            {
49
                return CreateString(ptr, 4);
50
            }
51
        }
52
        set
53
        {
54
            fixed (byte* ptr = _format)
55
            {
56
                FillString(ptr, value, 4);
57
            }
58
        }
59
    }
60

61
    public string SubChunk1Id
62
    {
63
        get
64
        {
65
            fixed (byte* ptr = _subChunk1Id)
66
            {
67
                return CreateString(ptr, 4);
68
            }
69
        }
70
        set
71
        {
72
            fixed (byte* ptr = _subChunk1Id)
73
            {
74
                FillString(ptr, value, 4);
75
            }
76
        }
77
    }
78

79
    public uint SubChunk1Size
80
    {
81
        get => _subChunk1Size;
82
        set => _subChunk1Size = value;
83
    }
84

85
    public WaveAudioFormat AudioFormat
86
    {
87
        get => _audioFormat;
88
        set => _audioFormat = value;
89
    }
90

91
    public ushort ChannelCount
92
    {
93
        get => _numChannels;
94
        set => _numChannels = value;
95
    }
96

97
    public uint SampleRate
98
    {
99
        get => _sampleRate;
100
        set => _sampleRate = value;
101
    }
102

103
    public uint ByteRate
104
    {
105
        get => _byteRate;
106
        set => _byteRate = value;
107
    }
108

109
    public ushort BlockAlign
110
    {
111
        get => _blockAlign;
112
        set => _blockAlign = value;
113
    }
114

115
    public ushort BitsPerSample
116
    {
117
        get => _bitsPerSample;
118
        set => _bitsPerSample = value;
119
    }
120

121
    public string SubChunk2Id
122
    {
123
        get
124
        {
125
            fixed (byte* ptr = _subChunk2Id)
126
            {
127
                return CreateString(ptr, 4);
128
            }
129
        }
130
        set
131
        {
132
            fixed (byte* ptr = _subChunk2Id)
133
            {
134
                FillString(ptr, value, 4);
135
            }
136
        }
137
    }
138

139
    public uint SubChunk2Size
140
    {
141
        get => _subChunk2Size;
142
        set => _subChunk2Size = value;
143
    }
144

145
    public unsafe static WaveHeader Create(WaveAudioFormat audioFormat, ushort channelCount, uint sampleRate, ushort bitsPerSample, uint pcmDataSize)
146
    {
147
        return new WaveHeader()
148
        {
149
            ChunkId = "RIFF",
150
            ChunkSize = (uint)(pcmDataSize + (sizeof(WaveHeader) - 8)),
151
            Format = "WAVE",
152

153
            SubChunk1Id = "fmt ",
154
            SubChunk1Size = 16,
155
            AudioFormat = audioFormat,
156
            ChannelCount = channelCount,
157
            SampleRate = sampleRate,
158
            ByteRate = sampleRate * channelCount * bitsPerSample / 8,
159
            BlockAlign = (ushort)(channelCount * bitsPerSample / 8),
160
            BitsPerSample = bitsPerSample,
161

162
            SubChunk2Id = "data",
163
            SubChunk2Size = pcmDataSize
164
        };
165
    }
166

167
    private static void FillString(byte* ptr, string value, int maxLength)
168
    {
169
        if (value.Length > maxLength)
170
        {
171
            throw new ArgumentException(nameof(value));
172
        }
173

174
        fixed (char* textPtr = value)
175
        {
176
            for (int i = 0; i < value.Length && i < maxLength; i++)
177
            {
178
                ptr[i] = (byte)textPtr[i];
179
            }
180
        }
181
    }
182

183
    private static string CreateString(byte* ptr, int maxLength)
184
    {
185
        StringBuilder sb = new StringBuilder(maxLength);
186
        for (int i = 0; i < maxLength; i++)
187
        {
188
            if (ptr[i] == 0)
189
            {
190
                break;
191
            }
192

193
            sb.Append((char)ptr[i]);
194
        }
195

196
        return sb.ToString();
197
    }
198
}
199

200
public enum WaveAudioFormat : ushort
201
{
202
    None = 0,
203
    PCM = 1,
204
}

1
var header = WaveHeader.Create(WaveAudioFormat.PCM, 1, 44100, 32, 44100 * 4 * 30);

1
using var output = File.Create("output.wav");
2
using var outputWriter = new BinaryWriter(output);
3

4
var pcm = PcmBuilder.CreateNew()
5
    .WithSampleRate(44100)
6
    .WithFrequency(8000)
7
    .Build();
8

9
var header = WaveHeader.Create(WaveAudioFormat.PCM, 1, 44100, 32, 44100 * 4 * 30);
10

11
// 写入 Header
12
unsafe
13
{
14
    var headerByteSpan = new Span<byte>((byte*)&header, sizeof(WaveHeader));
15
    outputWriter.Write(headerByteSpan);
16
}
17

18
// 获取 PCM 数据迭代器
19
var pcmEnumerator = pcm.GetEnumerator();
20

21
// 向文件写入 PCM
22
for (int i = 0; i < 44100 * 30; i++)
23
{
24
    pcmEnumerator.MoveNext();
25

26
    outputWriter.Write(pcmEnumerator.Current);
27
}