client: allow calling ReadFrames() when publishing

clientconnpublish_test.go

@@ -753,3 +753,174 @@ func TestClientPublishRTCP(t *testing.T) {
 	err = conn.WriteFrame(track.ID, StreamTypeRTP, byts)
 	require.NoError(t, err)
 }
+
+func TestClientPublishReadManualRTCP(t *testing.T) {
+	for _, proto := range []string{
+		"udp",
+		"tcp",
+	} {
+		t.Run(proto, func(t *testing.T) {
+			l, err := net.Listen("tcp", "localhost:8554")
+			require.NoError(t, err)
+			defer l.Close()
+
+			serverDone := make(chan struct{})
+			defer func() { <-serverDone }()
+			go func() {
+				defer close(serverDone)
+
+				conn, err := l.Accept()
+				require.NoError(t, err)
+				bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
+
+				var req base.Request
+				err = req.Read(bconn.Reader)
+				require.NoError(t, err)
+				require.Equal(t, base.Options, req.Method)
+
+				err = base.Response{
+					StatusCode: base.StatusOK,
+					Header: base.Header{
+						"Public": base.HeaderValue{strings.Join([]string{
+							string(base.Announce),
+							string(base.Setup),
+							string(base.Record),
+						}, ", ")},
+					},
+				}.Write(bconn.Writer)
+				require.NoError(t, err)
+
+				err = req.Read(bconn.Reader)
+				require.NoError(t, err)
+				require.Equal(t, base.Announce, req.Method)
+
+				err = base.Response{
+					StatusCode: base.StatusOK,
+				}.Write(bconn.Writer)
+				require.NoError(t, err)
+
+				err = req.Read(bconn.Reader)
+				require.NoError(t, err)
+				require.Equal(t, base.Setup, req.Method)
+
+				var inTH headers.Transport
+				err = inTH.Read(req.Header["Transport"])
+				require.NoError(t, err)
+
+				th := headers.Transport{
+					Delivery: func() *base.StreamDelivery {
+						v := base.StreamDeliveryUnicast
+						return &v
+					}(),
+				}
+
+				var l1 net.PacketConn
+				if proto == "udp" {
+					var err error
+					l1, err = net.ListenPacket("udp", "localhost:34557")
+					require.NoError(t, err)
+					defer l1.Close()
+
+					th.Protocol = StreamProtocolUDP
+					th.ServerPorts = &[2]int{34556, 34557}
+					th.ClientPorts = inTH.ClientPorts
+
+				} else {
+					th.Protocol = StreamProtocolTCP
+					th.InterleavedIDs = inTH.InterleavedIDs
+				}
+
+				err = base.Response{
+					StatusCode: base.StatusOK,
+					Header: base.Header{
+						"Transport": th.Write(),
+					},
+				}.Write(bconn.Writer)
+				require.NoError(t, err)
+
+				err = req.Read(bconn.Reader)
+				require.NoError(t, err)
+				require.Equal(t, base.Record, req.Method)
+
+				err = base.Response{
+					StatusCode: base.StatusOK,
+				}.Write(bconn.Writer)
+				require.NoError(t, err)
+
+				if proto == "udp" {
+					buf := make([]byte, 2048)
+					n, _, err := l1.ReadFrom(buf)
+					require.NoError(t, err)
+					require.Equal(t, []byte{0x05, 0x06, 0x07, 0x08}, buf[:n])
+
+				} else {
+					var f base.InterleavedFrame
+					f.Payload = make([]byte, 2048)
+					err = f.Read(bconn.Reader)
+					require.NoError(t, err)
+					require.Equal(t, StreamTypeRTCP, f.StreamType)
+					require.Equal(t, []byte{0x05, 0x06, 0x07, 0x08}, f.Payload)
+				}
+
+				if proto == "udp" {
+					l1.WriteTo([]byte{0x01, 0x02, 0x03, 0x04}, &net.UDPAddr{
+						IP:   net.ParseIP("127.0.0.1"),
+						Port: th.ClientPorts[1],
+					})
+
+				} else {
+					err = base.InterleavedFrame{
+						TrackID:    0,
+						StreamType: StreamTypeRTCP,
+						Payload:    []byte{0x01, 0x02, 0x03, 0x04},
+					}.Write(bconn.Writer)
+					require.NoError(t, err)
+				}
+
+				err = req.Read(bconn.Reader)
+				require.NoError(t, err)
+				require.Equal(t, base.Teardown, req.Method)
+
+				base.Response{
+					StatusCode: base.StatusOK,
+				}.Write(bconn.Writer)
+
+				conn.Close()
+			}()
+
+			conf := ClientConf{
+				StreamProtocol: func() *StreamProtocol {
+					if proto == "udp" {
+						v := StreamProtocolUDP
+						return &v
+					}
+					v := StreamProtocolTCP
+					return &v
+				}(),
+			}
+
+			track, err := NewTrackH264(96, []byte("123456"), []byte("123456"))
+			require.NoError(t, err)
+
+			conn, err := conf.DialPublish("rtsp://localhost:8554/teststream",
+				Tracks{track})
+			require.NoError(t, err)
+
+			recvDone := make(chan struct{})
+			done := conn.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
+				require.Equal(t, 0, trackID)
+				require.Equal(t, StreamTypeRTCP, streamType)
+				require.Equal(t, []byte{0x01, 0x02, 0x03, 0x04}, payload)
+				close(recvDone)
+			})
+
+			err = conn.WriteFrame(track.ID, StreamTypeRTCP,
+				[]byte{0x05, 0x06, 0x07, 0x08})
+			require.NoError(t, err)
+
+			<-recvDone
+			conn.Close()
+			<-done
+		})
+	}
+}