improve documentation

Author: aler9

pkg/ntp/ntp.go

@@ -1,12 +1,12 @@
-// Package ntp contains functions to encode and decode timestamps to/from NTP format.
+// Package ntp contains functions to encode and decode timestamps to/from the NTP format.
 package ntp
 
 import (
 	"math"
 	"time"
 )
 
-// Encode encodes a timestamp in NTP format.
+// Encode encodes a timestamp in the NTP format.
 // Specification: RFC3550, section 4
 func Encode(t time.Time) uint64 {
 	ntp := uint64(t.UnixNano()) + 2208988800*1000000000
@@ -15,7 +15,7 @@ func Encode(t time.Time) uint64 {
 	return secs<<32 | fractional
 }
 
-// Decode decodes a timestamp from NTP format.
+// Decode decodes a timestamp from the NTP format.
 // Specification: RFC3550, section 4
 func Decode(v uint64) time.Time {
 	secs := int64((v >> 32) - 2208988800)

pkg/rtpreceiver/receiver.go

@@ -51,8 +51,8 @@ type Receiver struct {
 	sequenceNumberCycles   uint16
 	lastValidSeqNum        uint16
 	remoteSSRC             uint32
-	lastTimeRTP            uint32
-	lastTimeSystem         time.Time
+	lastRTP                uint32
+	lastSystem             time.Time
 	totalLost              uint32
 	totalLostSinceReport   uint32
 	totalSinceReport       uint32
@@ -195,8 +195,8 @@ func (rr *Receiver) ProcessPacket2(
 
 		if ptsEqualsDTS {
 			rr.timeInitialized = true
-			rr.lastTimeRTP = pkt.Timestamp
-			rr.lastTimeSystem = system
+			rr.lastRTP = pkt.Timestamp
+			rr.lastSystem = system
 		}
 
 		return []*rtp.Packet{pkt}, 0
@@ -240,17 +240,17 @@ func (rr *Receiver) ProcessPacket2(
 			if rr.timeInitialized && rr.ClockRate != 0 {
 				// update jitter
 				// https://tools.ietf.org/html/rfc3550#page-39
-				D := system.Sub(rr.lastTimeSystem).Seconds()*float64(rr.ClockRate) -
-					(float64(pkt.Timestamp) - float64(rr.lastTimeRTP))
+				D := system.Sub(rr.lastSystem).Seconds()*float64(rr.ClockRate) -
+					(float64(pkt.Timestamp) - float64(rr.lastRTP))
 				if D < 0 {
 					D = -D
 				}
 				rr.jitter += (D - rr.jitter) / 16
 			}
 
 			rr.timeInitialized = true
-			rr.lastTimeRTP = pkt.Timestamp
-			rr.lastTimeSystem = system
+			rr.lastRTP = pkt.Timestamp
+			rr.lastSystem = system
 		}
 	}
 
@@ -404,12 +404,12 @@ func (rr *Receiver) Stats() *Stats {
 		return nil
 	}
 
-	ntp, _ := rr.packetNTPUnsafe(rr.lastTimeRTP)
+	ntp, _ := rr.packetNTPUnsafe(rr.lastRTP)
 
 	return &Stats{
 		RemoteSSRC:         rr.remoteSSRC,
 		LastSequenceNumber: rr.lastValidSeqNum,
-		LastRTP:            rr.lastTimeRTP,
+		LastRTP:            rr.lastRTP,
 		LastNTP:            ntp,
 		Jitter:             rr.jitter,
 		TotalReceived:      rr.totalReceived,

pkg/rtpsender/sender.go

@@ -24,9 +24,9 @@ type Sender struct {
 
 	// data from RTP packets
 	firstRTPPacketSent bool
-	lastTimeRTP        uint32
-	lastTimeNTP        time.Time
-	lastTimeSystem     time.Time
+	lastRTP            uint32
+	lastNTP            time.Time
+	lastSystem         time.Time
 	localSSRC          uint32
 	lastSequenceNumber uint16
 	packetCount        uint32
@@ -83,9 +83,9 @@ func (rs *Sender) report() rtcp.Packet {
 		return nil
 	}
 
-	systemTimeDiff := rs.TimeNow().Sub(rs.lastTimeSystem)
-	ntpTime := rs.lastTimeNTP.Add(systemTimeDiff)
-	rtpTime := rs.lastTimeRTP + uint32(systemTimeDiff.Seconds()*float64(rs.ClockRate))
+	systemDiffDiff := rs.TimeNow().Sub(rs.lastSystem)
+	ntpTime := rs.lastNTP.Add(systemDiffDiff)
+	rtpTime := rs.lastRTP + uint32(systemDiffDiff.Seconds()*float64(rs.ClockRate))
 
 	return &rtcp.SenderReport{
 		SSRC:        rs.localSSRC,
@@ -103,9 +103,9 @@ func (rs *Sender) ProcessPacket(pkt *rtp.Packet, ntp time.Time, ptsEqualsDTS boo
 
 	if ptsEqualsDTS {
 		rs.firstRTPPacketSent = true
-		rs.lastTimeRTP = pkt.Timestamp
-		rs.lastTimeNTP = ntp
-		rs.lastTimeSystem = rs.TimeNow()
+		rs.lastRTP = pkt.Timestamp
+		rs.lastNTP = ntp
+		rs.lastSystem = rs.TimeNow()
 		rs.localSSRC = pkt.SSRC
 	}
 
@@ -135,8 +135,8 @@ func (rs *Sender) Stats() *Stats {
 
 	return &Stats{
 		LastSequenceNumber: rs.lastSequenceNumber,
-		LastRTP:            rs.lastTimeRTP,
-		LastNTP:            rs.lastTimeNTP,
+		LastRTP:            rs.lastRTP,
+		LastNTP:            rs.lastNTP,
 		TotalSent:          rs.packetCount2,
 	}
 }

pkg/rtptime/global_decoder.go

@@ -39,7 +39,7 @@ type GlobalDecoderTrack interface {
 type GlobalDecoder struct {
 	mutex             sync.Mutex
 	leadingTrack      GlobalDecoderTrack
-	startNTP          time.Time
+	startSystem       time.Time
 	startPTS          int64
 	startPTSClockRate int64
 	tracks            map[GlobalDecoderTrack]*globalDecoderTrackData
@@ -74,14 +74,14 @@ func (d *GlobalDecoder) Decode(
 
 		if d.leadingTrack == nil {
 			d.leadingTrack = track
-			d.startNTP = now
+			d.startSystem = now
 			d.startPTS = 0
 			d.startPTSClockRate = int64(track.ClockRate())
 		}
 
 		// start from the PTS of the leading track
 		startPTS := multiplyAndDivide(d.startPTS, int64(track.ClockRate()), d.startPTSClockRate)
-		startPTS += multiplyAndDivide(int64(now.Sub(d.startNTP)), int64(track.ClockRate()), int64(time.Second))
+		startPTS += multiplyAndDivide(int64(now.Sub(d.startSystem)), int64(track.ClockRate()), int64(time.Second))
 
 		d.tracks[track] = &globalDecoderTrackData{
 			overall: startPTS,
@@ -93,10 +93,10 @@ func (d *GlobalDecoder) Decode(
 
 	pts := df.decode(pkt.Timestamp)
 
-	// update startNTP / startPTS
+	// update startSystem / startPTS
 	if d.leadingTrack == track && track.PTSEqualsDTS(pkt) {
 		now := timeNow()
-		d.startNTP = now
+		d.startSystem = now
 		d.startPTS = pts
 	}