client: skip tracks with an invalid clock rate (https://github.com/aler9/rtsp-simple-server/issues/832)

client.go

@@ -1184,7 +1184,7 @@ func (c *Client) doDescribe(u *base.URL) (Tracks, *base.URL, *base.Response, err
 		return nil, nil, nil, err
 	}
 
-	tracks, err := ReadTracks(res.Body)
+	tracks, err := ReadTracks(res.Body, true)
 	if err != nil {
 		return nil, nil, nil, err
 	}

pkg/liberrors/server.go

@@ -106,14 +106,6 @@ func (e ErrServerSDPInvalid) Error() string {
 	return fmt.Sprintf("invalid SDP: %v", e.Err)
 }
 
-// ErrServerSDPNoTracksDefined is an error that can be returned by a server.
-type ErrServerSDPNoTracksDefined struct{}
-
-// Error implements the error interface.
-func (e ErrServerSDPNoTracksDefined) Error() string {
-	return "no tracks defined in the SDP"
-}
-
 // ErrServerTransportHeaderInvalid is an error that can be returned by a server.
 type ErrServerTransportHeaderInvalid struct {
 	Err error

server_publish_test.go

@@ -94,36 +94,6 @@ func TestServerPublishErrorAnnounce(t *testing.T) {
 			},
 			"invalid SDP: invalid line: (\x01\x02\x03\x04)",
 		},
-		{
-			"no tracks",
-			base.Request{
-				Method: base.Announce,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-				Header: base.Header{
-					"CSeq":         base.HeaderValue{"1"},
-					"Content-Type": base.HeaderValue{"application/sdp"},
-				},
-				Body: func() []byte {
-					sout := &psdp.SessionDescription{
-						SessionName: psdp.SessionName("Stream"),
-						Origin: psdp.Origin{
-							Username:       "-",
-							NetworkType:    "IN",
-							AddressType:    "IP4",
-							UnicastAddress: "127.0.0.1",
-						},
-						TimeDescriptions: []psdp.TimeDescription{
-							{Timing: psdp.Timing{0, 0}}, //nolint:govet
-						},
-						MediaDescriptions: []*psdp.MediaDescription{},
-					}
-
-					byts, _ := sout.Marshal()
-					return byts
-				}(),
-			},
-			"no tracks defined in the SDP",
-		},
 		{
 			"invalid URL 1",
 			invalidURLAnnounceReq(t, "rtsp://  aaaaa"),

serversession.go

@@ -501,19 +501,13 @@ func (ss *ServerSession) handleRequest(sc *ServerConn, req *base.Request) (*base
 			}, liberrors.ErrServerContentTypeUnsupported{CT: ct}
 		}
 
-		tracks, err := ReadTracks(req.Body)
+		tracks, err := ReadTracks(req.Body, false)
 		if err != nil {
 			return &base.Response{
 				StatusCode: base.StatusBadRequest,
 			}, liberrors.ErrServerSDPInvalid{Err: err}
 		}
 
-		if len(tracks) == 0 {
-			return &base.Response{
-				StatusCode: base.StatusBadRequest,
-			}, liberrors.ErrServerSDPNoTracksDefined{}
-		}
-
 		for _, track := range tracks {
 			trackURL, err := track.url(req.URL)
 			if err != nil {

track_test.go

@@ -699,7 +699,7 @@ func TestTrackURL(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			tracks, err := ReadTracks(ca.sdp)
+			tracks, err := ReadTracks(ca.sdp, false)
 			require.NoError(t, err)
 			ur, err := tracks[0].url(ca.baseURL)
 			require.NoError(t, err)

tracks.go

@@ -3,6 +3,7 @@ package gortsplib
 import (
 	"fmt"
 	"strconv"
+	"strings"
 
 	psdp "github.com/pion/sdp/v3"
 
@@ -13,22 +14,30 @@ import (
 type Tracks []Track
 
 // ReadTracks decodes tracks from the SDP format.
-func ReadTracks(byts []byte) (Tracks, error) {
+func ReadTracks(byts []byte, skipGenericTracksWithoutClockRate bool) (Tracks, error) {
 	var sd sdp.SessionDescription
 	err := sd.Unmarshal(byts)
 	if err != nil {
 		return nil, err
 	}
 
-	tracks := make(Tracks, len(sd.MediaDescriptions))
+	var tracks Tracks //nolint:prealloc
 
 	for i, md := range sd.MediaDescriptions {
 		t, err := newTrackFromMediaDescription(md)
 		if err != nil {
+			if skipGenericTracksWithoutClockRate &&
+				strings.HasPrefix(err.Error(), "unable to get clock rate") {
+				continue
+			}
 			return nil, fmt.Errorf("unable to parse track %d: %s", i+1, err)
 		}
 
-		tracks[i] = t
+		tracks = append(tracks, t)
+	}
+
+	if len(tracks) == 0 {
+		return nil, fmt.Errorf("no valid tracks found")
 	}
 
 	return tracks, nil

tracks_test.go

@@ -35,8 +35,53 @@ func TestTracksReadErrors(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			_, err := ReadTracks(ca.sdp)
+			_, err := ReadTracks(ca.sdp, false)
 			require.EqualError(t, err, ca.err)
 		})
 	}
 }
+
+func TestTracksReadSkipGenericTracksWithoutClockRate(t *testing.T) {
+	sdp := []byte("v=0\r\n" +
+		"o=- 0 0 IN IP4 10.0.0.131\r\n" +
+		"s=Media Presentation\r\n" +
+		"i=samsung\r\n" +
+		"c=IN IP4 0.0.0.0\r\n" +
+		"b=AS:2632\r\n" +
+		"t=0 0\r\n" +
+		"a=control:rtsp://10.0.100.50/profile5/media.smp\r\n" +
+		"a=range:npt=now-\r\n" +
+		"m=video 42504 RTP/AVP 97\r\n" +
+		"b=AS:2560\r\n" +
+		"a=rtpmap:97 H264/90000\r\n" +
+		"a=control:rtsp://10.0.100.50/profile5/media.smp/trackID=v\r\n" +
+		"a=cliprect:0,0,1080,1920\r\n" +
+		"a=framesize:97 1920-1080\r\n" +
+		"a=framerate:30.0\r\n" +
+		"a=fmtp:97 packetization-mode=1;profile-level-id=640028;sprop-parameter-sets=Z2QAKKy0A8ARPyo=,aO4Bniw=\r\n" +
+		"m=audio 42506 RTP/AVP 0\r\n" +
+		"b=AS:64\r\n" +
+		"a=rtpmap:0 PCMU/8000\r\n" +
+		"a=control:rtsp://10.0.100.50/profile5/media.smp/trackID=a\r\n" +
+		"a=recvonly\r\n" +
+		"m=application 42508 RTP/AVP 107\r\n" +
+		"b=AS:8\r\n")
+
+	tracks, err := ReadTracks(sdp, true)
+	require.NoError(t, err)
+	require.Equal(t, Tracks{
+		&TrackH264{
+			control:     "rtsp://10.0.100.50/profile5/media.smp/trackID=v",
+			payloadType: 97,
+			sps:         []byte{0x67, 0x64, 0x00, 0x28, 0xac, 0xb4, 0x03, 0xc0, 0x11, 0x3f, 0x2a},
+			pps:         []byte{0x68, 0xee, 0x01, 0x9e, 0x2c},
+		},
+		&TrackGeneric{
+			control:   "rtsp://10.0.100.50/profile5/media.smp/trackID=a",
+			clockRate: 8000,
+			media:     "audio",
+			formats:   []string{"0"},
+			rtpmap:    "0 PCMU/8000",
+		},
+	}, tracks)
+}