Add support for AMR-WB codec. (#58)

Use opencore-amr for decoding and vo-amrwbenc for encoding.

Author: dennwc

.github/workflows/test.yaml

@@ -42,7 +42,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.24.2
+          go-version: 1.26
 
       - name: Set up gotestfmt
         run: go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest

all/all_cgo.go

@@ -4,5 +4,6 @@ package all
 
 // Register all supported codecs that use CGo.
 import (
+	_ "github.com/livekit/media-sdk/amrwb"
 	_ "github.com/livekit/media-sdk/opus"
 )

amrwb/amrwb.go

@@ -0,0 +1,162 @@
+// Copyright 2026 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package amrwb
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dennwc/amrwb-cgo"
+	"github.com/livekit/media-sdk"
+)
+
+const (
+	SDPName    = "AMR-WB/16000"
+	SampleRate = 16000
+)
+
+func init() {
+	media.RegisterCodec(media.NewAudioCodec(media.CodecInfo{
+		SDPName:     SDPName,
+		SampleRate:  SampleRate,
+		RTPIsStatic: false,
+		Priority:    -4,
+		FileExt:     "amrwb",
+		Disabled:    true,
+	}, Decode, Encode))
+}
+
+type Sample []byte
+
+func (s Sample) Size() int {
+	return len(s)
+}
+
+func (s Sample) CopyTo(dst []byte) (int, error) {
+	if len(dst) < len(s) {
+		return 0, io.ErrShortBuffer
+	}
+	n := copy(dst, s)
+	return n, nil
+}
+
+type Writer = media.WriteCloser[Sample]
+
+func Decode(w media.PCM16Writer) Writer {
+	return &Decoder{
+		w: w,
+		d: amrwb.NewDecoder(),
+	}
+}
+
+type Decoder struct {
+	w     media.PCM16Writer
+	d     *amrwb.Decoder
+	frame amrwb.PCMFrame
+	buf   media.PCM16Sample
+}
+
+func (d *Decoder) String() string {
+	return fmt.Sprintf("AMR-WB(decode) -> %s", d.w)
+}
+
+func (d *Decoder) SampleRate() int {
+	return SampleRate
+}
+
+func (d *Decoder) Close() error {
+	d.d.Close()
+	return d.w.Close()
+}
+
+func (d *Decoder) WriteSample(in Sample) error {
+	d.buf = d.buf[:0]
+	var blockErr error
+	for len(in) > 0 {
+		n, err := d.d.Decode(&d.frame, in)
+		if err != nil {
+			blockErr = err
+			break
+		}
+		in = in[n:]
+		d.buf = append(d.buf, d.frame[:]...)
+	}
+	if len(d.buf) != 0 {
+		if err := d.w.WriteSample(d.buf); err != nil {
+			return err
+		}
+	}
+	return blockErr
+}
+
+func Encode(w Writer) media.PCM16Writer {
+	return &Encoder{
+		w: w,
+		e: amrwb.NewEncoder(amrwb.Best),
+	}
+}
+
+type Encoder struct {
+	w    Writer
+	e    *amrwb.Encoder
+	buf  []byte
+	done bool
+}
+
+func (e *Encoder) String() string {
+	return fmt.Sprintf("AMR-WB(encode) -> %s", e.w)
+}
+
+func (e *Encoder) SampleRate() int {
+	return SampleRate
+}
+
+func (e *Encoder) Close() error {
+	return e.w.Close()
+}
+
+func (e *Encoder) WriteSample(in media.PCM16Sample) error {
+	if len(in) == 0 {
+		return nil
+	}
+	var blockErr error
+	if e.done {
+		// We zero-padded previous frame, but we still got data after that.
+		// The stream must be normalized with FullFrames by the caller instead.
+		blockErr = errors.New("amrwb: writing frame after a short previous frame")
+	}
+	e.buf = e.buf[:0]
+	for len(in) > 0 {
+		const n = amrwb.PCMFrameSize
+		if len(in) < n {
+			// Zero pad, it's okay for the last frame only.
+			// We'll return the error if we get another frame after this.
+			e.done = true
+			var buf amrwb.PCMFrame
+			copy(buf[:], in)
+			in = buf[:]
+		}
+		frame := (*amrwb.PCMFrame)(in[:n])
+		in = in[n:]
+		e.buf = e.e.Encode(e.buf, frame)
+	}
+	if len(e.buf) != 0 {
+		if err := e.w.WriteSample(e.buf); err != nil {
+			return err
+		}
+	}
+	return blockErr
+}

amrwb/amrwb_test.go

