package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 15:16:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

rename 'track' references into 'format'

Browse Source
This commit is contained in:
aler9
2022-12-13 18:06:41 +01:00
parent 50d6b2e916
commit 38b24b8e26
32 changed files with 123 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
client.go
View File

@@ -1574,9 +1574,9 @@ func (c *Client) Seek(ra *headers.Range) (*base.Response, error) {
func (c *Client) OnPacketRTPAny(cb func(*media.Media, format.Format, *rtp.Packet)) { func (c *Client) OnPacketRTPAny(cb func(*media.Media, format.Format, *rtp.Packet)) {
for _, cm := range c.medias { for _, cm := range c.medias {
cmedia := cm.media cmedia := cm.media
for _, trak := range cm.media.Formats { for _, forma := range cm.media.Formats {
c.OnPacketRTP(cm.media, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(cm.media, forma, func(pkt *rtp.Packet) {
cb(cmedia, trak, pkt) cb(cmedia, forma, pkt)
}) })
} }
} }
@@ -1593,9 +1593,9 @@ func (c *Client) OnPacketRTCPAny(cb func(*media.Media, rtcp.Packet)) {
} }
// OnPacketRTP sets the callback that is called when a RTP packet is read. // OnPacketRTP sets the callback that is called when a RTP packet is read.
func (c *Client) OnPacketRTP(medi *media.Media, trak format.Format, cb func(*rtp.Packet)) { func (c *Client) OnPacketRTP(medi *media.Media, forma format.Format, cb func(*rtp.Packet)) {
cm := c.medias[medi] cm := c.medias[medi]
ct := cm.formats[trak.PayloadType()] ct := cm.formats[forma.PayloadType()]
ct.onPacketRTP = cb ct.onPacketRTP = cb
} }

28
client_play_test.go
View File

@@ -267,16 +267,16 @@ func TestClientPlay(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL(scheme+"://"+listenIP+":8554/test/stream?param=value"), req.URL) require.Equal(t, mustParseURL(scheme+"://"+listenIP+":8554/test/stream?param=value"), req.URL)
trak := &format.Generic{ forma := &format.Generic{
PayloadTyp: 96, PayloadTyp: 96,
RTPMap: "private/90000", RTPMap: "private/90000",
} }
err = trak.Init() err = forma.Init()
require.NoError(t, err) require.NoError(t, err)
medias := media.Medias{{ medias := media.Medias{{
Type: "application", Type: "application",
Formats: []format.Format{trak}, Formats: []format.Format{forma},
}} }}
medias.SetControls() medias.SetControls()
@@ -466,7 +466,7 @@ func TestClientPlay(t *testing.T) {
err = readAll(&c, err = readAll(&c,
scheme+"://"+listenIP+":8554/test/stream?param=value", scheme+"://"+listenIP+":8554/test/stream?param=value",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
require.Equal(t, &testRTPPacket, pkt) require.Equal(t, &testRTPPacket, pkt)
err := c.WritePacketRTCP(medi, &testRTCPPacket) err := c.WritePacketRTCP(medi, &testRTCPPacket)
require.NoError(t, err) require.NoError(t, err)
@@ -608,9 +608,9 @@ func TestClientPlayPartial(t *testing.T) {
_, err = c.Setup(medias[1], baseURL, 0, 0) _, err = c.Setup(medias[1], baseURL, 0, 0)
require.NoError(t, err) require.NoError(t, err)
c.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { c.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
require.Equal(t, medias[1], medi) require.Equal(t, medias[1], medi)
require.Equal(t, medias[1].Formats[0], trak) require.Equal(t, medias[1].Formats[0], forma)
require.Equal(t, &testRTPPacket, pkt) require.Equal(t, &testRTPPacket, pkt)
close(packetRecv) close(packetRecv)
}) })
@@ -892,7 +892,7 @@ func TestClientPlayAnyPort(t *testing.T) {
var med *media.Media var med *media.Media
err = readAll(&c, "rtsp://localhost:8554/teststream", err = readAll(&c, "rtsp://localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
require.Equal(t, &testRTPPacket, pkt) require.Equal(t, &testRTPPacket, pkt)
med = medi med = medi
close(packetRecv) close(packetRecv)
@@ -1012,7 +1012,7 @@ func TestClientPlayAutomaticProtocol(t *testing.T) {
c := Client{} c := Client{}
err = readAll(&c, "rtsp://localhost:8554/teststream", err = readAll(&c, "rtsp://localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
close(packetRecv) close(packetRecv)
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1245,7 +1245,7 @@ func TestClientPlayAutomaticProtocol(t *testing.T) {
} }
err = readAll(&c, "rtsp://myuser:mypass@localhost:8554/teststream", err = readAll(&c, "rtsp://myuser:mypass@localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
close(packetRecv) close(packetRecv)
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1367,7 +1367,7 @@ func TestClientPlayDifferentInterleavedIDs(t *testing.T) {
} }
err = readAll(&c, "rtsp://localhost:8554/teststream", err = readAll(&c, "rtsp://localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
close(packetRecv) close(packetRecv)
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1554,7 +1554,7 @@ func TestClientPlayRedirect(t *testing.T) {
ru = "rtsp://testusr:testpwd@localhost:8554/path1" ru = "rtsp://testusr:testpwd@localhost:8554/path1"
} }
err = readAll(&c, ru, err = readAll(&c, ru,
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
close(packetRecv) close(packetRecv)
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1754,7 +1754,7 @@ func TestClientPlayPause(t *testing.T) {
} }
err = readAll(&c, "rtsp://localhost:8554/teststream", err = readAll(&c, "rtsp://localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
if atomic.SwapInt32(&firstFrame, 1) == 0 { if atomic.SwapInt32(&firstFrame, 1) == 0 {
close(packetRecv) close(packetRecv)
} }
@@ -2218,7 +2218,7 @@ func TestClientPlayIgnoreTCPInvalidMedia(t *testing.T) {
} }
err = readAll(&c, "rtsp://localhost:8554/teststream", err = readAll(&c, "rtsp://localhost:8554/teststream",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
close(recv) close(recv)
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -2636,7 +2636,7 @@ func TestClientPlayDifferentSource(t *testing.T) {
} }
err = readAll(&c, "rtsp://localhost:8554/test/stream?param=value", err = readAll(&c, "rtsp://localhost:8554/test/stream?param=value",
func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
require.Equal(t, &testRTPPacket, pkt) require.Equal(t, &testRTPPacket, pkt)
close(packetRecv) close(packetRecv)
}) })

12
clientmedia.go
View File

@@ -71,8 +71,8 @@ func (cm *clientMedia) setMedia(medi *media.Media) {
cm.media = medi cm.media = medi
cm.formats = make(map[uint8]*clientFormat) cm.formats = make(map[uint8]*clientFormat)
for _, trak := range medi.Formats { for _, forma := range medi.Formats {
cm.formats[trak.PayloadType()] = newClientFormat(cm, trak) cm.formats[forma.PayloadType()] = newClientFormat(cm, forma)
} }
} }
@@ -193,12 +193,12 @@ func (cm *clientMedia) readRTPTCPPlay(payload []byte) error {
return err return err
} }
trak, ok := cm.formats[pkt.PayloadType] forma, ok := cm.formats[pkt.PayloadType]
if !ok { if !ok {
return nil return nil
} }
trak.readRTPTCP(pkt) forma.readRTPTCP(pkt)
return nil return nil
} }
@@ -266,13 +266,13 @@ func (cm *clientMedia) readRTPUDPPlay(payload []byte) error {
return nil return nil
} }
trak, ok := cm.formats[pkt.PayloadType] forma, ok := cm.formats[pkt.PayloadType]
if !ok { if !ok {
cm.c.OnDecodeError(fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType)) cm.c.OnDecodeError(fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
return nil return nil
} }
trak.readRTPUDP(pkt) forma.readRTPUDP(pkt)
return nil return nil
} }

4
clienttrack.go
View File

@@ -23,11 +23,11 @@ type clientFormat struct {
onPacketRTP func(*rtp.Packet) onPacketRTP func(*rtp.Packet)
} }
func newClientFormat(cm *clientMedia, trak format.Format) *clientFormat { func newClientFormat(cm *clientMedia, forma format.Format) *clientFormat {
return &clientFormat{ return &clientFormat{
c: cm.c, c: cm.c,
cm: cm, cm: cm,
format: trak, format: forma,
onPacketRTP: func(*rtp.Packet) {}, onPacketRTP: func(*rtp.Packet) {},
} }
} }

8
examples/client-read-format-g711/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the G711 media and format // find the G711 media and format
var trak *format.G711 var forma *format.G711
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode a G711 packet from the RTP packet // decode a G711 packet from the RTP packet
op, _, err := rtpDec.Decode(pkt) op, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-g722/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the G722 media and format // find the G722 media and format
var trak *format.G722 var forma *format.G722
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode a G722 packet from the RTP packet // decode a G722 packet from the RTP packet
op, _, err := rtpDec.Decode(pkt) op, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

12
examples/client-read-format-h264-convert-to-jpeg/main.go
View File

@@ -63,14 +63,14 @@ func main() {
} }
// find the H264 media and format // find the H264 media and format
var trak *format.H264 var forma *format.H264
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup RTP/H264->H264 decoder // setup RTP/H264->H264 decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup H264->raw frames decoder // setup H264->raw frames decoder
h264RawDec, err := newH264Decoder() h264RawDec, err := newH264Decoder()
@@ -80,11 +80,11 @@ func main() {
defer h264RawDec.close() defer h264RawDec.close()
// if SPS and PPS are present into the SDP, send them to the decoder // if SPS and PPS are present into the SDP, send them to the decoder
sps := trak.SafeSPS() sps := forma.SafeSPS()
if sps != nil { if sps != nil {
h264RawDec.decode(sps) h264RawDec.decode(sps)
} }
pps := trak.SafePPS() pps := forma.SafePPS()
if pps != nil { if pps != nil {
h264RawDec.decode(pps) h264RawDec.decode(pps)
} }
@@ -97,7 +97,7 @@ func main() {
// called when a RTP packet arrives // called when a RTP packet arrives
saveCount := 0 saveCount := 0
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// convert RTP packets into NALUs // convert RTP packets into NALUs
nalus, _, err := rtpDec.Decode(pkt) nalus, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

10
examples/client-read-format-h264-save-to-disk/main.go
View File

@@ -35,17 +35,17 @@ func main() {
} }
// find the H264 media and format // find the H264 media and format
var trak *format.H264 var forma *format.H264
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup RTP/H264->H264 decoder // setup RTP/H264->H264 decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup H264->MPEGTS muxer // setup H264->MPEGTS muxer
mpegtsMuxer, err := newMPEGTSMuxer(trak.SafeSPS(), trak.SafePPS()) mpegtsMuxer, err := newMPEGTSMuxer(forma.SafeSPS(), forma.SafePPS())
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -57,7 +57,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// convert RTP packets into NALUs // convert RTP packets into NALUs
nalus, pts, err := rtpDec.Decode(pkt) nalus, pts, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

12
examples/client-read-format-h264/main.go
View File

@@ -40,14 +40,14 @@ func main() {
} }
// find the H264 media and format // find the H264 media and format
var trak *format.H264 var forma *format.H264
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup RTP/H264->H264 decoder // setup RTP/H264->H264 decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup H264->raw frames decoder // setup H264->raw frames decoder
h264RawDec, err := newH264Decoder() h264RawDec, err := newH264Decoder()
@@ -57,11 +57,11 @@ func main() {
defer h264RawDec.close() defer h264RawDec.close()
// if SPS and PPS are present into the SDP, send them to the decoder // if SPS and PPS are present into the SDP, send them to the decoder
sps := trak.SafeSPS() sps := forma.SafeSPS()
if sps != nil { if sps != nil {
h264RawDec.decode(sps) h264RawDec.decode(sps)
} }
pps := trak.SafePPS() pps := forma.SafePPS()
if pps != nil { if pps != nil {
h264RawDec.decode(pps) h264RawDec.decode(pps)
} }
@@ -73,7 +73,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// convert RTP packets into NALUs // convert RTP packets into NALUs
nalus, _, err := rtpDec.Decode(pkt) nalus, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-h265/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the H265 media and format // find the H265 media and format
var trak *format.H265 var forma *format.H265
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup RTP/H265->H265 decoder // setup RTP/H265->H265 decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// convert RTP packets into NALUs // convert RTP packets into NALUs
nalus, pts, err := rtpDec.Decode(pkt) nalus, pts, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-lpcm/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the LPCM media and format // find the LPCM media and format
var trak *format.LPCM var forma *format.LPCM
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode LPCM samples from the RTP packet // decode LPCM samples from the RTP packet
op, _, err := rtpDec.Decode(pkt) op, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-mpeg4audio/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the MPEG4-audio media and format // find the MPEG4-audio media and format
var trak *format.MPEG4Audio var forma *format.MPEG4Audio
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode MPEG4-audio AUs from the RTP packet // decode MPEG4-audio AUs from the RTP packet
aus, _, err := rtpDec.Decode(pkt) aus, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-opus/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the Opus media and format // find the Opus media and format
var trak *format.Opus var forma *format.Opus
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode an Opus packet from the RTP packet // decode an Opus packet from the RTP packet
op, _, err := rtpDec.Decode(pkt) op, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-vp8/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the VP8 media and format // find the VP8 media and format
var trak *format.VP8 var forma *format.VP8
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode a VP8 frame from the RTP packet // decode a VP8 frame from the RTP packet
vf, _, err := rtpDec.Decode(pkt) vf, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

8
examples/client-read-format-vp9/main.go
View File

@@ -37,14 +37,14 @@ func main() {
} }
// find the VP9 media and format // find the VP9 media and format
var trak *format.VP9 var forma *format.VP9
medi := medias.FindFormat(&trak) medi := medias.FindFormat(&forma)
if medi == nil { if medi == nil {
panic("media not found") panic("media not found")
} }
// setup decoder // setup decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup the chosen media only // setup the chosen media only
_, err = c.Setup(medi, baseURL, 0, 0) _, err = c.Setup(medi, baseURL, 0, 0)
@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTP(medi, trak, func(pkt *rtp.Packet) { c.OnPacketRTP(medi, forma, func(pkt *rtp.Packet) {
// decode a VP9 frame from the RTP packet // decode a VP9 frame from the RTP packet
vf, _, err := rtpDec.Decode(pkt) vf, _, err := rtpDec.Decode(pkt)
if err != nil { if err != nil {

2
examples/client-read-options/main.go
View File

@@ -53,7 +53,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { c.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
log.Printf("RTP packet from media %v\n", medi) log.Printf("RTP packet from media %v\n", medi)
}) })

2
examples/client-read-pause/main.go
View File

@@ -47,7 +47,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { c.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
log.Printf("RTP packet from media %v\n", medi) log.Printf("RTP packet from media %v\n", medi)
}) })

2
examples/client-read-republish/main.go
View File

@@ -53,7 +53,7 @@ func main() {
} }
// read RTP packets from reader and write them to publisher // read RTP packets from reader and write them to publisher
reader.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { reader.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
publisher.WritePacketRTP(medi, pkt) publisher.WritePacketRTP(medi, pkt)
}) })

