Tests, validation, format

pkg/packetdump/filter.go

@@ -14,9 +14,9 @@ type RTPFilterCallback func(pkt *rtp.Packet) bool
 
 // RTCPFilterCallback can be used to filter RTCP packets to dump.
 // The callback returns whether or not to print dump the packet's content.
-// Deprecated: prefer RTCPFilterPerPacketCallback
+// Deprecated: prefer RTCPPerPacketFilterCallback
 type RTCPFilterCallback func(pkt []rtcp.Packet) bool
 
-// RTCPFilterPerPacketCallback can be used to filter RTCP packets to dump.
+// RTCPPerPacketFilterCallback can be used to filter RTCP packets to dump.
 // It's called once per every packet opposing to RTCPFilterCallback which is called once per packet batch
-type RTCPFilterPerPacketCallback func(pkt rtcp.Packet) bool
+type RTCPPerPacketFilterCallback func(pkt rtcp.Packet) bool

pkg/packetdump/option.go

@@ -79,18 +79,18 @@ func RTPFilter(callback RTPFilterCallback) PacketDumperOption {
 }
 
 // RTCPFilter sets the RTCP filter.
-// Deprecated: prefer RTCPFilterPerPacket
+// Deprecated: prefer RTCPPerPacketFilter
 func RTCPFilter(callback RTCPFilterCallback) PacketDumperOption {
 	return func(d *PacketDumper) error {
 		d.rtcpFilter = callback
 		return nil
 	}
 }
 