@@ -0,0 +1,84 @@
+package amrwb
+
+import (
+	"os"
+	"os/exec"
+	"testing"
+
+	"github.com/livekit/media-sdk"
+	"github.com/livekit/media-sdk/res"
+	"github.com/livekit/media-sdk/res/testdata"
+)
+
+func TestAMRWB(t *testing.T) {
+	const rate = 16000
+	frames := res.ReadOggAudioFile(testdata.TestAudioOgg16K, rate, 1)
+
+	blocks := make([]Sample, 0, len(frames))
+	fw := media.NewFrameWriter(&blocks, rate)
+
+	enc := Encode(fw)
+	t.Cleanup(func() {
+		enc.Close()
+	})
+	for i, frame := range frames {
+		err := enc.WriteSample(frame)
+		if err != nil {
+			t.Errorf("encoding frame %d/%d: %v", i+1, len(frames), err)
+		}
+	}
+	famr, err := os.Create("testdata.amrwb")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer famr.Close()
+
+	famr.WriteString("#!AMR-WB\n")
+	for _, block := range blocks {
+		famr.Write(block)
+	}
+
+	var out []media.PCM16Sample
+	pw := media.NewPCM16FrameWriter(&out, rate)
+
+	dec := Decode(pw)
+	t.Cleanup(func() {
+		dec.Close()
+	})
+	for _, block := range blocks {
+		err := dec.WriteSample(block)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	f, err := os.Create("testdata.s16le")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	err = media.DumpFramesPCM16(f, rate, out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := exec.LookPath("ffmpeg"); err != nil {
+		t.Log("ffmpeg not found in $PATH")
+		return
+	}
+
+	err = exec.Command("ffmpeg",
+		"-i", "testdata.amrwb",
+		"testdata.amrwb.ogg",
+	).Run()
+	if err != nil {
+		t.Error(err)
+	}
+	err = exec.Command("ffmpeg",
+		"-f", "s16le", "-ar", "16000", "-ac", "1",
+		"-i", "testdata.s16le",
+		"testdata.s16le.ogg",
+	).Run()
+	if err != nil {
+		t.Error(err)
+	}
+}

buffers.go

@@ -8,43 +8,43 @@ import (
 )
 
 type sample interface {
-	int8 | int16 | int32 | int64 | float32 | float64
+	byte | int8 | int16 | int32 | int64 | float32 | float64
 }
 
 // FullFrames creates a writer that only writes full frames of a given size to the underlying writer (except the last one).
 func FullFrames[T ~[]S, S sample](w WriteCloser[T], frameSize int) WriteCloser[T] {
 	if frameSize <= 0 {
 		panic("invalid frame size")
 	}
-	return &frameBuffer[T, S]{
+	return &fullFrameBuffer[T, S]{
 		w:         w,
 		frameSize: frameSize,
 		buf:       make([]S, 0, frameSize),
 	}
 }
 
-type frameBuffer[T ~[]S, S sample] struct {
+type fullFrameBuffer[T ~[]S, S sample] struct {
 	frameSize int
 	mu        sync.Mutex
 	w         WriteCloser[T]
 	buf       []S
 }
 
-func (b *frameBuffer[T, S]) String() string {
-	return fmt.Sprintf("FrameBuf(%d) -> %s", b.frameSize, b.w)
+func (b *fullFrameBuffer[T, S]) String() string {
+	return fmt.Sprintf("FullFrameBuf(%d) -> %s", b.frameSize, b.w)
 }
-func (b *frameBuffer[T, S]) SampleRate() int {
+func (b *fullFrameBuffer[T, S]) SampleRate() int {
 	return b.w.SampleRate()
 }
 
-func (b *frameBuffer[T, S]) WriteSample(in T) error {
+func (b *fullFrameBuffer[T, S]) WriteSample(in T) error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	b.buf = append(b.buf, in...)
 	return b.flush(false)
 }
 
-func (b *frameBuffer[T, S]) flush(force bool) error {
+func (b *fullFrameBuffer[T, S]) flush(force bool) error {
 	it := b.buf
 	defer func() {
 		if len(it) == 0 {
@@ -69,10 +69,40 @@ func (b *frameBuffer[T, S]) flush(force bool) error {
 	return nil
 }
 
-func (b *frameBuffer[T, S]) Close() error {
+func (b *fullFrameBuffer[T, S]) Close() error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	err := b.flush(true)
 	err2 := b.w.Close()
 	return errors.Join(err, err2)
 }
+
+// NewFrameWriter creates a writer that appends a copy of all written frames to a slice.
+func NewFrameWriter[T ~[]S, S sample](buf *[]T, sampleRate int) WriteCloser[T] {
+	return &frameWriter[T, S]{
+		buf:        buf,
+		sampleRate: sampleRate,
+	}
+}
+
+type frameWriter[T ~[]S, S sample] struct {
+	buf        *[]T
+	sampleRate int
+}
+
+func (b *frameWriter[T, S]) String() string {
+	return fmt.Sprintf("Frames(%d)", b.sampleRate)
+}
+
+func (b *frameWriter[T, S]) SampleRate() int {
+	return b.sampleRate
+}
+
+func (b *frameWriter[T, S]) Close() error {
+	return nil
+}
+
+func (b *frameWriter[T, S]) WriteSample(data T) error {
+	*b.buf = append(*b.buf, slices.Clone(data))
+	return nil
+}