add audio aac convert to opus

README.md

@@ -8,5 +8,32 @@ This repo demonstrates a RTMP server that on every RTMP publish makes the audio/
 * Open [http://localhost:8080/](http://localhost:8080/)
 * Publish an RTMP feed to `rtmp://localhost:1935/publish/foobar`. It must be H264 and alaw
 
-#### GStreamer
-`gst-launch-1.0 videotestsrc ! video/x-raw,format=I420 ! x264enc speed-preset=ultrafast tune=zerolatency key-int-max=20 ! flvmux name=flvmux ! rtmpsink location=rtmp://localhost:1935/publish/foobar audiotestsrc ! alawenc ! flvmux.`
+#### AAC convert to OPUS
+
+Modify from source https://github.com/Glimesh/rtmp-ingest.git thanks Glimesh 
+
+Modify from source [mediadevices/pkg/codec/opus at master · pion/mediadevices (github.com)](https://github.com/pion/mediadevices/tree/master/pkg/codec/opus)
+
+Modify from source [hraban/opus: Go wrapper for libopus (golang) (github.com)](https://github.com/hraban/opus)
+
+Opus lib ref  [xiph/opus: Modern audio compression for the internet. (github.com)](https://github.com/xiph/opus)
+
+Opus Lib : static build(please add your lib to path ./opus/lib name like :libopus-linux-x64.a), pkgconfig dynamic
+
+    please build your lib or install your opus lib dev env
+
+of course you can use  opus "gopkg.in/hraban/opus.v2"
+
+instead of opus "github.com/sean-der/rtmp-to-webrtc/opus" (just my study)
+
+### macOS Development
+
+```
+brew install opusfile fdk-aac
+```
+
+### Ubuntu / Linux Development
+
+```
+apt install -y pkg-config build-essential libopusfile-dev libfdk-aac-dev libavutil-dev libavcodec-dev libswscale-dev
+```

go.mod

@@ -3,8 +3,10 @@ module github.com/sean-der/rtmp-to-webrtc
 go 1.14
 
 require (
+	github.com/Glimesh/go-fdkaac v0.0.0-20220325160929-2f6b0a53a22a
 	github.com/pion/webrtc/v3 v3.1.22
 	github.com/pkg/errors v0.9.1
 	github.com/yutopp/go-flv v0.2.0
 	github.com/yutopp/go-rtmp v0.0.0-20191212152852-4e41609a99bb
+	gopkg.in/hraban/opus.v2 v2.0.0-20220302220929-eeacdbcb92d0
 )

go.sum

@@ -1,3 +1,5 @@
+github.com/Glimesh/go-fdkaac v0.0.0-20220325160929-2f6b0a53a22a h1:KLHAFbjWd6MjrM1gw3KmFBX23O/27yso8vcfcanKEAc=
+github.com/Glimesh/go-fdkaac v0.0.0-20220325160929-2f6b0a53a22a/go.mod h1:EKp34oLIwEAKG/EYPeDKmUFZBTIqw/Q/NLvFVss3+EQ=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -174,6 +176,8 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/hraban/opus.v2 v2.0.0-20220302220929-eeacdbcb92d0 h1:B8lK1KhYrE4H3urNYBAL/UquYftW65IHPY8JP3gpZ4M=
+gopkg.in/hraban/opus.v2 v2.0.0-20220302220929-eeacdbcb92d0/go.mod h1:/L5E7a21VWl8DeuCPKxQBdVG5cy+L0MRZ08B1wnqt7g=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -35,7 +35,8 @@ func createPeerConnection(w http.ResponseWriter, r *http.Request) {
 		panic(err)
 	}
 
-	audioTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypePCMA}, "audio", "pion")
+	// audioTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypePCMA}, "audio", "pion")
+	audioTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeOpus}, "audio", "pion")
 	if err != nil {
 		panic(err)
 	}

opus/Makefile