-// RTCPFilterPerPacket sets the RTCP per-packet filter.
-func RTCPFilterPerPacket(callback RTCPFilterPerPacketCallback) PacketDumperOption {
+// RTCPPerPacketFilter sets the RTCP per-packet filter.
+func RTCPPerPacketFilter(callback RTCPPerPacketFilterCallback) PacketDumperOption {
 	return func(d *PacketDumper) error {
-		d.rtcpFilterPerPacket = callback
+		d.rtcpPerPacketFilter = callback
 		return nil
 	}
 }

pkg/packetdump/packet_dumper.go

@@ -15,6 +15,9 @@ import (
 	"github.com/pion/rtp"
 )
 
+// ErrBothBinaryAndDeprecatedFormat is returned when both binary and deprecated format callbacks are set
+var ErrBothBinaryAndDeprecatedFormat = fmt.Errorf("both binary and deprecated format callbacks are set")
+
 // PacketDumper dumps packet to a io.Writer
 type PacketDumper struct {
 	log logging.LeveledLogger
@@ -36,7 +39,7 @@ type PacketDumper struct {
 
 	rtpFilter           RTPFilterCallback
 	rtcpFilter          RTCPFilterCallback
-	rtcpFilterPerPacket RTCPFilterPerPacketCallback
+	rtcpPerPacketFilter RTCPPerPacketFilterCallback
 }
 
 // NewPacketDumper creates a new PacketDumper
@@ -59,11 +62,15 @@ func NewPacketDumper(opts ...PacketDumperOption) (*PacketDumper, error) {
 		rtcpFilter: func([]rtcp.Packet) bool {
 			return true
 		},
-		rtcpFilterPerPacket: func(rtcp.Packet) bool {
+		rtcpPerPacketFilter: func(rtcp.Packet) bool {
 			return true
 		},
 	}
 
+	if d.rtpFormat != nil && d.rtpFormatBinary != nil {
+		return nil, ErrBothBinaryAndDeprecatedFormat
+	}
+
 	for _, opt := range opts {
 		if err := opt(d); err != nil {
 			return nil, err
@@ -178,7 +185,7 @@ func (d *PacketDumper) writeDumpedRTCP(dump *rtcpDump) error {
 	}
 
 	for _, pkt := range dump.packets {
-		if !d.rtcpFilterPerPacket(pkt) {
+		if !d.rtcpPerPacketFilter(pkt) {
 			continue
 		}
 

pkg/packetdump/receiver_interceptor_test.go

@@ -164,3 +164,50 @@ func TestReceiverCustomBinaryFormatter(t *testing.T) {
 	assert.Equal(t, []byte{123}, rtpBuf.Bytes())
 	assert.Equal(t, []byte{45}, rtcpBuf.Bytes())
 }
+
+func TestReceiverRTCPPerPacketFilter(t *testing.T) {
+	buf := bytes.Buffer{}
+
+	factory, err := NewReceiverInterceptor(
+		RTCPWriter(&buf),
+		Log(logging.NewDefaultLoggerFactory().NewLogger("test")),
+		RTCPPerPacketFilter(func(packet rtcp.Packet) bool {
+			_, isPli := packet.(*rtcp.PictureLossIndication)
+			return isPli
+		}),
+		RTCPBinaryFormatter(func(p rtcp.Packet, _ interceptor.Attributes) ([]byte, error) {
+			assert.IsType(t, &rtcp.PictureLossIndication{}, p)
+			return []byte{123}, nil
+		}),
+	)
+	assert.NoError(t, err)
+
+	i, err := factory.NewInterceptor("")
+	assert.NoError(t, err)
+
+	assert.EqualValues(t, 0, buf.Len())
+
+	stream := test.NewMockStream(&interceptor.StreamInfo{
+		SSRC:      123456,
+		ClockRate: 90000,
+	}, i)
+	defer func() {
+		assert.NoError(t, stream.Close())
+	}()
+
+	stream.ReceiveRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{
+		SenderSSRC: 123,
+		MediaSSRC:  456,
+	}})
+	stream.ReceiveRTCP([]rtcp.Packet{&rtcp.ReceiverReport{
+		SSRC: 789,
+	}})
+	// Give time for packets to be handled and stream written to.
+	time.Sleep(50 * time.Millisecond)
+
+	err = i.Close()
+	assert.NoError(t, err)
+
+	// Only single PictureLossIndication should have been written.
+	assert.Equal(t, []byte{123}, buf.Bytes())
+}

pkg/packetdump/sender_interceptor_test.go

@@ -173,3 +173,54 @@ func TestSenderCustomBinaryFormatter(t *testing.T) {
 	assert.Equal(t, []byte{123}, rtpBuf.Bytes())
 	assert.Equal(t, []byte{45}, rtcpBuf.Bytes())
 }
+
+func TestSenderRTCPPerPacketFilter(t *testing.T) {
+	buf := bytes.Buffer{}
+
+	factory, err := NewSenderInterceptor(
+		RTCPWriter(&buf),
+		Log(logging.NewDefaultLoggerFactory().NewLogger("test")),
+		RTCPPerPacketFilter(func(packet rtcp.Packet) bool {
+			_, isPli := packet.(*rtcp.PictureLossIndication)
+			return isPli
+		}),
+		RTCPBinaryFormatter(func(p rtcp.Packet, _ interceptor.Attributes) ([]byte, error) {
+			assert.IsType(t, &rtcp.PictureLossIndication{}, p)
+			return []byte{123}, nil
+		}),
+	)
+	assert.NoError(t, err)
+
+	i, err := factory.NewInterceptor("")
+	assert.NoError(t, err)
+
+	assert.EqualValues(t, 0, buf.Len())
+
+	stream := test.NewMockStream(&interceptor.StreamInfo{
+		SSRC:      123456,
+		ClockRate: 90000,
+	}, i)
+	defer func() {
+		assert.NoError(t, stream.Close())
+	}()
+
+	err = stream.WriteRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{
+		SenderSSRC: 123,
+		MediaSSRC:  456,
+	}})
+	assert.NoError(t, err)
+
+	err = stream.WriteRTCP([]rtcp.Packet{&rtcp.ReceiverReport{
+		SSRC: 789,
+	}})
+	assert.NoError(t, err)
+
+	// Give time for packets to be handled and stream written to.
+	time.Sleep(50 * time.Millisecond)
+
+	err = i.Close()
+	assert.NoError(t, err)
+
+	// Only single PictureLossIndication should have been written.
+	assert.Equal(t, []byte{123}, buf.Bytes())
+}