2
examples/client-read/main.go
View File

@@ -43,7 +43,7 @@ func main() {
} }
// called when a RTP packet arrives // called when a RTP packet arrives
c.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { c.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
log.Printf("RTP packet from media %v\n", medi) log.Printf("RTP packet from media %v\n", medi)
}) })

10
examples/server-h264-save-to-disk/main.go
View File

@@ -67,8 +67,8 @@ func (sh *serverHandler) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (
} }
// find the H264 media and format // find the H264 media and format
var trak *format.H264 var forma *format.H264
medi := ctx.Medias.FindFormat(&trak) medi := ctx.Medias.FindFormat(&forma)
if medi == nil { if medi == nil {
return &base.Response{ return &base.Response{
StatusCode: base.StatusBadRequest, StatusCode: base.StatusBadRequest,
@@ -76,10 +76,10 @@ func (sh *serverHandler) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (
} }
// setup RTP/H264->H264 decoder // setup RTP/H264->H264 decoder
rtpDec := trak.CreateDecoder() rtpDec := forma.CreateDecoder()
// setup H264->MPEGTS muxer // setup H264->MPEGTS muxer
mpegtsMuxer, err := newMPEGTSMuxer(trak.SafeSPS(), trak.SafePPS()) mpegtsMuxer, err := newMPEGTSMuxer(forma.SafeSPS(), forma.SafePPS())
if err != nil { if err != nil {
return &base.Response{ return &base.Response{
StatusCode: base.StatusBadRequest, StatusCode: base.StatusBadRequest,
@@ -88,7 +88,7 @@ func (sh *serverHandler) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (
sh.publisher = ctx.Session sh.publisher = ctx.Session
sh.media = medi sh.media = medi
sh.format = trak sh.format = forma
sh.rtpDec = rtpDec sh.rtpDec = rtpDec
sh.mpegtsMuxer = mpegtsMuxer sh.mpegtsMuxer = mpegtsMuxer

2
examples/server-tls/main.go
View File

@@ -126,7 +126,7 @@ func (sh *serverHandler) OnRecord(ctx *gortsplib.ServerHandlerOnRecordCtx) (*bas
log.Printf("record request") log.Printf("record request")
// called when receiving a RTP packet // called when receiving a RTP packet
ctx.Session.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { ctx.Session.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
// route the RTP packet to all readers // route the RTP packet to all readers
sh.stream.WritePacketRTP(medi, pkt) sh.stream.WritePacketRTP(medi, pkt)
}) })

2
examples/server/main.go
View File

@@ -125,7 +125,7 @@ func (sh *serverHandler) OnRecord(ctx *gortsplib.ServerHandlerOnRecordCtx) (*bas
log.Printf("record request") log.Printf("record request")
// called when receiving a RTP packet // called when receiving a RTP packet
ctx.Session.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { ctx.Session.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
// route the RTP packet to all readers // route the RTP packet to all readers
sh.stream.WritePacketRTP(medi, pkt) sh.stream.WritePacketRTP(medi, pkt)
}) })

2
internal/highleveltests/server_test.go
View File

@@ -385,7 +385,7 @@ func TestServerRecordRead(t *testing.T) {
}, fmt.Errorf("invalid query (%s)", ctx.Query) }, fmt.Errorf("invalid query (%s)", ctx.Query)
} }
ctx.Session.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { ctx.Session.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
stream.WritePacketRTP(medi, pkt) stream.WritePacketRTP(medi, pkt)
}) })