@@ -0,0 +1,31 @@
+git_url := https://github.com/xiph/opus.git
+version := v1.3.1
+src_root_dir := src
+lib_dir := lib
+include_dir := include
+lib_prefix := libopus
+src_dir := $(src_root_dir)/$(MEDIADEVICES_TARGET_PLATFORM)
+output_path := $(lib_dir)/$(lib_prefix)-$(MEDIADEVICES_TARGET_PLATFORM).a
+
+.PHONY: all
+all: guard-MEDIADEVICES_TARGET_PLATFORM guard-MEDIADEVICES_TOOLCHAIN_BIN $(output_path) headers
+
+headers: | $(src_dir) $(include_dir)
+	@cp $(src_dir)/include/*.h $(include_dir)
+
+$(output_path): $(src_dir)/$(lib_prefix).a | $(lib_dir)
+	@cp $< $@
+
+$(src_dir)/$(lib_prefix).a: | $(src_dir)
+	cd $(src_dir) && \
+		$(MEDIADEVICES_TOOLCHAIN_BIN) cmake -DOPUS_STACK_PROTECTOR=OFF -DCMAKE_C_FLAGS="-fpic" && \
+		$(MEDIADEVICES_TOOLCHAIN_BIN) make VERBOSE=1
+
+$(src_dir): | $(src_root_dir)
+	git clone --depth=1 --branch=$(version) $(git_url) $@
+
+$(src_root_dir) $(lib_dir) $(include_dir):
+	@mkdir -p $@
+
+guard-%:
+	@if [ -z ${$*} ]; then echo "$* is a required environment variable"; exit 1; fi

opus/decoder.go

@@ -0,0 +1,262 @@
+// Copyright © Go Opus Authors (see AUTHORS file)
+//
+// License for use of this code is detailed in the LICENSE file
+
+package opus
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+/*
+#cgo pkg-config: opus
+#include <opus.h>
+
+int
+bridge_decoder_get_last_packet_duration(OpusDecoder *st, opus_int32 *samples)
+{
+	return opus_decoder_ctl(st, OPUS_GET_LAST_PACKET_DURATION(samples));
+}
+*/
+import "C"
+
+var errDecUninitialized = fmt.Errorf("opus decoder uninitialized")
+
+type Decoder struct {
+	p *C.struct_OpusDecoder
+	// Same purpose as encoder struct
+	mem         []byte
+	sample_rate int
+	channels    int
+}
+
+// NewDecoder allocates a new Opus decoder and initializes it with the
+// appropriate parameters. All related memory is managed by the Go GC.
+func NewDecoder(sample_rate int, channels int) (*Decoder, error) {
+	var dec Decoder
+	err := dec.Init(sample_rate, channels)
+	if err != nil {
+		return nil, err
+	}
+	return &dec, nil
+}
+
+func (dec *Decoder) Init(sample_rate int, channels int) error {
+	if dec.p != nil {
+		return fmt.Errorf("opus decoder already initialized")
+	}
+	if channels != 1 && channels != 2 {
+		return fmt.Errorf("Number of channels must be 1 or 2: %d", channels)
+	}
+	size := C.opus_decoder_get_size(C.int(channels))
+	dec.sample_rate = sample_rate
+	dec.channels = channels
+	dec.mem = make([]byte, size)
+	dec.p = (*C.OpusDecoder)(unsafe.Pointer(&dec.mem[0]))
+	errno := C.opus_decoder_init(
+		dec.p,
+		C.opus_int32(sample_rate),
+		C.int(channels))
+	if errno != 0 {
+		return Error(errno)
+	}
+	return nil
+}
+
+// Decode encoded Opus data into the supplied buffer. On success, returns the
+// number of samples correctly written to the target buffer.
+func (dec *Decoder) Decode(data []byte, pcm []int16) (int, error) {
+	if dec.p == nil {
+		return 0, errDecUninitialized
+	}
+	if len(data) == 0 {
+		return 0, fmt.Errorf("opus: no data supplied")
+	}
+	if len(pcm) == 0 {
+		return 0, fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return 0, fmt.Errorf("opus: target buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode(
+		dec.p,
+		(*C.uchar)(&data[0]),
+		C.opus_int32(len(data)),
+		(*C.opus_int16)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		0))
+	if n < 0 {
+		return 0, Error(n)
+	}
+	return n, nil
+}
+
+// Decode encoded Opus data into the supplied buffer. On success, returns the
+// number of samples correctly written to the target buffer.
+func (dec *Decoder) DecodeFloat32(data []byte, pcm []float32) (int, error) {
+	if dec.p == nil {
+		return 0, errDecUninitialized
+	}
+	if len(data) == 0 {
+		return 0, fmt.Errorf("opus: no data supplied")
+	}
+	if len(pcm) == 0 {
+		return 0, fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return 0, fmt.Errorf("opus: target buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode_float(
+		dec.p,
+		(*C.uchar)(&data[0]),
+		C.opus_int32(len(data)),
+		(*C.float)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		0))
+	if n < 0 {
+		return 0, Error(n)
+	}
+	return n, nil
+}
+
+// DecodeFEC encoded Opus data into the supplied buffer with forward error
+// correction.
+//
+// It is to be used on the packet directly following the lost one.  The supplied
+// buffer needs to be exactly the duration of audio that is missing
+//
+// When a packet is considered "lost", DecodeFEC can be called on the next
+// packet in order to try and recover some of the lost data. The PCM needs to be
+// exactly the duration of audio that is missing.  `LastPacketDuration()` can be
+// used on the decoder to get the length of the last packet.  Note also that in
+// order to use this feature the encoder needs to be configured with
+// SetInBandFEC(true) and SetPacketLossPerc(x) options.
+//
+// Note that DecodeFEC automatically falls back to PLC when no FEC data is
+// available in the provided packet.
+func (dec *Decoder) DecodeFEC(data []byte, pcm []int16) error {
+	if dec.p == nil {
+		return errDecUninitialized
+	}
+	if len(data) == 0 {
+		return fmt.Errorf("opus: no data supplied")
+	}
+	if len(pcm) == 0 {
+		return fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return fmt.Errorf("opus: target buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode(
+		dec.p,
+		(*C.uchar)(&data[0]),
+		C.opus_int32(len(data)),
+		(*C.opus_int16)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		1))
+	if n < 0 {
+		return Error(n)
+	}
+	return nil
+}
+
+// DecodeFECFloat32 encoded Opus data into the supplied buffer with forward error
+// correction. It is to be used on the packet directly following the lost one.
+// The supplied buffer needs to be exactly the duration of audio that is missing
+func (dec *Decoder) DecodeFECFloat32(data []byte, pcm []float32) error {
+	if dec.p == nil {
+		return errDecUninitialized
+	}
+	if len(data) == 0 {
+		return fmt.Errorf("opus: no data supplied")
+	}
+	if len(pcm) == 0 {
+		return fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return fmt.Errorf("opus: target buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode_float(
+		dec.p,
+		(*C.uchar)(&data[0]),
+		C.opus_int32(len(data)),
+		(*C.float)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		1))
+	if n < 0 {
+		return Error(n)
+	}
+	return nil
+}
+
+// DecodePLC recovers a lost packet using Opus Packet Loss Concealment feature.
+//
+// The supplied buffer needs to be exactly the duration of audio that is missing.
+// When a packet is considered "lost", `DecodePLC` and `DecodePLCFloat32` methods
+// can be called in order to obtain something better sounding than just silence.
+// The PCM needs to be exactly the duration of audio that is missing.
+// `LastPacketDuration()` can be used on the decoder to get the length of the
+// last packet.
+//
+// This option does not require any additional encoder options. Unlike FEC,
+// PLC does not introduce additional latency. It is calculated from the previous
+// packet, not from the next one.
+func (dec *Decoder) DecodePLC(pcm []int16) error {
+	if dec.p == nil {
+		return errDecUninitialized
+	}
+	if len(pcm) == 0 {
+		return fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return fmt.Errorf("opus: output buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode(
+		dec.p,
+		nil,
+		0,
+		(*C.opus_int16)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		0))
+	if n < 0 {
+		return Error(n)
+	}
+	return nil
+}
+
+// DecodePLCFloat32 recovers a lost packet using Opus Packet Loss Concealment feature.
+// The supplied buffer needs to be exactly the duration of audio that is missing.
+func (dec *Decoder) DecodePLCFloat32(pcm []float32) error {
+	if dec.p == nil {
+		return errDecUninitialized
+	}
+	if len(pcm) == 0 {
+		return fmt.Errorf("opus: target buffer empty")
+	}
+	if cap(pcm)%dec.channels != 0 {
+		return fmt.Errorf("opus: output buffer capacity must be multiple of channels")
+	}
+	n := int(C.opus_decode_float(
+		dec.p,
+		nil,
+		0,
+		(*C.float)(&pcm[0]),
+		C.int(cap(pcm)/dec.channels),
+		0))
+	if n < 0 {
+		return Error(n)
+	}
+	return nil
+}
+
+// LastPacketDuration gets the duration (in samples)
+// of the last packet successfully decoded or concealed.
+func (dec *Decoder) LastPacketDuration() (int, error) {
+	var samples C.opus_int32
+	res := C.bridge_decoder_get_last_packet_duration(dec.p, &samples)
+	if res != C.OPUS_OK {
+		return 0, Error(res)
+	}
+	return int(samples), nil
+}