package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 07:06:58 +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)
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)
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)
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)
err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -807,7 +807,7 @@ func TestClientPublishAutomaticProtocol(t *testing.T) {
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)
c := Client{}
@@ -950,7 +950,7 @@ func TestClientPublishRTCPReport(t *testing.T) {
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)
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)
err = c.StartPublishing("rtsp://localhost:8554/teststream",

34
client_read_test.go
View File

@@ -23,7 +23,7 @@ import (
)
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)
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, 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)
tracks := Tracks{track}
@@ -467,7 +467,7 @@ func TestClientReadNonStandardFrameSize(t *testing.T) {
require.Equal(t, base.Describe, req.Method)
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)
tracks := Tracks{track}
@@ -571,10 +571,10 @@ func TestClientReadPartial(t *testing.T) {
require.Equal(t, base.Describe, req.Method)
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)
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)
tracks := Tracks{track1, track2}
@@ -720,7 +720,7 @@ func TestClientReadNoContentBase(t *testing.T) {
require.Equal(t, base.Describe, req.Method)
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)
tracks := Tracks{track}
@@ -840,7 +840,7 @@ func TestClientReadAnyPort(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -997,7 +997,7 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -1136,7 +1136,7 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
err = v.ValidateRequest(req)
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)
tracks := Tracks{track}
@@ -1352,7 +1352,7 @@ func TestClientReadDifferentInterleavedIDs(t *testing.T) {
require.Equal(t, base.Describe, req.Method)
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)
tracks := Tracks{track1}
@@ -1519,7 +1519,7 @@ func TestClientReadRedirect(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -1684,7 +1684,7 @@ func TestClientReadPause(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -1863,7 +1863,7 @@ func TestClientReadRTCPReport(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -2041,7 +2041,7 @@ func TestClientReadErrorTimeout(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -2196,7 +2196,7 @@ func TestClientReadIgnoreTCPInvalidTrack(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -2330,7 +2330,7 @@ func TestClientReadSeek(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -2510,7 +2510,7 @@ func TestClientReadKeepaliveFromSession(t *testing.T) {
require.NoError(t, err)
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)
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"])
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)
tracks := Tracks{track}
@@ -207,7 +207,7 @@ func TestClientAuth(t *testing.T) {
err = v.ValidateRequest(req)
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)
tracks := Tracks{track}
@@ -276,7 +276,7 @@ func TestClientDescribeCharset(t *testing.T) {
require.Equal(t, base.Describe, req.Method)
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)
base.Response{

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

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

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

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

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

@@ -37,7 +37,7 @@ func main() {
fmt.Println("stream connected")
// create an H264 track
track, err := gortsplib.NewTrackH264(96, sps, pps)
track, err := gortsplib.NewTrackH264(96, sps, pps, nil)
if err != nil {
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"},
},
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)
track.setControl(control)
@@ -257,7 +257,7 @@ func TestServerPublishSetupPath(t *testing.T) {
defer conn.Close()
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)
track.setControl(ca.control)
@@ -355,7 +355,7 @@ func TestServerPublishErrorSetupDifferentPaths(t *testing.T) {
defer conn.Close()
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)
tracks := Tracks{track}
@@ -437,7 +437,7 @@ func TestServerPublishErrorSetupTrackTwice(t *testing.T) {
defer conn.Close()
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)
tracks := Tracks{track}
@@ -536,10 +536,10 @@ func TestServerPublishErrorRecordPartialTracks(t *testing.T) {
defer conn.Close()
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)
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)
tracks := Tracks{track1, track2}
@@ -685,7 +685,7 @@ func TestServerPublish(t *testing.T) {
<-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)
tracks := Tracks{track}
@@ -877,7 +877,7 @@ func TestServerPublishNonStandardFrameSize(t *testing.T) {
br := bufio.NewReader(conn)
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)
tracks := Tracks{track}
@@ -982,7 +982,7 @@ func TestServerPublishErrorInvalidProtocol(t *testing.T) {
br := bufio.NewReader(conn)
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)
tracks := Tracks{track}
@@ -1086,7 +1086,7 @@ func TestServerPublishRTCPReport(t *testing.T) {
defer conn.Close()
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)
tracks := Tracks{track}
@@ -1261,7 +1261,7 @@ func TestServerPublishTimeout(t *testing.T) {
defer conn.Close()
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)
tracks := Tracks{track}
@@ -1388,7 +1388,7 @@ func TestServerPublishWithoutTeardown(t *testing.T) {
require.NoError(t, err)
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)
tracks := Tracks{track}
@@ -1507,7 +1507,7 @@ func TestServerPublishUDPChangeConn(t *testing.T) {
defer conn.Close()
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)
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) {
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)
stream := NewServerStream(Tracks{track, track, track, track, track})
@@ -150,7 +150,7 @@ func TestServerReadSetupErrors(t *testing.T) {
t.Run(ca, func(t *testing.T) {
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)
stream := NewServerStream(Tracks{track})
@@ -258,7 +258,7 @@ func TestServerRead(t *testing.T) {
sessionClosed := 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)
stream := NewServerStream(Tracks{track})
@@ -566,7 +566,7 @@ func TestServerRead(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)
stream := NewServerStream(Tracks{track})
@@ -614,7 +614,7 @@ func TestServerReadVLCMulticast(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)
stream := NewServerStream(Tracks{track})
@@ -701,7 +701,7 @@ func TestServerReadTCPResponseBeforeFrames(t *testing.T) {
writerDone := 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)
stream := NewServerStream(Tracks{track})
@@ -799,7 +799,7 @@ func TestServerReadTCPResponseBeforeFrames(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)
stream := NewServerStream(Tracks{track})
@@ -885,7 +885,7 @@ func TestServerReadPlayPausePlay(t *testing.T) {
writerDone := 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)
stream := NewServerStream(Tracks{track})
@@ -1007,7 +1007,7 @@ func TestServerReadPlayPausePause(t *testing.T) {
writerDone := 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)
stream := NewServerStream(Tracks{track})
@@ -1139,7 +1139,7 @@ func TestServerReadTimeout(t *testing.T) {
t.Run(transport, func(t *testing.T) {
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)
stream := NewServerStream(Tracks{track})
@@ -1235,7 +1235,7 @@ func TestServerReadWithoutTeardown(t *testing.T) {
connClosed := 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)
stream := NewServerStream(Tracks{track})
@@ -1337,7 +1337,7 @@ func TestServerReadWithoutTeardown(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)
stream := NewServerStream(Tracks{track})
@@ -1439,10 +1439,10 @@ func TestServerReadUDPChangeConn(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)
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)
stream := NewServerStream(Tracks{track1, track2})
@@ -1615,7 +1615,7 @@ func TestServerReadAdditionalInfos(t *testing.T) {
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)
stream := NewServerStream(Tracks{track, track})
@@ -1735,7 +1735,7 @@ func TestServerReadAdditionalInfos(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)
stream := NewServerStream(Tracks{track})

10
server_test.go
View File

@@ -689,7 +689,7 @@ func TestServerErrorInvalidMethod(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)
stream := NewServerStream(Tracks{track})
@@ -791,7 +791,7 @@ func TestServerErrorTCPTwoConnOneSession(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)
stream := NewServerStream(Tracks{track})
@@ -1059,7 +1059,7 @@ func TestServerSessionClose(t *testing.T) {
func TestServerSessionAutoClose(t *testing.T) {
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)
stream := NewServerStream(Tracks{track})
@@ -1126,7 +1126,7 @@ func TestServerErrorInvalidPath(t *testing.T) {
t.Run(string(method), func(t *testing.T) {
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)
stream := NewServerStream(Tracks{track})
@@ -1168,7 +1168,7 @@ func TestServerErrorInvalidPath(t *testing.T) {
sxID := ""
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)
tracks := Tracks{track}

22
track_h264.go
View File

@@ -64,14 +64,16 @@ type TrackH264 struct {
payloadType uint8
sps []byte
pps []byte
extradata []byte
}
// 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{
payloadType: payloadType,
sps: sps,
pps: pps,
extradata: extradata,
}, nil
}
@@ -133,11 +135,21 @@ func (t *TrackH264) mediaDescription() *psdp.MediaDescription {
typ := strconv.FormatInt(int64(t.payloadType), 10)
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 {
spropParameterSets := base64.StdEncoding.EncodeToString(t.sps) +
"," + base64.StdEncoding.EncodeToString(t.pps)
profileLevelID := strings.ToUpper(hex.EncodeToString(t.sps[1:4]))
fmtp += "; sprop-parameter-sets=" + spropParameterSets + "; profile-level-id=" + profileLevelID
fmtp += "; profile-level-id=" + strings.ToUpper(hex.EncodeToString(t.sps[1:4]))
}
return &psdp.MediaDescription{

8
track_h264_test.go
View File

@@ -173,6 +173,9 @@ func TestTrackH264New(t *testing.T) {
},
[]byte{
0x68, 0xee, 0x3c, 0x80,
},
[]byte{
0x01, 0x02,
})
require.NoError(t, err)
}
@@ -299,6 +302,9 @@ func TestTrackH264MediaDescription(t *testing.T) {
},
[]byte{
0x68, 0xee, 0x3c, 0x80,
},
[]byte{
0x01, 0x02,
})
require.NoError(t, err)
@@ -316,7 +322,7 @@ func TestTrackH264MediaDescription(t *testing.T) {
{
Key: "fmtp",
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",