6
pkg/media/media.go
View File

@@ -79,11 +79,11 @@ func (m *Media) Marshal() *psdp.MediaDescription {
}, },
} }
for _, trak := range m.Formats { for _, forma := range m.Formats {
typ := strconv.FormatUint(uint64(trak.PayloadType()), 10) typ := strconv.FormatUint(uint64(forma.PayloadType()), 10)
md.MediaName.Formats = append(md.MediaName.Formats, typ) md.MediaName.Formats = append(md.MediaName.Formats, typ)
rtpmap, fmtp := trak.Marshal() rtpmap, fmtp := forma.Marshal()
if rtpmap != "" { if rtpmap != "" {
md.Attributes = append(md.Attributes, psdp.Attribute{ md.Attributes = append(md.Attributes, psdp.Attribute{

10
pkg/media/medias.go
View File

@@ -90,12 +90,12 @@ func (ms Medias) SetControls() {
} }
// FindFormat finds a certain format among all the formats in all the medias. // FindFormat finds a certain format among all the formats in all the medias.
// If the format is found, it is inserted into trak, and format media is returned. // If the format is found, it is inserted into forma, and format media is returned.
func (ms Medias) FindFormat(trak interface{}) *Media { func (ms Medias) FindFormat(forma interface{}) *Media {
for _, media := range ms { for _, media := range ms {
for _, trakk := range media.Formats { for _, formak := range media.Formats {
if reflect.TypeOf(trakk) == reflect.TypeOf(trak).Elem() { if reflect.TypeOf(formak) == reflect.TypeOf(forma).Elem() {
reflect.ValueOf(trak).Elem().Set(reflect.ValueOf(trakk)) reflect.ValueOf(forma).Elem().Set(reflect.ValueOf(formak))
return media return media
} }
} }

6
pkg/media/medias_test.go
View File

@@ -481,8 +481,8 @@ func TestMediasFindFormat(t *testing.T) {
md, md,
} }
var trak *format.Generic var forma *format.Generic
me := ms.FindFormat(&trak) me := ms.FindFormat(&forma)
require.Equal(t, md, me) require.Equal(t, md, me)
require.Equal(t, tr, trak) require.Equal(t, tr, forma)
} }

6
server_play_test.go
View File

@@ -1939,16 +1939,16 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
return &ri, ssrcs return &ri, ssrcs
} }
trak := &format.Generic{ forma := &format.Generic{
PayloadTyp: 96, PayloadTyp: 96,
RTPMap: "private/90000", RTPMap: "private/90000",
} }
err := trak.Init() err := forma.Init()
require.NoError(t, err) require.NoError(t, err)
medi := &media.Media{ medi := &media.Media{
Type: "application", Type: "application",
Formats: []format.Format{trak}, Formats: []format.Format{forma},
} }
stream := NewServerStream(media.Medias{medi.Clone(), medi.Clone()}) stream := NewServerStream(media.Medias{medi.Clone(), medi.Clone()})

4
server_record_test.go
View File

@@ -500,9 +500,9 @@ func TestServerRecord(t *testing.T) {
// these are sent after the response, only if onRecord returns StatusOK. // these are sent after the response, only if onRecord returns StatusOK.
ctx.Session.WritePacketRTCP(ctx.Session.AnnouncedMedias()[0], &testRTCPPacket) ctx.Session.WritePacketRTCP(ctx.Session.AnnouncedMedias()[0], &testRTCPPacket)
ctx.Session.OnPacketRTPAny(func(medi *media.Media, trak format.Format, pkt *rtp.Packet) { ctx.Session.OnPacketRTPAny(func(medi *media.Media, forma format.Format, pkt *rtp.Packet) {
require.Equal(t, ctx.Session.AnnouncedMedias()[0], medi) require.Equal(t, ctx.Session.AnnouncedMedias()[0], medi)
require.Equal(t, ctx.Session.AnnouncedMedias()[0].Formats[0], trak) require.Equal(t, ctx.Session.AnnouncedMedias()[0].Formats[0], forma)
require.Equal(t, &testRTPPacket, pkt) require.Equal(t, &testRTPPacket, pkt)
}) })

14
serversession.go
View File

@@ -747,8 +747,8 @@ func (ss *ServerSession) handleRequest(sc *ServerConn, req *base.Request) (*base
if ss.state == ServerSessionStatePreRecord { if ss.state == ServerSessionStatePreRecord {
sm.formats = make(map[uint8]*serverSessionFormat) sm.formats = make(map[uint8]*serverSessionFormat)
for _, trak := range sm.media.Formats { for _, forma := range sm.media.Formats {
sm.formats[trak.PayloadType()] = newServerSessionFormat(sm, trak) sm.formats[forma.PayloadType()] = newServerSessionFormat(sm, forma)
} }
} }
@@ -1090,9 +1090,9 @@ func (ss *ServerSession) handleRequest(sc *ServerConn, req *base.Request) (*base
func (ss *ServerSession) OnPacketRTPAny(cb func(*media.Media, format.Format, *rtp.Packet)) { func (ss *ServerSession) OnPacketRTPAny(cb func(*media.Media, format.Format, *rtp.Packet)) {
for _, sm := range ss.setuppedMedias { for _, sm := range ss.setuppedMedias {
cmedia := sm.media cmedia := sm.media
for _, trak := range sm.media.Formats { for _, forma := range sm.media.Formats {
ss.OnPacketRTP(sm.media, trak, func(pkt *rtp.Packet) { ss.OnPacketRTP(sm.media, forma, func(pkt *rtp.Packet) {
cb(cmedia, trak, pkt) cb(cmedia, forma, pkt)
}) })
} }
} }
@@ -1109,9 +1109,9 @@ func (ss *ServerSession) OnPacketRTCPAny(cb func(*media.Media, rtcp.Packet)) {
} }
// OnPacketRTP sets the callback that is called when a RTP packet is read. // OnPacketRTP sets the callback that is called when a RTP packet is read.
func (ss *ServerSession) OnPacketRTP(medi *media.Media, trak format.Format, cb func(*rtp.Packet)) { func (ss *ServerSession) OnPacketRTP(medi *media.Media, forma format.Format, cb func(*rtp.Packet)) {
sm := ss.setuppedMedias[medi] sm := ss.setuppedMedias[medi]
st := sm.formats[trak.PayloadType()] st := sm.formats[forma.PayloadType()]
st.onPacketRTP = cb st.onPacketRTP = cb
} }

8
serversessionmedia.go
View File

@@ -192,7 +192,7 @@ func (sm *serverSessionMedia) readRTPUDPRecord(payload []byte) error {
return nil return nil
} }
trak, ok := sm.formats[pkt.PayloadType] forma, ok := sm.formats[pkt.PayloadType]
if !ok { if !ok {
onDecodeError(sm.ss, fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType)) onDecodeError(sm.ss, fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
return nil return nil
@@ -201,7 +201,7 @@ func (sm *serverSessionMedia) readRTPUDPRecord(payload []byte) error {
now := time.Now() now := time.Now()
atomic.StoreInt64(sm.ss.udpLastPacketTime, now.Unix()) atomic.StoreInt64(sm.ss.udpLastPacketTime, now.Unix())
trak.readRTPUDP(pkt, now) forma.readRTPUDP(pkt, now)
return nil return nil
} }
@@ -271,13 +271,13 @@ func (sm *serverSessionMedia) readRTPTCPRecord(payload []byte) error {
return err return err
} }
trak, ok := sm.formats[pkt.PayloadType] forma, ok := sm.formats[pkt.PayloadType]
if !ok { if !ok {
onDecodeError(sm.ss, fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType)) onDecodeError(sm.ss, fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
return nil return nil
} }
trak.readRTPTCP(pkt) forma.readRTPTCP(pkt)
return nil return nil
} }

4
serversessiontrack.go
View File

@@ -19,10 +19,10 @@ type serverSessionFormat struct {
onPacketRTP func(*rtp.Packet) onPacketRTP func(*rtp.Packet)
} }
func newServerSessionFormat(sm *serverSessionMedia, trak format.Format) *serverSessionFormat { func newServerSessionFormat(sm *serverSessionMedia, forma format.Format) *serverSessionFormat {
return &serverSessionFormat{ return &serverSessionFormat{
sm: sm, sm: sm,
format: trak, format: forma,
onPacketRTP: func(*rtp.Packet) {}, onPacketRTP: func(*rtp.Packet) {},
} }
} }

12
serverstream.go
View File

@@ -43,20 +43,20 @@ func NewServerStream(medias media.Medias) *ServerStream {
ssm := &serverStreamMedia{} ssm := &serverStreamMedia{}
ssm.formats = make(map[uint8]*serverStreamFormat) ssm.formats = make(map[uint8]*serverStreamFormat)
for _, trak := range media.Formats { for _, forma := range media.Formats {
tr := &serverStreamFormat{ tr := &serverStreamFormat{
format: trak, format: forma,
} }
cmedia := media cmedia := media
tr.rtcpSender = rtcpsender.New( tr.rtcpSender = rtcpsender.New(
trak.ClockRate(), forma.ClockRate(),
func(pkt rtcp.Packet) { func(pkt rtcp.Packet) {
st.WritePacketRTCP(cmedia, pkt) st.WritePacketRTCP(cmedia, pkt)
}, },
) )
ssm.formats[trak.PayloadType()] = tr ssm.formats[forma.PayloadType()] = tr
} }
st.streamMedias[media] = ssm st.streamMedias[media] = ssm
@@ -295,9 +295,9 @@ func (st *ServerStream) WritePacketRTPWithNTP(medi *media.Media, pkt *rtp.Packet
sm := st.streamMedias[medi] sm := st.streamMedias[medi]
trak := sm.formats[pkt.PayloadType] forma := sm.formats[pkt.PayloadType]
trak.rtcpSender.ProcessPacket(pkt, ntp, trak.format.PTSEqualsDTS(pkt)) forma.rtcpSender.ProcessPacket(pkt, ntp, forma.format.PTSEqualsDTS(pkt))
// send unicast // send unicast
for r := range st.activeUnicastReaders { for r := range st.activeUnicastReaders {