Audio formats

type Opus struct {
    // RTP payload type (96–127).
    PayloadTyp uint8

    // Number of audio channels (1 = mono, 2 = stereo).
    // Determined from the sprop-stereo fmtp parameter.
    ChannelCount int
}

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

// create decoder
rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

// called when a RTP packet arrives
c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        log.Printf("waiting for timestamp")
        return
    }

    // extract Opus packets from RTP packets
    op, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    log.Printf("received Opus packet with PTS %v size %d", pts, len(op))
})

type MPEG4Audio struct {
    // RTP payload type (96–127).
    PayloadTyp uint8

    ProfileLevelID   int

    // Parsed AudioSpecificConfig from the config fmtp parameter.
    // Contains sample rate, channel count, and codec profile.
    Config           *mpeg4audio.AudioSpecificConfig

    SizeLength       int
    IndexLength      int
    IndexDeltaLength int
}

// find the MPEG-4 audio media and format
var forma *format.MPEG4Audio
medi := desc.FindFormat(&forma)
if medi == nil {
    panic("media not found")
}

// create decoder
rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

// called when a RTP packet arrives
c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        log.Printf("waiting for timestamp")
        return
    }

    // extract access units from RTP packets
    aus, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    // one RTP packet may contain multiple access units
    for _, au := range aus {
        log.Printf("received access unit with PTS %v size %d", pts, len(au))
    }
})

type G711 struct {
    // RTP payload type.
    // Static: 0 (PCMU) or 8 (PCMA). Dynamic: 96–127.
    PayloadTyp uint8

    // MULaw selects mu-law encoding (PCMU). False selects A-law (PCMA).
    MULaw bool

    // Sample rate in Hz. Typically 8000.
    SampleRate int

    // Number of audio channels.
    ChannelCount int
}

// declare a PCMU stream for recording
forma := &format.G711{
    MULaw:        true, // PCMU
    SampleRate:   8000,
    ChannelCount: 1,
}

// — or detect while playing back —

var forma *format.G711
medi := desc.FindFormat(&forma)
if medi == nil {
    panic("media not found")
}

rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        return
    }

    samples, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    log.Printf("received G711 samples with PTS %v, size %d", pts, len(samples))
})

type LPCM struct {
    // RTP payload type.
    // Static: 10 (L16 stereo 44100 Hz) or 11 (L16 mono 44100 Hz).
    // Dynamic: 96–127 for L8, L16, or L24 at other rates.
    PayloadTyp uint8

    // Bit depth: 8, 16, or 24.
    BitDepth int

    // Sample rate in Hz.
    SampleRate int

    // Number of audio channels.
    ChannelCount int
}

// declare a 16-bit stereo 44100 Hz LPCM stream
forma := &format.LPCM{
    PayloadTyp:   96,
    BitDepth:     16,
    SampleRate:   44100,
    ChannelCount: 2,
}

// — or detect while playing back —

var forma *format.LPCM
medi := desc.FindFormat(&forma)
if medi == nil {
    panic("media not found")
}

rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        return
    }

    samples, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    log.Printf("received LPCM samples with PTS %v, size %d", pts, len(samples))
})

type AC3 struct {
    // RTP payload type (96–127).
    PayloadTyp uint8

    // Sample rate in Hz.
    SampleRate int

    // Number of audio channels. Defaults to 6 if omitted in SDP.
    ChannelCount int
}

var forma *format.AC3
medi := desc.FindFormat(&forma)
if medi == nil {
    panic("media not found")
}

rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        return
    }

    frame, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    log.Printf("received AC-3 frame with PTS %v, size %d", pts, len(frame))
})

// G722 has no configurable fields — payload type 9 is fixed by RFC 3551.
type G722 struct{}

var forma *format.G722
medi := desc.FindFormat(&forma)
if medi == nil {
    panic("media not found")
}

rtpDec, err := forma.CreateDecoder()
if err != nil {
    panic(err)
}

_, err = c.Setup(desc.BaseURL, medi, 0, 0)
if err != nil {
    panic(err)
}

c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
    pts, ok := c.PacketPTS(medi, pkt)
    if !ok {
        return
    }

    samples, err := rtpDec.Decode(pkt)
    if err != nil {
        log.Printf("ERR: %v", err)
        return
    }

    log.Printf("received G722 samples with PTS %v, size %d", pts, len(samples))
})