Is there a pure golang implementation of aac transcode opus? [closed] - go

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 5 days ago.
Improve this question
Please note: pure golang implementation, no ffmpeg-wrapper / c-go
Is there a pure golang implementation of aac transcode opus?
I've written a streaming-WebRTC gateway app that can convert av streams from streaming devices to WebRTC via pion, but now there's a tricky problem, the audio encoding provided by these media devices is usually aac(WebRTC do not support aac), I can't find a library that implements aac -> opus (or pcm -> opus) in pure go, only some library based on c-go (like this one). The c-go based library has some limitations, e.g. it can't be self-contained, so there a pure golang implementation of aac transcode opus?
The code (snippet) below is my current implementation using Glimesh's fdk-aac and hraban's opus
...
// 音频相关配置
// https://github.com/Glimesh/go-fdkaac
aacDecoder := fdkaac.NewAacDecoder()
defer func() {
_ = aacDecoder.Close()
}()
aacDecoderInitDone := false
var opusEncoder *hrabanopus.Encoder
minAudioSampleRate := 16000
var opusAudioBuffer []byte
opusBlockSize := 960
opusBufferSize := 1000
opusFramesSize := 120
...
// 用 AAC 的元数据初始化 AAC 编码器
// https://github.com/winlinvip/go-fdkaac
if tag.AACPacketType == flvio.AAC_SEQHDR {
if !aacDecoderInitDone {
if err := aacDecoder.InitRaw(tagData); err != nil {
return errors.Wrapf(err, "从 %s.%s 的(音频元数据 %s)标签初始化 AAC 解码器失败", flowControlGroup, streamKey, hex.EncodeToString(tagData))
}
aacDecoderInitDone = true
logrus.Infof("从 %s.%s 的(音频元数据 %s)标签初始化了 AAC 解码器 %p", flowControlGroup, streamKey, hex.EncodeToString(tagData), aacDecoder)
}
} else {
tagDataString := hex.EncodeToString(tagData)
logrus.Tracef("使用已初始化了的 AAC 解码器 %p 解码 %s.%s 的音频数据 %s", aacDecoder, flowControlGroup, streamKey, tagDataString)
// 解码 AAC 为 PCM
decodeResult, err := aacDecoder.Decode(tagData)
if err != nil {
return errors.Wrapf(err, "从 %s.%s 的标签解码 PCM 数据失败", flowControlGroup, streamKey)
}
rate := aacDecoder.SampleRate()
channels := aacDecoder.NumChannels()
if rate < minAudioSampleRate {
logrus.Tracef("从 %s.%s 的标签解码 PCM 数据得到音频采样频 %d小于要求的最小值(%d),将忽略编码opus的操作", flowControlGroup, streamKey, rate, minAudioSampleRate)
} else {
if opusEncoder == nil {
oEncoder, err := hrabanopus.NewEncoder(rate, channels, hrabanopus.AppAudio)
if err != nil {
return err
}
opusEncoder = oEncoder
}
// https://github.com/Glimesh/waveguide/blob/a7e7745be31d0a112aa6adb6437df03960c4a5c5/internal/inputs/rtmp/rtmp.go#L289
// https://github.com/xiangxud/rtmp-to-webrtc/blob/07d7da9197cedc3756a1c87389806c3670b9c909/rtmp.go#L168
for opusAudioBuffer = append(opusAudioBuffer, decodeResult...); len(opusAudioBuffer) >= opusBlockSize*4; opusAudioBuffer = opusAudioBuffer[opusBlockSize*4:] {
pcm16 := make([]int16, opusBlockSize*2)
pcm16len := len(pcm16)
for i := 0; i < pcm16len; i++ {
pcm16[i] = int16(binary.LittleEndian.Uint16(opusAudioBuffer[i*2:]))
}
opusData := make([]byte, opusBufferSize)
n, err := opusEncoder.Encode(pcm16, opusData)
if err != nil {
return err
}
opusOutput := opusData[:n]
// https://datatracker.ietf.org/doc/html/rfc6716#section-2.1.4
// Opus can encode frames of 2.5, 5, 10, 20, 40, or 60 ms. It can also
// combine multiple frames into packets of up to 120 ms. For real-time
// applications, sending fewer packets per second reduces the bitrate,
// since it reduces the overhead from IP, UDP, and RTP headers.
// However, it increases latency and sensitivity to packet losses, as
// losing one packet constitutes a loss of a bigger chunk of audio.
// Increasing the frame duration also slightly improves coding
// efficiency, but the gain becomes small for frame sizes above 20 ms.
// For this reason, 20 ms frames are a good choice for most
// applications.
sampleDuration := time.Duration(opusFramesSize) * time.Millisecond
sample := media.Sample{
Data: opusOutput,
Duration: sampleDuration,
}
if err := audioTrack.WriteSample(sample); err != nil {
return err
}
}
}
}
...
Also, is there a pure-go ffmpeg alternative? not wrappers