Fixing linter errors

pkg/flexfec/flexfec_coverage.go

@@ -12,8 +12,10 @@ import (
 // We are not supporting the possibility of having an FEC packet protect multiple
 // SSRC source packets for now.
 // https://datatracker.ietf.org/doc/html/rfc8627#section-4.2.2.1
-const MaxMediaPackets uint32 = 110
-const MaxFecPackets uint32 = MaxMediaPackets
+const (
+	MaxMediaPackets uint32 = 110
+	MaxFecPackets   uint32 = MaxMediaPackets
+)
 
 type ProtectionCoverage struct {
 	// Array of masks, each mask capable of covering up to maxMediaPkts = 110.
@@ -66,7 +68,6 @@ func (p *ProtectionCoverage) ResetCoverage() {
 			p.packetMasks[i].SetBit(j, 0)
 		}
 	}
-
 }
 
 func (p *ProtectionCoverage) GetCoveredBy(fecPacketIndex uint32) *util.MediaPacketIterator {
@@ -92,5 +93,5 @@ func (p *ProtectionCoverage) ExtractMask2(fecPacketIndex uint32) uint32 {
 }
 
 func (p *ProtectionCoverage) ExtractMask3(fecPacketIndex uint32) uint64 {
-	return uint64(p.packetMasks[fecPacketIndex].GetBitValue(46, 109))
+	return p.packetMasks[fecPacketIndex].GetBitValue(46, 109)
 }

pkg/flexfec/flexfec_encoder.go

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
 // SPDX-License-Identifier: MIT
 
+// Package flexfec implements FlexFEC to recover missing RTP packets due to packet loss.
+// https://datatracker.ietf.org/doc/html/rfc8627
 package flexfec
 
 import (
@@ -10,8 +12,10 @@ import (
 	"github.com/pion/rtp"
 )
 
-const BaseRtpHeaderSize = 12
-const BaseFecHeaderSize = 12
+const (
+	BaseRtpHeaderSize = 12
+	BaseFecHeaderSize = 12
+)
 
 type FlexFecEncoder struct {
 	baseSN      uint16
@@ -33,9 +37,8 @@ func NewFlexFecEncoder(baseSN uint16, payloadType uint8, ssrc uint32) *FlexFecEn
 // Encoding will be skipped if there are missing Media packets.
 func (flex *FlexFecEncoder) EncodeFec(mediaPackets []rtp.Packet, numFecPackets uint32) []rtp.Packet {
 	// Start by defining which FEC packets cover which media packets
-	// We transform mediaPackets array into a slice to avoid as many copies as possible.
 	if flex.coverage == nil {
-		flex.coverage = NewCoverage(mediaPackets[:], numFecPackets)
+		flex.coverage = NewCoverage(mediaPackets, numFecPackets)
 	} else {
 		flex.coverage.ResetCoverage()
 	}
@@ -118,7 +121,11 @@ func (flex *FlexFecEncoder) encodeFlexFecHeader(mediaPackets *util.MediaPacketIt
 	tmpMediaPacketBuf := make([]byte, headerSize)
 	for mediaPackets.HasNext() {
 		mediaPacket := mediaPackets.Next()
-		mediaPacket.MarshalTo(tmpMediaPacketBuf)
+		n, err := mediaPacket.MarshalTo(tmpMediaPacketBuf)
+
+		if n == 0 || err != nil {
+			return nil
+		}
 
 		// XOR the first 2 bytes of the header: V, P, X, CC, M, PT fields
 		flexFecHeader[0] ^= tmpMediaPacketBuf[0]

pkg/flexfec/util/bitarray.go

@@ -1,14 +1,16 @@
 // SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
 // SPDX-License-Identifier: MIT
 
+// Package util implements utilities to better support Fec decoding / encoding.
 package util
 
+// BitArray provides support for bitmask manipulations.
 type BitArray struct {
 	bytes []byte
 }
 
-// Returns a bit array as an array of bytes, where sizeBits represents
-// the number of bits that the byte array should hold.
+// NewBitArray returns a new BitArray. It takes sizeBits as parameter which represents
+// the size of the underlying bitmask.
 func NewBitArray(sizeBits uint32) BitArray {
 	sizeBytes := uint32(0)
 	if sizeBits%8 == 0 {
@@ -22,6 +24,7 @@ func NewBitArray(sizeBits uint32) BitArray {
 	}
 }
 
+// SetBit sets a bit to the specified bit value on the bitmask.
 func (b *BitArray) SetBit(bitIndex uint32, bitValue uint32) {
 	byteIndex := bitIndex / 8
 	bitOffset := uint(bitIndex % 8)
@@ -34,6 +37,7 @@ func (b *BitArray) SetBit(bitIndex uint32, bitValue uint32) {
 	}
 }
 
+// GetBit returns the bit value at a specified index of the bitmask.
 func (b *BitArray) GetBit(bitIndex uint32) uint8 {
 	return b.bytes[bitIndex/8]
 }
@@ -60,13 +64,13 @@ func (b *BitArray) GetBitValue(i int, j int) uint64 {
 	// Loop through the bytes and concatenate the bits
 	for idx, b := range subArray {
 		if idx == 0 {
-			b = b << uint(startBit)
+			b <<= uint(startBit)
 		}
 		result |= uint64(b)
 	}
 
 	// Mask the bits that are not part of the desired range
-	result = result & (1<<uint(j-i+1) - 1)
+	result &= (1<<uint(j-i+1) - 1)
 
 	return result
 }

pkg/flexfec/util/media_packet_iterator.go

@@ -5,12 +5,15 @@ package util
 
 import "github.com/pion/rtp"
 
+// MediaPacketIterator supports iterating through a list of media packets protected by
+// a specific Fec packet.
 type MediaPacketIterator struct {
 	mediaPackets   []rtp.Packet
 	coveredIndices []uint32
 	nextIndex      int
 }
 
+// NewMediaPacketIterator returns a new MediaPacketIterator.
 func NewMediaPacketIterator(mediaPackets []rtp.Packet, coveredIndices []uint32) *MediaPacketIterator {
 	return &MediaPacketIterator{
 		mediaPackets:   mediaPackets,
@@ -19,15 +22,19 @@ func NewMediaPacketIterator(mediaPackets []rtp.Packet, coveredIndices []uint32)
 	}
 }
 
+// Reset sets the starting iterating index back to 0.
 func (m *MediaPacketIterator) Reset() *MediaPacketIterator {
 	m.nextIndex = 0
 	return m
 }
 
+// HasNext indicates whether or not there are more media packets
+// that can be iterated through.
 func (m *MediaPacketIterator) HasNext() bool {
 	return m.nextIndex < len(m.coveredIndices)
 }
 
+// Next returns the next media packet to iterate through.
 func (m *MediaPacketIterator) Next() *rtp.Packet {
 	if m.nextIndex == len(m.coveredIndices) {
 		return nil