zishuo/webrtc
1
0
Fork 0
mirror of https://github.com/pion/webrtc.git synced 2025-10-31 18:52:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove PacketWithHeader type

Browse Source 
This simplifies the RTCP interface, and saves a bit of code.
Relates to #119
This commit is contained in:
Woodrow Douglass
2018-11-28 15:54:32 -05:00
committed by Max Hawkins
parent 510829772e
commit 81ceadeb71
6 changed files with 55 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
internal/network/manager.go
View File

@@ -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]

21
internal/network/port-receive.go
View File

@@ -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

2
media.go
View File

@@ -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
}

78
pkg/rtcp/packet.go
View File

@@ -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
}
switch p.Header.Type {
case TypeSenderReport:
sr := new(SenderReport)
err := sr.Unmarshal(rawPacket)
err := h.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)
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
}

42
pkg/rtcp/reader_test.go
View File

@@ -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)
}
}

4
rtcpeerconnection.go
View File

@@ -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)