RTSP G711 track to WAV file

[cedricve]

Hello all, I'm currently experimenting with some audio codecs (and still learning). While using gortsplib I'm able to read the PCM stream of an IP camera, using the codec I understand there is the sampleRate, Clock, and more.

I'm now trying to understand how I can write this PCM (RTP packets) to a valid wav file. So instead of just recording audio and video, I would like to retrieve only the audio.

[cedricve]

I tried it with this example code, but not sure what I'm missing (https://github.com/bluenviron/gortsplib/blob/main/examples/client-read-format-g711/main.go). I believe the library github.com/youpy/go-wav expect a finished "PCM" file, as it includes the total payload size in the WAVE header. https://github.com/youpy/go-wav/blob/master/writer.go#L22

	package main

	import (
		"log"
		"os"

		"github.com/bluenviron/gortsplib/v3"
		"github.com/bluenviron/gortsplib/v3/pkg/formats"
		"github.com/bluenviron/gortsplib/v3/pkg/url"
		"github.com/pion/rtp"
		"github.com/youpy/go-wav"
	)

	// This example shows how to
	// 1. connect to a RTSP server
	// 2. check if there's a G711 media
	// 3. get G711 frames of that media

	func main() {
		c := gortsplib.Client{}

		// parse URL
		u, err := url.Parse("rtsp://xxx:554")
		if err != nil {
			panic(err)
		}

		// connect to the server
		err = c.Start(u.Scheme, u.Host)
		if err != nil {
			panic(err)
		}
		defer c.Close()

		// find published medias
		medias, baseURL, _, err := c.Describe(u)
		if err != nil {
			panic(err)
		}

		// find the G711 media and format
		var forma *formats.G711
		medi := medias.FindFormat(&forma)
		if medi == nil {
			panic("media not found")
		}

		// create decoder
		rtpDec := forma.CreateDecoder()

		// setup a single media
		_, err = c.Setup(medi, baseURL, 0, 0)
		if err != nil {
			panic(err)
		}

		// Create PCM file
		f, err := os.Create("out.pcm")
		if err != nil {
			panic(err)
		}
		defer f.Close()

		// Create a WAV file
		f2, err := os.Create("out.wav")
		if err != nil {
			panic(err)
		}
		defer f2.Close()

		// Use go-wav to encde the PCM file to WAV
                     //
		wavOut := wav.NewWriter(f2, 0, 1, uint32(rtpDec.SampleRate), 16)

		// called when a RTP packet arrives
		c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
			// extract G711 frames from RTP packets
			op, _, err := rtpDec.Decode(pkt)
			if err != nil {
				log.Printf("ERR: %v", err)
				return
			}

			// write to wav
			wavOut.Write(op)

			// print
			log.Printf("received G711 frame of size %d\n", len(op))
		})

		// start playing
		_, err = c.Play(nil)
		if err != nil {
			panic(err)
		}

		// wait until a fatal error
		panic(c.Wait())
	}

[aler9]

Hello, in my opinion you can dynamically update the sample count in the WAV file header by overriding the header by using Seek() on the file:

wavOut.Write(op)

// place pointer at the beginning of the file in order to override the header
f2.Seek(0, 0)

blockAlign := numChannels * bitsPerSample / 8
byteRate := sampleRate * uint32(blockAlign)
format := &WavFormat{AudioFormatPCM, numChannels, sampleRate, byteRate, blockAlign, bitsPerSample}
dataSize := numSamples * uint32(format.BlockAlign)
riffSize := 4 + 8 + 16 + 8 + dataSize
riffWriter := riff.NewWriter(f2, []byte("WAVE"), riffSize)
writer = &Writer{riffWriter, format}
riffWriter.WriteChunk([]byte("fmt "), 16, func(w io.Writer) {
	binary.Write(w, binary.LittleEndian, format)
})

// place pointer at the end of the file in order to continue writing
f2.Seek(0, io.SeekEnd)

...

// repeat

I took the header code from the library:
https://github.com/youpy/go-wav/blob/780d56edb16de52d690ed9db9af90b456e5b1367/writer.go#L16