Implement RTP/RTCP related stats

This Commit adds the RTP and RTCP related statistics from the WebRTC
statistics API (https://w3c.github.io/webrtc-stats/) draft, that are
easy to gather by intercepting RTP/RTCP streams.

Author: mengelbart

internal/ntp/ntp.go

@@ -0,0 +1,27 @@
+// Package ntp provides conversion methods between time.Time and NTP timestamps
+// stored in uint64
+package ntp
+
+import (
+	"time"
+)
+
+// ToNTP converts a time.Time oboject to an uint64 NTP timestamp
+func ToNTP(t time.Time) uint64 {
+	// seconds since 1st January 1900
+	s := (float64(t.UnixNano()) / 1000000000) + 2208988800
+
+	// higher 32 bits are the integer part, lower 32 bits are the fractional part
+	integerPart := uint32(s)
+	fractionalPart := uint32((s - float64(integerPart)) * 0xFFFFFFFF)
+	return uint64(integerPart)<<32 | uint64(fractionalPart)
+}
+
+// ToTime converts a uint64 NTP timestamps to a time.Time object
+func ToTime(t uint64) time.Time {
+	seconds := (t & 0xFFFFFFFF00000000) >> 32
+	fractional := float64(t&0x00000000FFFFFFFF) / float64(0xFFFFFFFF)
+	d := time.Duration(seconds)*time.Second + time.Duration(fractional*1e9)*time.Nanosecond
+
+	return time.Unix(0, 0).Add(-2208988800 * time.Second).Add(d)
+}

internal/ntp/ntp_test.go

@@ -0,0 +1,49 @@
+package ntp
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNTPTimeConverstion(t *testing.T) {
+	for i, cc := range []struct {
+		ts time.Time
+	}{
+		{
+			ts: time.Now(),
+		},
+		{
+			ts: time.Unix(0, 0),
+		},
+	} {
+		t.Run(fmt.Sprintf("TimeToNTP/%v", i), func(t *testing.T) {
+			assert.InDelta(t, cc.ts.UnixNano(), ToTime(ToNTP(cc.ts)).UnixNano(), float64(time.Millisecond.Nanoseconds()))
+		})
+	}
+}
+
+func TestTimeToNTPConverstion(t *testing.T) {
+	for i, cc := range []struct {
+		ts uint64
+	}{
+		{
+			ts: 0,
+		},
+		{
+			ts: 65535,
+		},
+		{
+			ts: 16606669245815957503,
+		},
+		{
+			ts: 9487534653230284800,
+		},
+	} {
+		t.Run(fmt.Sprintf("TimeToNTP/%v", i), func(t *testing.T) {
+			assert.Equal(t, cc.ts, ToNTP(ToTime(cc.ts)))
+		})
+	}
+}

internal/sequencenumber/unwrapper.go

@@ -0,0 +1,42 @@
+// Package sequencenumber provides a sequence number unwrapper
+package sequencenumber
+
+const (
+	maxSequenceNumberPlusOne = int64(65536)
+	breakpoint               = 32768 // half of max uint16
+)
+
+// Unwrapper stores an unwrapped sequence number
+type Unwrapper struct {
+	init          bool
+	lastUnwrapped int64
+}
+
+func isNewer(value, previous uint16) bool {
+	if value-previous == breakpoint {
+		return value > previous
+	}
+	return value != previous && (value-previous) < breakpoint
+}
+
+// Unwrap unwraps the next sequencenumber
+func (u *Unwrapper) Unwrap(i uint16) int64 {
+	if !u.init {
+		u.init = true
+		u.lastUnwrapped = int64(i)
+		return u.lastUnwrapped
+	}
+
+	lastWrapped := uint16(u.lastUnwrapped)
+	delta := int64(i - lastWrapped)
+	if isNewer(i, lastWrapped) {
+		if delta < 0 {
+			delta += maxSequenceNumberPlusOne
+		}
+	} else if delta > 0 && u.lastUnwrapped+delta-maxSequenceNumberPlusOne >= 0 {
+		delta -= maxSequenceNumberPlusOne
+	}
+
+	u.lastUnwrapped += delta
+	return u.lastUnwrapped
+}

internal/sequencenumber/unwrapper_test.go

@@ -0,0 +1,104 @@
+package sequencenumber
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsNewer(t *testing.T) {
+	cases := []struct {
+		a, b     uint16
+		expected bool
+	}{
+		{
+			a:        1,
+			b:        0,
+			expected: true,
+		},
+		{
+			a:        65534,
+			b:        65535,
+			expected: false,
+		},
+		{
+			a:        65535,
+			b:        65535,
+			expected: false,
+		},
+		{
+			a:        0,
+			b:        65535,
+			expected: true,
+		},
+		{
+			a:        0,
+			b:        32767,
+			expected: false,
+		},
+		{
+			a:        32770,
+			b:        2,
+			expected: true,
+		},
+		{
+			a:        3,
+			b:        32770,
+			expected: false,
+		},
+	}
+	for i, tc := range cases {
+		t.Run(fmt.Sprintf("%v", i), func(t *testing.T) {
+			assert.Equalf(t, tc.expected, isNewer(tc.a, tc.b), "expected isNewer(%v, %v) to be %v", tc.a, tc.b, tc.expected)
+		})
+	}
+}
+
+func TestUnwrapper(t *testing.T) {
+	cases := []struct {
+		input    []uint16
+		expected []int64
+	}{
+		{
+			input:    []uint16{},
+			expected: []int64{},
+		},
+		{
+			input:    []uint16{0, 1, 2, 3, 4},
+			expected: []int64{0, 1, 2, 3, 4},
+		},
+		{
+			input:    []uint16{65534, 65535, 0, 1, 2},
+			expected: []int64{65534, 65535, 65536, 65537, 65538},
+		},
+		{
+			input:    []uint16{32769, 0},
+			expected: []int64{32769, 65536},
+		},
+		{
+			input:    []uint16{32767, 0},
+			expected: []int64{32767, 0},
+		},
+		{
+			input: []uint16{
+				0, 32767, 32768, 32769, 32770,
+				1, 2, 32765, 32770, 65535,
+			},
+			expected: []int64{
+				0, 32767, 32768, 32769, 32770,
+				65537, 65538, 98301, 98306, 131071,
+			},
+		},
+	}
+	for i, tc := range cases {
+		t.Run(fmt.Sprintf("%v", i), func(t *testing.T) {
+			u := &Unwrapper{}
+			result := []int64{}
+			for _, i := range tc.input {
+				result = append(result, u.Unwrap(i))
+			}
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}