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

support h264 tracks with extradata in sprop-parameter-sets

Browse Source
This commit is contained in:
aler9
2022-01-30 15:46:37 +01:00
committed by Alessandro Ros
parent 5aefa9e271
commit ad69a8957b
11 changed files with 88 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
client_publish_test.go
View File

@@ -201,7 +201,7 @@ func TestClientPublishSerial(t *testing.T) {
}, },
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
err = c.StartPublishing(scheme+"://localhost:8554/teststream", err = c.StartPublishing(scheme+"://localhost:8554/teststream",
@@ -358,7 +358,7 @@ func TestClientPublishParallel(t *testing.T) {
}(), }(),
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
writerDone := make(chan struct{}) writerDone := make(chan struct{})
@@ -523,7 +523,7 @@ func TestClientPublishPauseSerial(t *testing.T) {
}(), }(),
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
err = c.StartPublishing("rtsp://localhost:8554/teststream", err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -662,7 +662,7 @@ func TestClientPublishPauseParallel(t *testing.T) {
}(), }(),
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
err = c.StartPublishing("rtsp://localhost:8554/teststream", err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -807,7 +807,7 @@ func TestClientPublishAutomaticProtocol(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
}() }()
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
c := Client{} c := Client{}
@@ -950,7 +950,7 @@ func TestClientPublishRTCPReport(t *testing.T) {
udpSenderReportPeriod: 1 * time.Second, udpSenderReportPeriod: 1 * time.Second,
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
err = c.StartPublishing("rtsp://localhost:8554/teststream", err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -1094,7 +1094,7 @@ func TestClientPublishIgnoreTCPRTPPackets(t *testing.T) {
}, },
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
err = c.StartPublishing("rtsp://localhost:8554/teststream", err = c.StartPublishing("rtsp://localhost:8554/teststream",

34
client_read_test.go
View File

@@ -23,7 +23,7 @@ import (
) )
func TestClientReadTracks(t *testing.T) { func TestClientReadTracks(t *testing.T) {
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track2, err := NewTrackAAC(96, 2, 44100, 2, nil) track2, err := NewTrackAAC(96, 2, 44100, 2, nil)
@@ -206,7 +206,7 @@ func TestClientRead(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)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -467,7 +467,7 @@ func TestClientReadNonStandardFrameSize(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL) require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -571,10 +571,10 @@ func TestClientReadPartial(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://"+listenIP+":8554/teststream"), req.URL) require.Equal(t, mustParseURL("rtsp://"+listenIP+":8554/teststream"), req.URL)
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track1, track2} tracks := Tracks{track1, track2}
@@ -720,7 +720,7 @@ func TestClientReadNoContentBase(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL) require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -840,7 +840,7 @@ func TestClientReadAnyPort(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -997,7 +997,7 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1136,7 +1136,7 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
err = v.ValidateRequest(req) err = v.ValidateRequest(req)
require.NoError(t, err) require.NoError(t, err)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1352,7 +1352,7 @@ func TestClientReadDifferentInterleavedIDs(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL) require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track1} tracks := Tracks{track1}
@@ -1519,7 +1519,7 @@ func TestClientReadRedirect(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1684,7 +1684,7 @@ func TestClientReadPause(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1863,7 +1863,7 @@ func TestClientReadRTCPReport(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -2041,7 +2041,7 @@ func TestClientReadErrorTimeout(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -2196,7 +2196,7 @@ func TestClientReadIgnoreTCPInvalidTrack(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -2330,7 +2330,7 @@ func TestClientReadSeek(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -2510,7 +2510,7 @@ func TestClientReadKeepaliveFromSession(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}

6
client_test.go
View File

@@ -120,7 +120,7 @@ func TestClientSession(t *testing.T) {
require.Equal(t, base.HeaderValue{"123456"}, req.Header["Session"]) require.Equal(t, base.HeaderValue{"123456"}, req.Header["Session"])
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -207,7 +207,7 @@ func TestClientAuth(t *testing.T) {
err = v.ValidateRequest(req) err = v.ValidateRequest(req)
require.NoError(t, err) require.NoError(t, err)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -276,7 +276,7 @@ func TestClientDescribeCharset(t *testing.T) {
require.Equal(t, base.Describe, req.Method) require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL) require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
base.Response{ base.Response{

2
examples/client-publish-h264/main.go
View File

@@ -35,7 +35,7 @@ func main() {
fmt.Println("stream connected") fmt.Println("stream connected")
// create an H264 track // create an H264 track
track, err := gortsplib.NewTrackH264(96, sps, pps) track, err := gortsplib.NewTrackH264(96, sps, pps, nil)
if err != nil { if err != nil {
panic(err) panic(err)
} }

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

@@ -36,7 +36,7 @@ func main() {
fmt.Println("stream connected") fmt.Println("stream connected")
// create an H264 track // create an H264 track
track, err := gortsplib.NewTrackH264(96, sps, pps) track, err := gortsplib.NewTrackH264(96, sps, pps, nil)
if err != nil { if err != nil {
panic(err) panic(err)
} }

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

@@ -37,7 +37,7 @@ func main() {
fmt.Println("stream connected") fmt.Println("stream connected")
// create an H264 track // create an H264 track
track, err := gortsplib.NewTrackH264(96, sps, pps) track, err := gortsplib.NewTrackH264(96, sps, pps, nil)
if err != nil { if err != nil {
panic(err) panic(err)
} }

26
server_publish_test.go
View File

@@ -26,7 +26,7 @@ func invalidURLAnnounceReq(t *testing.T, control string) base.Request {
"Content-Type": base.HeaderValue{"application/sdp"}, "Content-Type": base.HeaderValue{"application/sdp"},
}, },
Body: func() []byte { Body: func() []byte {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track.setControl(control) track.setControl(control)
@@ -257,7 +257,7 @@ func TestServerPublishSetupPath(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track.setControl(ca.control) track.setControl(ca.control)
@@ -355,7 +355,7 @@ func TestServerPublishErrorSetupDifferentPaths(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -437,7 +437,7 @@ func TestServerPublishErrorSetupTrackTwice(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -536,10 +536,10 @@ func TestServerPublishErrorRecordPartialTracks(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track1, track2} tracks := Tracks{track1, track2}
@@ -685,7 +685,7 @@ func TestServerPublish(t *testing.T) {
<-connOpened <-connOpened
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -877,7 +877,7 @@ func TestServerPublishNonStandardFrameSize(t *testing.T) {
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
var bb bytes.Buffer var bb bytes.Buffer
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -982,7 +982,7 @@ func TestServerPublishErrorInvalidProtocol(t *testing.T) {
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
var bb bytes.Buffer var bb bytes.Buffer
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1086,7 +1086,7 @@ func TestServerPublishRTCPReport(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1261,7 +1261,7 @@ func TestServerPublishTimeout(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1388,7 +1388,7 @@ func TestServerPublishWithoutTeardown(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}
@@ -1507,7 +1507,7 @@ func TestServerPublishUDPChangeConn(t *testing.T) {
defer conn.Close() defer conn.Close()
br := bufio.NewReader(conn) br := bufio.NewReader(conn)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}

32
server_read_test.go
View File

@@ -91,7 +91,7 @@ func TestServerReadSetupPath(t *testing.T) {
}, },
} { } {
t.Run(ca.name, func(t *testing.T) { t.Run(ca.name, func(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track, track, track, track, track}) stream := NewServerStream(Tracks{track, track, track, track, track})
@@ -150,7 +150,7 @@ func TestServerReadSetupErrors(t *testing.T) {
t.Run(ca, func(t *testing.T) { t.Run(ca, func(t *testing.T) {
connClosed := make(chan struct{}) connClosed := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -258,7 +258,7 @@ func TestServerRead(t *testing.T) {
sessionClosed := make(chan struct{}) sessionClosed := make(chan struct{})
framesReceived := make(chan struct{}) framesReceived := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -566,7 +566,7 @@ func TestServerRead(t *testing.T) {
} }
func TestServerReadVLCMulticast(t *testing.T) { func TestServerReadVLCMulticast(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -614,7 +614,7 @@ func TestServerReadVLCMulticast(t *testing.T) {
} }
func TestServerReadNonStandardFrameSize(t *testing.T) { func TestServerReadNonStandardFrameSize(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -701,7 +701,7 @@ func TestServerReadTCPResponseBeforeFrames(t *testing.T) {
writerDone := make(chan struct{}) writerDone := make(chan struct{})
writerTerminate := make(chan struct{}) writerTerminate := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -799,7 +799,7 @@ func TestServerReadTCPResponseBeforeFrames(t *testing.T) {
} }
func TestServerReadPlayPlay(t *testing.T) { func TestServerReadPlayPlay(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -885,7 +885,7 @@ func TestServerReadPlayPausePlay(t *testing.T) {
writerDone := make(chan struct{}) writerDone := make(chan struct{})
writerTerminate := make(chan struct{}) writerTerminate := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1007,7 +1007,7 @@ func TestServerReadPlayPausePause(t *testing.T) {
writerDone := make(chan struct{}) writerDone := make(chan struct{})
writerTerminate := make(chan struct{}) writerTerminate := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1139,7 +1139,7 @@ func TestServerReadTimeout(t *testing.T) {
t.Run(transport, func(t *testing.T) { t.Run(transport, func(t *testing.T) {
sessionClosed := make(chan struct{}) sessionClosed := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1235,7 +1235,7 @@ func TestServerReadWithoutTeardown(t *testing.T) {
connClosed := make(chan struct{}) connClosed := make(chan struct{})
sessionClosed := make(chan struct{}) sessionClosed := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1337,7 +1337,7 @@ func TestServerReadWithoutTeardown(t *testing.T) {
} }
func TestServerReadUDPChangeConn(t *testing.T) { func TestServerReadUDPChangeConn(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1439,10 +1439,10 @@ func TestServerReadUDPChangeConn(t *testing.T) {
} }
func TestServerReadPartialTracks(t *testing.T) { func TestServerReadPartialTracks(t *testing.T) {
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track2, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track1, track2}) stream := NewServerStream(Tracks{track1, track2})
@@ -1615,7 +1615,7 @@ func TestServerReadAdditionalInfos(t *testing.T) {
return &ri, ssrcs return &ri, ssrcs
} }
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track, track}) stream := NewServerStream(Tracks{track, track})
@@ -1735,7 +1735,7 @@ func TestServerReadAdditionalInfos(t *testing.T) {
} }
func TestServerReadErrorUDPSamePorts(t *testing.T) { func TestServerReadErrorUDPSamePorts(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})

10
server_test.go
View File

@@ -689,7 +689,7 @@ func TestServerErrorInvalidMethod(t *testing.T) {
} }
func TestServerErrorTCPTwoConnOneSession(t *testing.T) { func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -791,7 +791,7 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
} }
func TestServerErrorTCPOneConnTwoSessions(t *testing.T) { func TestServerErrorTCPOneConnTwoSessions(t *testing.T) {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1059,7 +1059,7 @@ func TestServerSessionClose(t *testing.T) {
func TestServerSessionAutoClose(t *testing.T) { func TestServerSessionAutoClose(t *testing.T) {
sessionClosed := make(chan struct{}) sessionClosed := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1126,7 +1126,7 @@ func TestServerErrorInvalidPath(t *testing.T) {
t.Run(string(method), func(t *testing.T) { t.Run(string(method), func(t *testing.T) {
connClosed := make(chan struct{}) connClosed := make(chan struct{})
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
stream := NewServerStream(Tracks{track}) stream := NewServerStream(Tracks{track})
@@ -1168,7 +1168,7 @@ func TestServerErrorInvalidPath(t *testing.T) {
sxID := "" sxID := ""
if method == base.Record { if method == base.Record {
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}) track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err) require.NoError(t, err)
tracks := Tracks{track} tracks := Tracks{track}

22
track_h264.go
View File

@@ -64,14 +64,16 @@ type TrackH264 struct {
payloadType uint8 payloadType uint8
sps []byte sps []byte
pps []byte pps []byte
extradata []byte
} }
// NewTrackH264 allocates a TrackH264. // NewTrackH264 allocates a TrackH264.
func NewTrackH264(payloadType uint8, sps []byte, pps []byte) (*TrackH264, error) { func NewTrackH264(payloadType uint8, sps []byte, pps []byte, extradata []byte) (*TrackH264, error) {
return &TrackH264{ return &TrackH264{
payloadType: payloadType, payloadType: payloadType,
sps: sps, sps: sps,
pps: pps, pps: pps,
extradata: extradata,
}, nil }, nil
} }
@@ -133,11 +135,21 @@ func (t *TrackH264) mediaDescription() *psdp.MediaDescription {
typ := strconv.FormatInt(int64(t.payloadType), 10) typ := strconv.FormatInt(int64(t.payloadType), 10)
fmtp := typ + " packetization-mode=1" fmtp := typ + " packetization-mode=1"
var tmp []string
if t.sps != nil {
tmp = append(tmp, base64.StdEncoding.EncodeToString(t.sps))
}
if t.pps != nil {
tmp = append(tmp, base64.StdEncoding.EncodeToString(t.pps))
}
if t.extradata != nil {
tmp = append(tmp, base64.StdEncoding.EncodeToString(t.extradata))
}
fmtp += "; sprop-parameter-sets=" + strings.Join(tmp, ",")
if len(t.sps) >= 4 { if len(t.sps) >= 4 {
spropParameterSets := base64.StdEncoding.EncodeToString(t.sps) + fmtp += "; profile-level-id=" + strings.ToUpper(hex.EncodeToString(t.sps[1:4]))
"," + base64.StdEncoding.EncodeToString(t.pps)
profileLevelID := strings.ToUpper(hex.EncodeToString(t.sps[1:4]))
fmtp += "; sprop-parameter-sets=" + spropParameterSets + "; profile-level-id=" + profileLevelID
} }
return &psdp.MediaDescription{ return &psdp.MediaDescription{

8
track_h264_test.go
View File

@@ -173,6 +173,9 @@ func TestTrackH264New(t *testing.T) {
}, },
[]byte{ []byte{
0x68, 0xee, 0x3c, 0x80, 0x68, 0xee, 0x3c, 0x80,
},
[]byte{
0x01, 0x02,
}) })
require.NoError(t, err) require.NoError(t, err)
} }
@@ -299,6 +302,9 @@ func TestTrackH264MediaDescription(t *testing.T) {
}, },
[]byte{ []byte{
0x68, 0xee, 0x3c, 0x80, 0x68, 0xee, 0x3c, 0x80,
},
[]byte{
0x01, 0x02,
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -316,7 +322,7 @@ func TestTrackH264MediaDescription(t *testing.T) {
{ {
Key: "fmtp", Key: "fmtp",
Value: "96 packetization-mode=1; " + Value: "96 packetization-mode=1; " +
"sprop-parameter-sets=Z2QADKw7ULBLQgAAAwACAAADAD0I,aO48gA==; profile-level-id=64000C", "sprop-parameter-sets=Z2QADKw7ULBLQgAAAwACAAADAD0I,aO48gA==,AQI=; profile-level-id=64000C",
}, },
{ {
Key: "control", Key: "control",