Remove PacketWithHeader type

This simplifies the RTCP interface, and saves a bit of code.
Relates to #119

internal/network/manager.go

@@ -20,7 +20,7 @@ import (
 // and Rtcp messages incoming from the remote host
 type TransportPair struct {
 	RTP  chan<- *rtp.Packet
-	RTCP chan<- *rtcp.PacketWithHeader
+	RTCP chan<- rtcp.Packet
 }
 
 // Manager contains all network state (DTLS, SRTP) that is shared between ports
@@ -55,7 +55,7 @@ type Manager struct {
 
 //AddTransportPair notifies the network manager that an RTCTrack has
 //been created externally, and packets may be incoming with this ssrc
-func (m *Manager) AddTransportPair(ssrc uint32, Rtp chan<- *rtp.Packet, Rtcp chan<- *rtcp.PacketWithHeader) {
+func (m *Manager) AddTransportPair(ssrc uint32, Rtp chan<- *rtp.Packet, Rtcp chan<- rtcp.Packet) {
 	m.pairsLock.Lock()
 	defer m.pairsLock.Unlock()
 	bufferTransport := m.bufferTransportPairs[ssrc]

internal/network/port-receive.go

@@ -44,8 +44,9 @@ func (p *port) handleSRTP(buffer []byte) {
 				return
 			}
 			{
-				var report rtcp.PacketWithHeader
+				var report rtcp.Packet
-				err = report.Unmarshal(decrypted)
+				var header rtcp.Header
+				report, header, err = rtcp.Unmarshal(decrypted)
 				if err != nil {
 					fmt.Println(err)
 					return
@@ -55,33 +56,33 @@ func (p *port) handleSRTP(buffer []byte) {
 					bufferTransport := p.m.getBufferTransports(ssrc)
 					if bufferTransport != nil && bufferTransport.RTCP != nil {
 						select {
-						case bufferTransport.RTCP <- &report:
+						case bufferTransport.RTCP <- report:
 						default:
 						}
 					}
 				}
 
-				switch report.Header.Type {
+				switch header.Type {
 				case rtcp.TypeSenderReport:
-					for _, ssrc := range report.Packet.(*rtcp.SenderReport).Reports {
+					for _, ssrc := range report.(*rtcp.SenderReport).Reports {
 						f(ssrc.SSRC)
 					}
 				case rtcp.TypeReceiverReport:
-					for _, ssrc := range report.Packet.(*rtcp.ReceiverReport).Reports {
+					for _, ssrc := range report.(*rtcp.ReceiverReport).Reports {
 						f(ssrc.SSRC)
 					}
 				case rtcp.TypeSourceDescription:
-					for _, ssrc := range report.Packet.(*rtcp.SourceDescription).Chunks {
+					for _, ssrc := range report.(*rtcp.SourceDescription).Chunks {
 						f(ssrc.Source)
 					}
 				case rtcp.TypeGoodbye:
-					for _, ssrc := range report.Packet.(*rtcp.Goodbye).Sources {
+					for _, ssrc := range report.(*rtcp.Goodbye).Sources {
 						f(ssrc)
 					}
 				case rtcp.TypeTransportSpecificFeedback:
-					f(report.Packet.(*rtcp.RapidResynchronizationRequest).MediaSSRC)
+					f(report.(*rtcp.RapidResynchronizationRequest).MediaSSRC)
 				case rtcp.TypePayloadSpecificFeedback:
-					f(report.Packet.(*rtcp.PictureLossIndication).MediaSSRC)
+					f(report.(*rtcp.PictureLossIndication).MediaSSRC)
 				}
 			}
 			return

media.go

@@ -15,7 +15,7 @@ type RTCTrack struct {
 	Ssrc        uint32
 	Codec       *RTCRtpCodec
 	Packets     <-chan *rtp.Packet
-	RTCPPackets <-chan *rtcp.PacketWithHeader
+	RTCPPackets <-chan rtcp.Packet
 	Samples     chan<- media.RTCSample
 	RawRTP      chan<- *rtp.Packet
 }

pkg/rtcp/packet.go

@@ -6,80 +6,40 @@ type Packet interface {
 	Unmarshal(rawPacket []byte) error
 }
 
-// PacketWithHeader is a pair to represent an RTCP header and its
+// Unmarshal is a factory a polymorphic RTCP packet, and its header,
-// packet's polymorphic parsed and unparsed forms.
+func Unmarshal(rawPacket []byte) (Packet, Header, error) {
-type PacketWithHeader struct {
+	var h Header
-	Header
+	var p Packet
-	Packet
-	RawPacket []byte
-}
 
-//Marshal a PakcetWithHeader to a bytearray
+	err := h.Unmarshal(rawPacket)
-func (p PacketWithHeader) Marshal() ([]byte, error) {
-	return p.Packet.Marshal()
-}
-
-//Unmarshal a bytearray to a header-packet pair
-func (p *PacketWithHeader) Unmarshal(rawPacket []byte) error {
-
-	p.RawPacket = rawPacket
-
-	if err := p.Header.Unmarshal(rawPacket); err != nil {
-		return err
-	}
-
-	switch p.Header.Type {
-	case TypeSenderReport:
-		sr := new(SenderReport)
-		err := sr.Unmarshal(rawPacket)
 	if err != nil {
-			return err
+		return nil, h, err
 	}
-		p.Packet = sr
+
+	switch h.Type {
+	case TypeSenderReport:
+		p = new(SenderReport)
 
 	case TypeReceiverReport:
-		rr := new(ReceiverReport)
+		p = new(ReceiverReport)
-		err := rr.Unmarshal(rawPacket)
-		if err != nil {
-			return err
-		}
-		p.Packet = rr
 
 	case TypeSourceDescription:
-		sdes := new(SourceDescription)
+		p = new(SourceDescription)
-		err := sdes.Unmarshal(rawPacket)
-		if err != nil {
-			return err
-		}
-		p.Packet = sdes
 
 	case TypeGoodbye:
-		bye := new(Goodbye)
+		p = new(Goodbye)
-		err := bye.Unmarshal(rawPacket)
-		if err != nil {
-			return err
-		}
-		p.Packet = bye
 
 	case TypeTransportSpecificFeedback:
-		rrr := new(RapidResynchronizationRequest)
+		p = new(RapidResynchronizationRequest)
-		err := rrr.Unmarshal(rawPacket)
-		if err != nil {
-			return err
-		}
-		p.Packet = rrr
 
 	case TypePayloadSpecificFeedback:
-		psfb := new(PictureLossIndication)
+		p = new(PictureLossIndication)
-		err := psfb.Unmarshal(rawPacket)
-		if err != nil {
-			return err
-		}
-		p.Packet = psfb
 
 	default:
-		return errWrongType
+		return nil, h, errWrongType
 	}
 
-	return nil
+	err = p.Unmarshal(rawPacket)
+	return p, h, err
+
 }

pkg/rtcp/reader_test.go

@@ -79,11 +79,11 @@ func TestUnmarshal(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Read rr: %v", err)
 	}
-	var pwh PacketWithHeader
+	var parsed Packet
-	if err = pwh.Unmarshal(packet); err != nil {
+	if parsed, _, err = Unmarshal(packet); err != nil {
-		t.Errorf("Unmarshal pwh: %v", err)
+		t.Errorf("Unmarshal parsed: %v", err)
 	}
-	assert.IsType(t, pwh.Packet, (*ReceiverReport)(nil), "Unmarshalled to incorrect type")
+	assert.IsType(t, parsed, (*ReceiverReport)(nil), "Unmarshalled to incorrect type")
 
 	wantRR := &ReceiverReport{
 		SSRC: 0x902f9e2e,
@@ -97,7 +97,7 @@ func TestUnmarshal(t *testing.T) {
 			Delay:              150137,
 		}},
 	}
-	if got, want := wantRR, pwh.Packet; !reflect.DeepEqual(got, want) {
+	if got, want := wantRR, parsed; !reflect.DeepEqual(got, want) {
 		t.Errorf("Unmarshal rr: got %#v, want %#v", got, want)
 	}
 
@@ -107,10 +107,10 @@ func TestUnmarshal(t *testing.T) {
 		t.Fatalf("Read sdes: %v", err)
 	}
 
-	if err = pwh.Unmarshal(packet); err != nil {
+	if parsed, _, err = Unmarshal(packet); err != nil {
-		t.Errorf("Unmarshal pwh: %v", err)
+		t.Errorf("Unmarshal parsed: %v", err)
 	}
-	assert.IsType(t, pwh.Packet, (*SourceDescription)(nil), "Unmarshalled to incorrect type")
+	assert.IsType(t, parsed, (*SourceDescription)(nil), "Unmarshalled to incorrect type")
 
 	wantSdes := &SourceDescription{
 		Chunks: []SourceDescriptionChunk{
@@ -126,7 +126,7 @@ func TestUnmarshal(t *testing.T) {
 		},
 	}
 
-	if got, want := pwh.Packet, wantSdes; !reflect.DeepEqual(got, want) {
+	if got, want := parsed, wantSdes; !reflect.DeepEqual(got, want) {
 		t.Errorf("Unmarshal sdes: got %#v, want %#v", got, want)
 	}
 
@@ -136,16 +136,16 @@ func TestUnmarshal(t *testing.T) {
 		t.Fatalf("Read bye: %v", err)
 	}
 
-	if err = pwh.Unmarshal(packet); err != nil {
+	if parsed, _, err = Unmarshal(packet); err != nil {
-		t.Errorf("Unmarshal pwh: %v", err)
+		t.Errorf("Unmarshal parsed: %v", err)
 	}
 
-	assert.IsType(t, pwh.Packet, (*Goodbye)(nil), "Unmarshalled to incorrect type")
+	assert.IsType(t, parsed, (*Goodbye)(nil), "Unmarshalled to incorrect type")
 
 	wantBye := &Goodbye{
 		Sources: []uint32{0x902f9e2e},
 	}
-	if got, want := pwh.Packet, wantBye; !reflect.DeepEqual(got, want) {
+	if got, want := parsed, wantBye; !reflect.DeepEqual(got, want) {
 		t.Errorf("Unmarshal bye: got %#v, want %#v", got, want)
 	}
 
@@ -155,17 +155,17 @@ func TestUnmarshal(t *testing.T) {
 		t.Fatalf("Read pli: %v", err)
 	}
 
-	if err = pwh.Unmarshal(packet); err != nil {
+	if parsed, _, err = Unmarshal(packet); err != nil {
-		t.Errorf("Unmarshal pwh: %v", err)
+		t.Errorf("Unmarshal parsed: %v", err)
 	}
 
-	assert.IsType(t, pwh.Packet, (*PictureLossIndication)(nil), "Unmarshalled to incorrect type")
+	assert.IsType(t, parsed, (*PictureLossIndication)(nil), "Unmarshalled to incorrect type")
 
 	wantPli := &PictureLossIndication{
 		SenderSSRC: 0x902f9e2e,
 		MediaSSRC:  0x902f9e2e,
 	}
-	if got, want := pwh.Packet, wantPli; !reflect.DeepEqual(got, want) {
+	if got, want := parsed, wantPli; !reflect.DeepEqual(got, want) {
 		t.Errorf("Unmarshal pli: got %#v, want %#v", got, want)
 	}
 
@@ -175,17 +175,17 @@ func TestUnmarshal(t *testing.T) {
 		t.Fatalf("Read rrr: %v", err)
 	}
 
-	if err = pwh.Unmarshal(packet); err != nil {
+	if parsed, _, err = Unmarshal(packet); err != nil {
-		t.Errorf("Unmarshal pwh: %v", err)
+		t.Errorf("Unmarshal parsed: %v", err)
 	}
 
-	assert.IsType(t, pwh.Packet, (*RapidResynchronizationRequest)(nil), "Unmarshalled to incorrect type")
+	assert.IsType(t, parsed, (*RapidResynchronizationRequest)(nil), "Unmarshalled to incorrect type")
 
 	wantRrr := &RapidResynchronizationRequest{
 		SenderSSRC: 0x902f9e2e,
 		MediaSSRC:  0x902f9e2e,
 	}
-	if got, want := pwh.Packet, wantRrr; !reflect.DeepEqual(got, want) {
+	if got, want := parsed, wantRrr; !reflect.DeepEqual(got, want) {
 		t.Errorf("Unmarshal rrr: got %#v, want %#v", got, want)
 	}
 }

rtcpeerconnection.go

@@ -1029,7 +1029,7 @@ func (pc *RTCPeerConnection) generateChannel(ssrc uint32, payloadType uint8) (tp
 	}
 
 	rtpTransport := make(chan *rtp.Packet, 15)
-	rtcpTransport := make(chan *rtcp.PacketWithHeader, 15)
+	rtcpTransport := make(chan rtcp.Packet, 15)
 
 	track := &RTCTrack{
 		PayloadType: payloadType,
@@ -1202,7 +1202,7 @@ func (pc *RTCPeerConnection) newRTCTrack(payloadType uint8, ssrc uint32, id, lab
 
 	trackInput := make(chan media.RTCSample, 15) // Is the buffering needed?
 	rawPackets := make(chan *rtp.Packet)
-	rtcpPackets := make(chan *rtcp.PacketWithHeader)
+	rtcpPackets := make(chan rtcp.Packet)
 	if ssrc == 0 {
 		buf := make([]byte, 4)
 		_, err = rand.Read(buf)