diff --git a/internal/network/manager.go b/internal/network/manager.go index 984d83ea..cda6801d 100644 --- a/internal/network/manager.go +++ b/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] diff --git a/internal/network/port-receive.go b/internal/network/port-receive.go index 6f73bcdb..cfd66d89 100644 --- a/internal/network/port-receive.go +++ b/internal/network/port-receive.go @@ -44,8 +44,9 @@ func (p *port) handleSRTP(buffer []byte) { return } { - var report rtcp.PacketWithHeader - err = report.Unmarshal(decrypted) + var report rtcp.Packet + 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 diff --git a/media.go b/media.go index 61618950..5a43d560 100644 --- a/media.go +++ b/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 } diff --git a/pkg/rtcp/packet.go b/pkg/rtcp/packet.go index 658d8276..ab71ba66 100644 --- a/pkg/rtcp/packet.go +++ b/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 -// packet's polymorphic parsed and unparsed forms. -type PacketWithHeader struct { - Header - Packet - RawPacket []byte -} +// Unmarshal is a factory a polymorphic RTCP packet, and its header, +func Unmarshal(rawPacket []byte) (Packet, Header, error) { + var h Header + var p Packet -//Marshal a PakcetWithHeader to a bytearray -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 + err := h.Unmarshal(rawPacket) + if err != nil { + return nil, h, err } - switch p.Header.Type { + switch h.Type { case TypeSenderReport: - sr := new(SenderReport) - err := sr.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = sr + p = new(SenderReport) case TypeReceiverReport: - rr := new(ReceiverReport) - err := rr.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = rr + p = new(ReceiverReport) case TypeSourceDescription: - sdes := new(SourceDescription) - err := sdes.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = sdes + p = new(SourceDescription) case TypeGoodbye: - bye := new(Goodbye) - err := bye.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = bye + p = new(Goodbye) case TypeTransportSpecificFeedback: - rrr := new(RapidResynchronizationRequest) - err := rrr.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = rrr + p = new(RapidResynchronizationRequest) case TypePayloadSpecificFeedback: - psfb := new(PictureLossIndication) - err := psfb.Unmarshal(rawPacket) - if err != nil { - return err - } - p.Packet = psfb + p = new(PictureLossIndication) default: - return errWrongType + return nil, h, errWrongType } - return nil + err = p.Unmarshal(rawPacket) + return p, h, err + } diff --git a/pkg/rtcp/reader_test.go b/pkg/rtcp/reader_test.go index 800d503e..ed3a92cb 100644 --- a/pkg/rtcp/reader_test.go +++ b/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 - if err = pwh.Unmarshal(packet); err != nil { - t.Errorf("Unmarshal pwh: %v", err) + var parsed Packet + if parsed, _, err = Unmarshal(packet); err != nil { + 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 { - t.Errorf("Unmarshal pwh: %v", err) + if parsed, _, err = Unmarshal(packet); err != nil { + 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 { - t.Errorf("Unmarshal pwh: %v", err) + if parsed, _, err = Unmarshal(packet); err != nil { + 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 { - t.Errorf("Unmarshal pwh: %v", err) + if parsed, _, err = Unmarshal(packet); err != nil { + 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 { - t.Errorf("Unmarshal pwh: %v", err) + if parsed, _, err = Unmarshal(packet); err != nil { + 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) } } diff --git a/rtcpeerconnection.go b/rtcpeerconnection.go index 3d24076e..ae0c3ecb 100644 --- a/rtcpeerconnection.go +++ b/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)