使用Go播放音频：合成波形

原文地址：https://dylanmeeus.github.io/posts/audio-from-scratch-pt8/

在之前的文章中我们首先研究了如何用“原始”浮点数生成正弦波并使用ffplay对其进行解析。后来，我们探讨了如何读取/写入.wave文件以及如何使用断点提取以及创建“自动化轨道”。

你可能已经注意到，我们从未真正使用自己的声音数据从头开始创建.wave文件。现在该改变它了。在此文中，我们将研究如何创建各种基本声波。

本文的代码可以在Github示例中找到，也可以作为GoAudio库的一部分找到。

构造一个振荡器

振荡器是一种产生周期性（振荡）信号的设备（在我们的场景下是一段代码）。正弦波就是这种波形的一个例子，但我们还将介绍方波，三角波和锯齿波。

在本文的结尾，您将能够生成如下所示的信号：

image

在图像上，它们看起来像连接的线，但是在我们将生成的数字音频信号中，它们是单独的数据点。每个周期有几个“点”？这取决于我们使用的采样率。

我们可以弄清楚在给定的情况下如何找到sample rate。请记住，我们在trig函数中使用了弧度，因此周期定义为：2 * PI。要知道如何放置点，我们可以找出难点的一部分（“增量”），如下所示：

increment = (2 * PI) / SampleRate

不幸的是，这还不是全部。我们也要记住，我们的波具有一定的频率-我们必须在增量中加以考虑。实际功能将变为：

increment = ((2 * PI) / SampleRate) * freq

在Oscillator中，我们必须跟踪这些东西。我们想知道当前频率是多少，当前相位是什么，以及如何增加该相位以获得波的下一个值。

这仅解决了部分难题。现在也很清楚，我们需要一种方法来区分用户想要生成哪种波形。为此，我们可以从Shape类型的“枚举”开始。每个形状也需要以不同的方式进行计算，因此我们可以将Shape与计算函数相关联shapeCalcFunc = map[Shape]func(float64)float64

type Shape int

const (
    SINE Shape = iota
    SQUARE
    DOWNWARD_SAWTOOTH
    UPWARD_SAWTOOTH
    TRIANGLE
)

var (
    shapeCalcFunc = map[Shape]func(float64) float64{
        SINE:              sineCalc,
        SQUARE:            squareCalc,
        TRIANGLE:          triangleCalc,
        DOWNWARD_SAWTOOTH: downSawtoothCalc,
        UPWARD_SAWTOOTH:   upwSawtoothCalc,
    }
)

这些是我们的“基本”形状，将在接下来的几篇文章中使用。尽管我将继续介绍它们，但它们将为我们提供坚实的基础。

将刚刚提到的这些放在一起，我们可以定义一个Oscillator结构体：

type Oscillator struct {
    curfreq  float64
    curphase float64
    incr     float64
    twopiosr float64 // (2*PI) / samplerate
    tickfunc func(float64) float64
}

// NewOscillator set to a given sample rate
func NewOscillator(sr int, shape Shape) (*Oscillator, error) {
    cf, ok := shapeCalcFunc[shape]
    if !ok {
        return nil, fmt.Errorf("Shape type %v not supported", shape)
    }
    return &Oscillator{
        twopiosr: tau / float64(sr), // (2 * PI) / SampleRate
        tickfunc: cf,
    }, nil
}

|

请注意，我们将twopiosr = tau / SampleRate = (2 * PI) / SampleRate存储为结构体变量。我们将在几个函数中使用它。

产生波形

有了这个构造函数，我们就有了一个工作振荡器的基础，但是它还没有产生任何东西。为此，我们需要一个函数，要求振荡器产生波的下一个值（它可以无限期地执行此操作）。此功能需要做一些事情：

• 接受波产生的频率
• 调整帧之间的增量
• 在此相位找到值
• 调整当前相位
• 对相位进行一些边界检查（可选）

我们在Go中的功能变为：

func (o *Oscillator) Tick(freq float64) float64 {
    if o.curfreq != freq {
        o.curfreq = freq
        o.incr = o.twopiosr * freq
    }
    val := o.tickfunc(o.curphase)
    o.curphase += o.incr
        
        // adjust bounds
    if o.curphase >= tau {
        o.curphase -= tau
    }
    if o.curphase < 0 {
        o.curphase = tau
    }
    return val
}

对我们当前阶段的调整是将其保持在边界内（尽管根据sin函数的实现，这可能不是必需的，我仍做保留，但我敢肯定在Go中是不必要的）。

波形函数

