improve examples (#708)

examples/client-play-backchannel/main.go

@@ -1,63 +1,51 @@
 package main
 
 import (
+	"crypto/rand"
 	"log"
-	"net"
+	"time"
 
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/base"
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
-	"github.com/pion/rtp"
+	"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
 )
 
 // This example shows how to
-// 1. generate a G711 stream and RTP packets with GStreamer
+// 1. generate a dummy G711 audio stream
 // 2. connect to a RTSP server, find a back channel that supports G711
 // 3. route the packets from GStreamer to the channel
 
-func findPCMUBackChannel(desc *description.Session) *description.Media {
+func multiplyAndDivide(v, m, d int64) int64 {
+	secs := v / d
+	dec := v % d
+	return (secs*m + dec*m/d)
+}
+
+func randUint32() (uint32, error) {
+	var b [4]byte
+	_, err := rand.Read(b[:])
+	if err != nil {
+		return 0, err
+	}
+	return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3]), nil
+}
+
+func findG711BackChannel(desc *description.Session) (*description.Media, *format.G711) {
 	for _, media := range desc.Medias {
 		if media.IsBackChannel {
 			for _, forma := range media.Formats {
 				if g711, ok := forma.(*format.G711); ok {
-					if g711.MULaw {
-						return media
-					}
+					return media, g711
 				}
 			}
 		}
 	}
-	return nil
+	return nil, nil
 }
 
 func main() {
-	// open a listener to receive RTP/G711 packets
-	pc, err := net.ListenPacket("udp", "localhost:9000")
-	if err != nil {
-		panic(err)
-	}
-	defer pc.Close()
-
-	log.Println("Waiting for a RTP/G711 stream on UDP port 9000 - you can generate one with GStreamer:\n\n" +
-		"* audio from a test sine:\n\n" +
-		"gst-launch-1.0 audiotestsrc freq=300 ! audioconvert ! audioresample ! audio/x-raw,rate=8000" +
-		" ! mulawenc ! rtppcmupay ! udpsink host=127.0.0.1 port=9000\n\n" +
-		"* audio from a file:\n\n" +
-		"gst-launch-1.0 filesrc location=my_file.mp4 ! decodebin ! audioconvert ! audioresample ! audio/x-raw,rate=8000" +
-		" ! mulawenc ! rtppcmupay ! udpsink host=127.0.0.1 port=9000\n\n" +
-		"* audio from a microphone:\n\n" +
-		"gst-launch-1.0 pulsesrc ! audioconvert ! audioresample ! audio/x-raw,rate=8000" +
-		" ! mulawenc ! rtppcmupay ! udpsink host=127.0.0.1 port=9000\n")
-
-	// wait for first packet
-	buf := make([]byte, 2048)
-	n, _, err := pc.ReadFrom(buf)
-	if err != nil {
-		panic(err)
-	}
-	log.Println("stream connected")
-
 	c := gortsplib.Client{
 		RequestBackChannels: true,
 	}
@@ -82,7 +70,7 @@ func main() {
 	}
 
 	// find the back channel
-	medi := findPCMUBackChannel(desc)
+	medi, forma := findG711BackChannel(desc)
 	if medi == nil {
 		panic("media not found")
 	}
@@ -99,24 +87,62 @@ func main() {
 		panic(err)
 	}
 
-	var pkt rtp.Packet
-	for {
-		// parse RTP packet
-		err = pkt.Unmarshal(buf[:n])
+	// setup G711 -> RTP encoder
+	rtpEnc, err := forma.CreateEncoder()
+	if err != nil {
+		panic(err)
+	}
+
+	start := time.Now()
+	prevPTS := int64(0)
+
+	randomStart, err := randUint32()
+	if err != nil {
+		panic(err)
+	}
+
+	// setup a ticker to sleep between writings
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		// get current timestamp
+		pts := multiplyAndDivide(int64(time.Since(start)), int64(forma.ClockRate()), int64(time.Second))
+
+		// generate dummy LPCM audio samples
+		samples := createDummyAudio(pts, prevPTS)
+
+		// encode samples with G711
+		if forma.MULaw {
+			samples, err = g711.Mulaw(samples).Marshal()
+			if err != nil {
+				panic(err)
+			}
+		} else {
+			samples, err = g711.Alaw(samples).Marshal()
+			if err != nil {
+				panic(err)
+			}
+		}
+
+		// generate RTP packets from G711 samples
+		pkts, err := rtpEnc.Encode(samples)
 		if err != nil {
 			panic(err)
 		}
 
-		// route RTP packet to the server
-		err = c.WritePacketRTP(medi, &pkt)
-		if err != nil {
-			panic(err)
+		log.Printf("writing RTP packets with PTS=%d, sample size=%d, pkt count=%d", prevPTS, len(samples), len(pkts))
+
+		// write RTP packets to the server
+		for _, pkt := range pkts {
+			pkt.Timestamp += uint32(int64(randomStart) + prevPTS)
+
+			err = c.WritePacketRTP(desc.Medias[0], pkt)
+			if err != nil {
+				panic(err)
+			}
 		}
 
-		// read another RTP packet from source
-		n, _, err = pc.ReadFrom(buf)
-		if err != nil {
-			panic(err)
-		}
+		prevPTS = pts
 	}
 }