如何使用Go原生调整Opus Ogg页面大小？

核心思路 #

要实现和ffmpeg -i $INPUT_FILE -c:a libopus -page_duration 20000 -vn output.ogg相同的效果，本质是重新封装Opus帧到Ogg页面中，确保每个页面的时长约为20ms（20000微秒）。Pion的oggreader和oggwriter已经封装了Ogg容器的基础操作，无需深入啃RFC文档，只需处理帧的分组逻辑即可。

实时处理TTS响应的实现步骤 #

1. 流式读取TTS响应 #

利用HTTP响应的Body是io.Reader的特性，直接流式处理，无需等待完整文件下载：

resp, err := client.Do(req)
if err != nil {
    // 错误处理逻辑
}
defer resp.Body.Close()

2. 解析Opus头信息 #

Ogg容器的第一个页面必须是Opus头，后续帧才能被正确解析，先从流式响应中提取头信息：

import (
    "github.com/pion/ogg"
    "github.com/pion/opus"
)

oggReader, err := ogg.NewReader(resp.Body)
if err != nil {
    // 错误处理逻辑
}

var opusHead *opus.Head
for {
    page, _, err := oggReader.ParseNextPage()
    if err != nil {
        // 错误处理逻辑
    }

    if opusHead, err = opus.NewHead(page.Payload); err == nil {
        break // 成功读取头信息，跳出循环
    }
}

3. 按20ms时长分组Opus帧 #

根据Opus头的采样率和帧大小计算单帧时长，累计帧时长直到接近20ms时，打包成新的Ogg页面：

targetPageDuration := 20000 // 目标页面时长（微秒）
frameDuration := opusHead.SampleRate / 1000 * opusHead.FrameSize // 单帧时长（微秒）
currentDuration := 0
var pagePayload [][]byte

// 这里可以用io.Pipe对接WebRTC，实现实时传输
r, w := io.Pipe()
oggWriter := ogg.NewWriter(w)
defer oggWriter.Close()

// 写入Opus头页面
if err := oggWriter.WritePage(ogg.Page{
    Header: ogg.PageHeader{
        Version: 0,
        Type:    ogg.PageTypeBos,
        Serial:  1234, // 自定义唯一序列号
        Granule: 0,
        PageNum: 0,
        CRC:     0, // oggWriter会自动计算CRC
    },
    Payload: opusHead.Marshal(),
}); err != nil {
    // 错误处理逻辑
}

// 流式处理后续Opus帧
for {
    page, _, err := oggReader.ParseNextPage()
    if err == io.EOF {
        break
    }
    if err != nil {
        // 错误处理逻辑
    }

    frames, err := opus.ParseFrames(page.Payload)
    if err != nil {
        // 错误处理逻辑
    }

    for _, frame := range frames {
        currentDuration += frameDuration
        pagePayload = append(pagePayload, frame)

        // 累计时长达标，打包新页面
        if currentDuration >= targetPageDuration {
            combinedPayload := bytes.Join(pagePayload, nil)
            // 计算Granule值（对应总采样数，用于时间同步）
            granule := uint64(currentDuration * opusHead.SampleRate / 1000000)

            if err := oggWriter.WritePage(ogg.Page{
                Header: ogg.PageHeader{
                    Version: 0,
                    Type:    ogg.PageTypeContinued,
                    Serial:  1234, // 和头页面序列号一致
                    Granule: granule,
                    PageNum: oggWriter.PageNum(),
                    CRC:     0,
                },
                Payload: combinedPayload,
            }); err != nil {
                // 错误处理逻辑
            }

            // 重置计数器和缓存
            currentDuration = 0
            pagePayload = nil
        }
    }
}

// 处理剩余不足20ms的帧
if len(pagePayload) > 0 {
    combinedPayload := bytes.Join(pagePayload, nil)
    granule := uint64(currentDuration * opusHead.SampleRate / 1000000)

    if err := oggWriter.WritePage(ogg.Page{
        Header: ogg.PageHeader{
            Version: 0,
            Type:    ogg.PageTypeEos,
            Serial:  1234,
            Granule: granule,
            PageNum: oggWriter.PageNum(),
            CRC:     0,
        },
        Payload: combinedPayload,
    }); err != nil {
        // 错误处理逻辑
    }
}

4. 对接WebRTC实时播放 #

将管道的读取端接入WebRTC的音频轨道，复用Pion示例中的RTP发送逻辑即可：

import "github.com/pion/webrtc/v3"

go func() {
    defer r.Close()
    track, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: "audio/opus"}, "audio", "pion")
    if err != nil {
        // 错误处理逻辑
    }
    _, err = pc.AddTrack(track)
    if err != nil {
        // 错误处理逻辑
    }

    // 从管道读取调整后的Ogg数据，解析并发送RTP包
    oggReaderForRTP, err := ogg.NewReader(r)
    if err != nil {
        // 错误处理逻辑
    }
    // 此处复用play-from-disk示例中的RTP发送逻辑
}()

关键注意事项 #

• Opus头优先：必须先处理并写入Opus头页面，否则后续帧无法被解析。
• Granule值准确：该值是Ogg时间同步的核心，需严格按照总采样数计算。
• 低延迟保障：每凑够20ms帧就立即写入页面，避免缓存过多数据影响实时性。

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