剩下要实现的唯一部分是不同形状的波形的实际生成。这就是val := o.tickfunc(o.curphase)调用中发生的情况。通过使用通用函数调用，我们可以在对NewOscillator()的调用中注入正确的计算函数。

最容易实现的是正弦波。

func sineCalc(phase float64) float64 {
    return math.Sin(phase)
}

最简单的实现方式可能是方波函数。在这种情况下，我们1的一半是，另一半是-1。

func squareCalc(phase float64) float64 {
    val := -1.0
    if phase <= math.Pi {
        val = 1.0
    }
    return val
}

三角波是第一个看起来更复杂的波，锯齿波与之相关（可以从视觉上看到锯齿成为三角形的一部分，并且具有陡峭的截止点。

func triangleCalc(phase float64) float64 {
    val := 2.0*(phase*(1.0/tau)) - 1.0
    if val < 0.0 {
        val = -val
    }
    val = 2.0 * (val - 0.5)
    return val
}

func upwSawtoothCalc(phase float64) float64 {
    val := 2.0*(phase*(1.0/tau)) - 1.0
    return val
}

func downSawtoothCalc(phase float64) float64 {
    val := 1.0 - 2.0*(phase*(1.0/tau))
    return val
}

生成波

设置好振荡器后，我们终于可以开始使用它了。以下所有代码都包含在此GoAudio示例中。

func main() {
    flag.Parse()
    fmt.Println("usage: go run main -d {dur} -s {shape} -a {amps} -f {freqs} -o {output}")
    if output == nil {
        panic("please provide an output file")
    }

    wfmt := wave.NewWaveFmt(1, 1, 44100, 16, nil)
    amps, err := ioutil.ReadFile(*amppoints)
    if err != nil {
        panic(err)
    }
    ampPoints, err := breakpoint.ParseBreakpoints(bytes.NewReader(amps))
    if err != nil {
        panic(err)
    }
    ampStream, err := breakpoint.NewBreakpointStream(ampPoints, wfmt.SampleRate)

    freqs, err := ioutil.ReadFile(*freqpoints)
    if err != nil {
        panic(err)
    }
    freqPoints, err := breakpoint.ParseBreakpoints(bytes.NewReader(freqs))
    if err != nil {
        panic(err)
    }
    freqStream, err := breakpoint.NewBreakpointStream(freqPoints, wfmt.SampleRate)
    if err != nil {
        panic(err)
    }
    // create wave file sampled at 44.1Khz w/ 16-bit frames

    frames := generate(*duration, stringToShape[*shape], ampStream, freqStream, wfmt)
    wave.WriteFrames(frames, wfmt, *output)
    fmt.Println("done")
}

注意，我们还打印了用法，这告诉我们持续时间，形状，幅度断点，频率断点，最后是输出文件。“繁重的工作”发生在对generate 的调用中。在这里，我们传递持续时间，从CLI上输入的字符串派生的Shape实例，我们的断点以及最后一个WaveFmt。请记住，WaveFmt结构包含我们正在生成.wave的文件的元数据。在这种情况下，wave.NewWaveFmt(1, 1, 44100, 16, nil)表示这是一个标准PCM波形文件，在44.1Khz上播放1个通道（单声道），其中数据由16位浮点数组成。你可以使用这些值来查看结果如何变化。

最后，在generate函数中，我们需要计算需要生成的样本数量（=单帧）。然后，我们将调用Tick振荡器的函数以及断点流，以连续获取下一个值。

func generate(dur int, shape synth.Shape, ampStream, freqStream *breakpoint.BreakpointStream, wfmt wave.WaveFmt) []wave.Frame {
    reqFrames := dur * wfmt.SampleRate
    frames := make([]wave.Frame, reqFrames)
    osc, err := synth.NewOscillator(wfmt.SampleRate, shape)
    if err != nil {
        panic(err)
    }

    for i := range frames {
        amp := ampStream.Tick()
        freq := freqStream.Tick()
        frames[i] = wave.Frame(amp * osc.Tick(freq))
    }

    return frames
}

到这里，我们现在已经拥有所有用于生成基本波形的代码。当检查它们时，我们将得到在本文开头显示的结果。

改进之处

这样我们就可以生成基本的“干净”的音频信号，这对于测试目的可能是方便的，但是据我所知也就到此为止了。（大多数软件合成器也可以让你体验这些类型的wave，但是你可以将它们调整为更有用的功能）。

你可能对此代码有些担心，首先是性能问题。根据定义，振荡器是重复的，但我们一直在计算“下一阶段”。这是绝对必要的吗？不，我们实际上可以将期望看到的值存储在“查找表”中。

在下一篇文章中，我们将研究如何使用查找表，我们还将开始考虑谐波，以更真实的方式表示声音。