update linter settings (#840)

.golangci.yml

@@ -67,6 +67,9 @@ linters:
       disable:
       - fieldalignment
       - reflectvaluecompare
+      settings:
+        shadow:
+          strict: true
 
 formatters:
   enable:

client_play_test.go

@@ -1315,16 +1315,16 @@ func TestClientPlayAnyPort(t *testing.T) {
 				if ca == "random" {
 					// skip firewall opening
 					buf := make([]byte, 2048)
-					_, _, err = l1b.ReadFrom(buf)
+					_, _, err2 = l1b.ReadFrom(buf)
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
 					buf = make([]byte, 2048)
 					var n int
-					n, _, err = l1b.ReadFrom(buf)
+					n, _, err2 = l1b.ReadFrom(buf)
-					require.NoError(t, err)
+					require.NoError(t, err2)
 					var packets []rtcp.Packet
-					packets, err = rtcp.Unmarshal(buf[:n])
+					packets, err2 = rtcp.Unmarshal(buf[:n])
-					require.NoError(t, err)
+					require.NoError(t, err2)
 					require.Equal(t, &testRTCPPacket, packets[0])
 					close(serverRecv)
 				}
@@ -1351,7 +1351,7 @@ func TestClientPlayAnyPort(t *testing.T) {
 			<-packetRecv
 
 			if ca == "random" {
-				err := c.WritePacketRTCP(med, &testRTCPPacket)
+				err = c.WritePacketRTCP(med, &testRTCPPacket)
 				require.NoError(t, err)
 				<-serverRecv
 			}

client_record_test.go

@@ -613,7 +613,7 @@ func TestClientRecordSocketError(t *testing.T) {
 			defer ti.Stop()
 
 			for range ti.C {
-				err := c.WritePacketRTP(medi, &testRTPPacket)
+				err = c.WritePacketRTP(medi, &testRTPPacket)
 				if err != nil {
 					break
 				}

client_test.go

@@ -178,8 +178,8 @@ func TestClientCloseDuringRequest(t *testing.T) {
 	optionsDone := make(chan struct{})
 	go func() {
 		defer close(optionsDone)
-		_, err := c.Options(u)
+		_, err2 := c.Options(u)
-		require.Error(t, err)
+		require.Error(t, err2)
 	}()
 
 	<-requestReceived
@@ -534,7 +534,8 @@ func TestClientReplyToServerRequest(t *testing.T) {
 					})
 					require.NoError(t, err2)
 
-					res, err2 := conn.ReadResponse()
+					var res *base.Response
+					res, err2 = conn.ReadResponse()
 					require.NoError(t, err2)
 					require.Equal(t, base.StatusOK, res.StatusCode)
 					require.Equal(t, "4", res.Header["CSeq"][0])

examples/client-play-backchannel/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
 	"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
+	"github.com/pion/rtp"
 )
 
 // This example shows how to
@@ -129,7 +130,8 @@ func main() {
 		}
 
 		// generate RTP packets from G711 samples
-		pkts, err := rtpEnc.Encode(samples)
+		var pkts []*rtp.Packet
+		pkts, err = rtpEnc.Encode(samples)
 		if err != nil {
 			panic(err)
 		}

examples/client-play-pause/main.go

@@ -71,7 +71,7 @@ func main() {
 		time.Sleep(5 * time.Second)
 
 		// pause
-		_, err := c.Pause()
+		_, err = c.Pause()
 		if err != nil {
 			panic(err)
 		}

examples/client-record-format-g711/main.go

@@ -10,6 +10,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
 	"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
+	"github.com/pion/rtp"
 )
 
 // This example shows how to
@@ -89,7 +90,8 @@ func main() {
 		}
 
 		// generate RTP packets from G711 samples
-		pkts, err := rtpEnc.Encode(samples)
+		var pkts []*rtp.Packet
+		pkts, err = rtpEnc.Encode(samples)
 		if err != nil {
 			panic(err)
 		}

examples/client-record-format-h264-from-disk/main.go

@@ -14,6 +14,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
 	"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
+	"github.com/pion/rtp"
 )
 
 // This example shows how to
@@ -88,7 +89,8 @@ func main() {
 		}
 
 		// find the H264 track inside the file
-		track, err := findTrack(r)
+		var track *mpegts.Track
+		track, err = findTrack(r)
 		if err != nil {
 			panic(err)
 		}
@@ -119,7 +121,8 @@ func main() {
 			log.Printf("writing access unit with pts=%d dts=%d", pts, dts)
 
 			// wrap the access unit into RTP packets
-			packets, err := rtpEnc.Encode(au)
+			var packets []*rtp.Packet
+			packets, err = rtpEnc.Encode(au)
 			if err != nil {
 				return err
 			}
@@ -134,7 +137,7 @@ func main() {
 
 			// write RTP packets to the server
 			for _, packet := range packets {
-				err := c.WritePacketRTP(desc.Medias[0], packet)
+				err = c.WritePacketRTP(desc.Medias[0], packet)
 				if err != nil {
 					return err
 				}
@@ -145,7 +148,7 @@ func main() {
 
 		// read the file
 		for {
-			err := r.Read()
+			err = r.Read()
 			if err != nil {
 				// file has ended
 				if errors.Is(err, io.EOF) {

examples/client-record-format-lpcm/main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
+	"github.com/pion/rtp"
 )
 
 // This example shows how to
@@ -81,7 +82,8 @@ func main() {
 		samples := createDummyAudio(pts, prevPTS)
 
 		// generate RTP packets from LPCM samples
-		pkts, err := rtpEnc.Encode(samples)
+		var pkts []*rtp.Packet
+		pkts, err = rtpEnc.Encode(samples)
 		if err != nil {
 			panic(err)
 		}

examples/client-record-format-mjpeg/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/description"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
+	"github.com/pion/rtp"
 )
 
 // This example shows how to
@@ -79,13 +80,14 @@ func main() {
 
 		// encode the image with JPEG
 		var buf bytes.Buffer
-		err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 80})
+		err = jpeg.Encode(&buf, img, &jpeg.Options{Quality: 80})
 		if err != nil {
 			panic(err)
 		}
 
 		// generate RTP packets from the JPEG image
-		pkts, err := rtpEnc.Encode(buf.Bytes())
+		var pkts []*rtp.Packet
+		pkts, err = rtpEnc.Encode(buf.Bytes())
 		if err != nil {
 			panic(err)
 		}

examples/server-play-backchannel/audio_streamer.go

@@ -8,6 +8,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
 	"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
+	"github.com/pion/rtp"
 )
 
 func multiplyAndDivide(v, m, d int64) int64 {
@@ -70,7 +71,8 @@ func (r *audioStreamer) run() {
 		}
 
 		// generate RTP packets from G711 samples
-		pkts, err := rtpEnc.Encode(samples)
+		var pkts []*rtp.Packet
+		pkts, err = rtpEnc.Encode(samples)
 		if err != nil {
 			panic(err)
 		}

examples/server-play-format-h264-from-disk/file_streamer.go

@@ -12,6 +12,7 @@ import (
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/format"
 	"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
+	"github.com/pion/rtp"
 )
 
 func randUint32() (uint32, error) {
@@ -77,7 +78,8 @@ func (r *fileStreamer) run() {
 		}
 
 		// find the H264 track inside the file
-		track, err := findTrack(mr)
+		var track *mpegts.Track
+		track, err = findTrack(mr)
 		if err != nil {
 			panic(err)
 		}
@@ -108,7 +110,8 @@ func (r *fileStreamer) run() {
 			log.Printf("writing access unit with pts=%d dts=%d", pts, dts)
 
 			// wrap the access unit into RTP packets
-			packets, err := rtpEnc.Encode(au)
+			var packets []*rtp.Packet
+			packets, err = rtpEnc.Encode(au)
 			if err != nil {
 				return err
 			}
@@ -123,7 +126,7 @@ func (r *fileStreamer) run() {
 
 			// write RTP packets to the server
 			for _, packet := range packets {
-				err := r.stream.WritePacketRTP(r.stream.Desc.Medias[0], packet)
+				err = r.stream.WritePacketRTP(r.stream.Desc.Medias[0], packet)
 				if err != nil {
 					return err
 				}
@@ -134,7 +137,7 @@ func (r *fileStreamer) run() {
 
 		// read the file
 		for {
-			err := mr.Read()
+			err = mr.Read()
 			if err != nil {
 				// file has ended
 				if errors.Is(err, io.EOF) {

pkg/conn/conn.go

@@ -57,7 +57,7 @@ func (c *Conn) Read() (interface{}, error) {
 			return c.ReadRequest()
 		}
 
-		if _, err := c.br.Discard(1); err != nil {
+		if _, err = c.br.Discard(1); err != nil {
 			return nil, err
 		}
 	}

pkg/format/ac3.go

@@ -30,7 +30,7 @@ func (f *AC3) unmarshal(ctx *unmarshalContext) error {
 	f.SampleRate = int(tmp1)
 
 	if len(tmp) >= 2 {
-		tmp1, err := strconv.ParseUint(tmp[1], 10, 31)
+		tmp1, err = strconv.ParseUint(tmp[1], 10, 31)
 		if err != nil || tmp1 == 0 {
 			return fmt.Errorf("invalid channel count: '%s'", tmp[1])
 		}

pkg/format/g711.go

@@ -47,7 +47,7 @@ func (f *G711) unmarshal(ctx *unmarshalContext) error {
 	f.SampleRate = int(tmp1)
 
 	if len(tmp) >= 2 {
-		tmp1, err := strconv.ParseUint(tmp[1], 10, 31)
+		tmp1, err = strconv.ParseUint(tmp[1], 10, 31)
 		if err != nil || tmp1 == 0 {
 			return fmt.Errorf("invalid channel count: '%s'", tmp[1])
 		}

pkg/format/h264.go

@@ -172,7 +172,7 @@ func (f *H264) PTSEqualsDTS(pkt *rtp.Packet) bool {
 			return false
 		}
 
-		typ := h264.NALUType(pkt.Payload[1] & 0x1F)
+		typ = h264.NALUType(pkt.Payload[1] & 0x1F)
 		switch typ {
 		case h264.NALUTypeIDR, h264.NALUTypeSPS, h264.NALUTypePPS:
 			return true

pkg/format/h265.go

@@ -183,7 +183,7 @@ func (f *H265) PTSEqualsDTS(pkt *rtp.Packet) bool {
 			return false
 		}
 
-		typ := h265.NALUType(pkt.Payload[2] & 0b111111)
+		typ = h265.NALUType(pkt.Payload[2] & 0b111111)
 		switch typ {
 		case h265.NALUType_IDR_W_RADL, h265.NALUType_IDR_N_LP, h265.NALUType_CRA_NUT,
 			h265.NALUType_VPS_NUT, h265.NALUType_SPS_NUT, h265.NALUType_PPS_NUT:

pkg/format/lpcm.go

@@ -57,7 +57,7 @@ func (f *LPCM) unmarshal(ctx *unmarshalContext) error {
 	f.SampleRate = int(tmp1)
 
 	if len(tmp) >= 2 {
-		tmp1, err := strconv.ParseUint(tmp[1], 10, 31)
+		tmp1, err = strconv.ParseUint(tmp[1], 10, 31)
 		if err != nil || tmp1 == 0 {
 			return fmt.Errorf("invalid channel count: '%s'", tmp[1])
 		}

pkg/format/rtpac3/decoder_test.go

@@ -20,7 +20,8 @@ func TestDecode(t *testing.T) {
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addFrames, err := d.Decode(pkt)
+				var addFrames [][]byte
+				addFrames, err = d.Decode(pkt)
 
 				// test input integrity
 				require.Equal(t, clone, pkt)

pkg/format/rtpav1/decoder_test.go

@@ -20,7 +20,8 @@ func TestDecode(t *testing.T) {
 			var obus [][]byte
 
 			for _, pkt := range ca.pkts {
-				addOBUs, err := d.Decode(pkt)
+				var addOBUs [][]byte
+				addOBUs, err = d.Decode(pkt)
 				if errors.Is(err, ErrMorePacketsNeeded) {
 					continue
 				}

pkg/format/rtph264/decoder_test.go

@@ -22,7 +22,8 @@ func TestDecode(t *testing.T) {
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addNALUs, err := d.Decode(pkt)
+				var addNALUs [][]byte
+				addNALUs, err = d.Decode(pkt)
 
 				// test input integrity
 				require.Equal(t, clone, pkt)
@@ -164,7 +165,7 @@ func TestDecodeAnnexB(t *testing.T) {
 	}, nalus)
 
 	for i := 0; i < 2; i++ {
-		nalus, err := d.Decode(&rtp.Packet{
+		nalus, err = d.Decode(&rtp.Packet{
 			Header: rtp.Header{
 				Version:        2,
 				Marker:         true,

pkg/format/rtph265/decoder_test.go

@@ -22,7 +22,8 @@ func TestDecode(t *testing.T) {
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addNALUs, err := d.Decode(pkt)
+				var addNALUs [][]byte
+				addNALUs, err = d.Decode(pkt)
 
 				// test input integrity
 				require.Equal(t, clone, pkt)

pkg/format/rtpklv/decoder_test.go

@@ -20,7 +20,8 @@ func TestDecode(t *testing.T) {
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addUnits, err := d.Decode(pkt)
+				var addUnits []byte
+				addUnits, err = d.Decode(pkt)
 
 				// test input integrity
 				require.Equal(t, clone, pkt)

pkg/format/rtplpcm/decoder_test.go

@@ -20,7 +20,8 @@ func TestDecode(t *testing.T) {
 			var samples []byte
 
 			for _, pkt := range ca.pkts {
-				partial, err := d.Decode(pkt)
+				var partial []byte
+				partial, err = d.Decode(pkt)
 				require.NoError(t, err)
 				samples = append(samples, partial...)
 			}

pkg/format/rtpmjpeg/decoder.go

@@ -204,7 +204,7 @@ func (d *Decoder) Decode(pkt *rtp.Packet) ([]byte, error) {
 
 		if jh.Quantization >= 128 {
 			var hqt headerQuantizationTable
-			n, err := hqt.unmarshal(byts)
+			n, err = hqt.unmarshal(byts)
 			if err != nil {
 				return nil, err
 			}

pkg/format/rtpmjpeg/decoder_test.go

@@ -16,7 +16,8 @@ func TestDecode(t *testing.T) {
 			require.NoError(t, err)
 
 			for _, pkt := range ca.pkts {
-				image, err := d.Decode(pkt)
+				var image []byte
+				image, err = d.Decode(pkt)
 				if errors.Is(err, ErrMorePacketsNeeded) {
 					continue
 				}

pkg/format/rtpmpeg1audio/encoder.go

@@ -100,7 +100,7 @@ func (e *Encoder) Encode(frames [][]byte) ([]*rtp.Packet, error) {
 
 				for _, frame := range batch {
 					var h mpeg1audio.FrameHeader
-					err := h.Unmarshal(frame)
+					err = h.Unmarshal(frame)
 					if err != nil {
 						return nil, err
 					}

pkg/format/rtpmpeg4audio/decoder.go

@@ -178,7 +178,8 @@ func (d *Decoder) readAUHeaders(buf []byte, headersLen int) ([]uint64, error) {
 		if !firstRead {
 			firstRead = true
 			if d.IndexLength > 0 {
-				auIndex, err := bits.ReadBits(buf, &pos, d.IndexLength)
+				var auIndex uint64
+				auIndex, err = bits.ReadBits(buf, &pos, d.IndexLength)
 				if err != nil {
 					return nil, err
 				}
@@ -189,7 +190,8 @@ func (d *Decoder) readAUHeaders(buf []byte, headersLen int) ([]uint64, error) {
 				}
 			}
 		} else if d.IndexDeltaLength > 0 {
-			auIndexDelta, err := bits.ReadBits(buf, &pos, d.IndexDeltaLength)
+			var auIndexDelta uint64
+			auIndexDelta, err = bits.ReadBits(buf, &pos, d.IndexDeltaLength)
 			if err != nil {
 				return nil, err
 			}

pkg/format/rtpmpeg4audio/decoder_test.go

@@ -25,7 +25,8 @@ func TestDecodeGeneric(t *testing.T) {
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addAUs, err := d.Decode(pkt)
+				var addAUs [][]byte
+				addAUs, err = d.Decode(pkt)
 
 				// test input integrity
 				require.Equal(t, clone, pkt)
@@ -53,7 +54,8 @@ func TestDecodeGenericADTS(t *testing.T) {
 	require.NoError(t, err)
 
 	for i := 0; i < 2; i++ {
-		aus, err := d.Decode(&rtp.Packet{
+		var aus [][]byte
+		aus, err = d.Decode(&rtp.Packet{
 			Header: rtp.Header{
 				Version:        2,
 				Marker:         true,

pkg/format/vorbis.go

@@ -40,7 +40,8 @@ func (f *Vorbis) unmarshal(ctx *unmarshalContext) error {
 
 	for key, val := range ctx.fmtp {
 		if key == "configuration" {
-			conf, err := base64.StdEncoding.DecodeString(val)
+			var conf []byte
+			conf, err = base64.StdEncoding.DecodeString(val)
 			if err != nil {
 				return fmt.Errorf("invalid config: %v", val)
 			}

pkg/headers/authenticate.go

@@ -141,7 +141,8 @@ func (h *Authenticate) Unmarshal(v base.HeaderValue) error {
 				h.Stale = &v
 
 			case "algorithm":
-				a, err := parseAuthAlgorithm(v)
+				var a AuthAlgorithm
+				a, err = parseAuthAlgorithm(v)
 				if err != nil {
 					return err
 				}

pkg/headers/authorization.go

@@ -133,7 +133,8 @@ func (h *Authorization) Unmarshal(v base.HeaderValue) error {
 				h.Opaque = &v
 
 			case "algorithm":
-				a, err := parseAuthAlgorithm(v)
+				var a AuthAlgorithm
+				a, err = parseAuthAlgorithm(v)
 				if err != nil {
 					return err
 				}

pkg/headers/key_mgmt.go

@@ -45,7 +45,8 @@ func (h *KeyMgmt) Unmarshal(v base.HeaderValue) error {
 			uriProvided = true
 
 		case "data":
-			byts, err := base64.StdEncoding.DecodeString(v)
+			var byts []byte
+			byts, err = base64.StdEncoding.DecodeString(v)
 			if err != nil {
 				return fmt.Errorf("invalid data: %w", err)
 			}

pkg/headers/range.go

@@ -54,7 +54,7 @@ func (t *RangeSMPTETime) unmarshal(s string) error {
 	if len(parts) == 4 {
 		parts = strings.Split(parts[3], ".")
 		if len(parts) == 2 {
-			tmp, err := strconv.ParseUint(parts[0], 10, 64)
+			tmp, err = strconv.ParseUint(parts[0], 10, 64)
 			if err != nil {
 				return err
 			}
@@ -66,7 +66,7 @@ func (t *RangeSMPTETime) unmarshal(s string) error {
 			}
 			t.Subframe = uint(tmp)
 		} else {
-			tmp, err := strconv.ParseUint(parts[0], 10, 64)
+			tmp, err = strconv.ParseUint(parts[0], 10, 64)
 			if err != nil {
 				return err
 			}
@@ -111,7 +111,7 @@ func (r *RangeSMPTE) unmarshal(start string, end string) error {
 
 	if end != "" {
 		var v RangeSMPTETime
-		err := v.unmarshal(end)
+		err = v.unmarshal(end)
 		if err != nil {
 			return err
 		}
@@ -185,7 +185,7 @@ func (r *RangeNPT) unmarshal(start string, end string) error {
 
 	if end != "" {
 		var v time.Duration
-		err := unmarshalRangeNPTTime(&v, end)
+		err = unmarshalRangeNPTTime(&v, end)
 		if err != nil {
 			return err
 		}
@@ -230,7 +230,7 @@ func (r *RangeUTC) unmarshal(start string, end string) error {
 
 	if end != "" {
 		var v time.Time
-		err := unmarshalRangeUTCTime(&v, end)
+		err = unmarshalRangeUTCTime(&v, end)
 		if err != nil {
 			return err
 		}
@@ -296,7 +296,7 @@ func (h *Range) Unmarshal(v base.HeaderValue) error {
 		switch k {
 		case "smpte":
 			s := &RangeSMPTE{}
-			err := rangeValueUnmarshal(s, v)
+			err = rangeValueUnmarshal(s, v)
 			if err != nil {
 				return err
 			}
@@ -306,7 +306,7 @@ func (h *Range) Unmarshal(v base.HeaderValue) error {
 
 		case "npt":
 			s := &RangeNPT{}
-			err := rangeValueUnmarshal(s, v)
+			err = rangeValueUnmarshal(s, v)
 			if err != nil {
 				return err
 			}
@@ -316,7 +316,7 @@ func (h *Range) Unmarshal(v base.HeaderValue) error {
 
 		case "clock":
 			s := &RangeUTC{}
-			err := rangeValueUnmarshal(s, v)
+			err = rangeValueUnmarshal(s, v)
 			if err != nil {
 				return err
 			}
@@ -326,7 +326,7 @@ func (h *Range) Unmarshal(v base.HeaderValue) error {
 
 		case "time":
 			var t time.Time
-			err := unmarshalRangeUTCTime(&t, v)
+			err = unmarshalRangeUTCTime(&t, v)
 			if err != nil {
 				return err
 			}

pkg/headers/rtp_info.go

@@ -48,7 +48,8 @@ func (h *RTPInfo) Unmarshal(v base.HeaderValue) error {
 				urlReceived = true
 
 			case "seq":
-				vi, err := strconv.ParseUint(v, 10, 16)
+				var vi uint64
+				vi, err = strconv.ParseUint(v, 10, 16)
 				if err != nil {
 					return err
 				}
@@ -56,7 +57,8 @@ func (h *RTPInfo) Unmarshal(v base.HeaderValue) error {
 				e.SequenceNumber = &vi2
 
 			case "rtptime":
-				vi, err := strconv.ParseUint(v, 10, 32)
+				var vi uint64
+				vi, err = strconv.ParseUint(v, 10, 32)
 				if err != nil {
 					return err
 				}

pkg/headers/session.go

@@ -47,7 +47,8 @@ func (h *Session) Unmarshal(v base.HeaderValue) error {
 
 	for k, v := range kvs {
 		if k == "timeout" {
-			iv, err := strconv.ParseUint(v, 10, 32)
+			var iv uint64
+			iv, err = strconv.ParseUint(v, 10, 32)
 			if err != nil {
 				return err
 			}

pkg/mikey/message.go

@@ -32,7 +32,8 @@ func (m *Message) Unmarshal(buf []byte) error {
 			return fmt.Errorf("unsupported payload type: %d", nextPayloadType)
 		}
 
-		payloadLen, err := payload.unmarshal(buf[n:])
+		var payloadLen int
+		payloadLen, err = payload.unmarshal(buf[n:])
 		if err != nil {
 			return fmt.Errorf("unable to parse payload %d: %w", nextPayloadType, err)
 		}
@@ -80,7 +81,8 @@ func (m *Message) Marshal() ([]byte, error) {
 
 		buf[n] = byte(nextPayloadType)
 
-		n2, err := pl.marshalTo(buf[n:])
+		var n2 int
+		n2, err = pl.marshalTo(buf[n:])
 		if err != nil {
 			return nil, err
 		}

pkg/multicast/multi_conn_lin.go

@@ -92,7 +92,8 @@ func NewMultiConn(
 		writeSocks := make([]int, len(enabledInterfaces))
 
 		for i, intf := range enabledInterfaces {
-			writeSock, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
+			var writeSock int
+			writeSock, err = syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
 			if err != nil {
 				for j := 0; j < i; j++ {
 					syscall.Close(writeSocks[j]) //nolint:errcheck
@@ -111,7 +112,6 @@ func NewMultiConn(
 				return nil, err
 			}
 
-			var lsa syscall.SockaddrInet4
 			lsa.Port = addr.Port
 			copy(lsa.Addr[:], addr.IP.To4())
 			err = syscall.Bind(writeSock, &lsa)

pkg/multicast/multicast.go

@@ -28,10 +28,12 @@ func InterfaceForSource(ip net.IP) (*net.Interface, error) {
 			continue
 		}
 
-		addrs, err := intf.Addrs()
+		var addrs []net.Addr
+		addrs, err = intf.Addrs()
 		if err == nil {
 			for _, addr := range addrs {
-				_, ipnet, err := net.ParseCIDR(addr.String())
+				var ipnet *net.IPNet
+				_, ipnet, err = net.ParseCIDR(addr.String())
 				if err == nil && ipnet.Contains(ip) {
 					return &intf, nil
 				}

pkg/ringbuffer/ringbuffer_test.go

@@ -87,7 +87,8 @@ func TestOverflow(t *testing.T) {
 	require.Equal(t, false, ok)
 
 	for i := 0; i < 32; i++ {
-		data, ok := r.Pull()
+		var data interface{}
+		data, ok = r.Pull()
 		require.Equal(t, true, ok)
 		require.Equal(t, []byte{1, 2, 3, 4}, data)
 	}

pkg/sdp/sdp.go

@@ -146,7 +146,7 @@ func (s *SessionDescription) unmarshalOrigin(value string) error {
 	case strings.ContainsAny(tmp, "abcdefABCDEF"):
 		s.Origin.SessionID, err = strconv.ParseUint(tmp, 16, 64)
 	default:
-		if i := strings.Index(tmp, "."); i >= 0 {
+		if i = strings.Index(tmp, "."); i >= 0 {
 			tmp = tmp[:i]
 		}
 		tmp = strings.TrimPrefix(tmp, "-")
@@ -412,7 +412,8 @@ func (s *SessionDescription) unmarshalRepeatTimes(value string) error {
 	}
 
 	for i := 2; i < len(fields); i++ {
-		offset, err := parseTimeUnits(fields[i])
+		var offset int64
+		offset, err = parseTimeUnits(fields[i])
 		if err != nil {
 			return fmt.Errorf("%w `%v`", errSDPInvalidValue, fields)
 		}
@@ -453,7 +454,8 @@ func (s *SessionDescription) unmarshalMediaDescription(value string) error {
 	}
 
 	if len(parts) > 1 {
-		portRange, err := strconv.Atoi(parts[1])
+		var portRange int
+		portRange, err = strconv.Atoi(parts[1])
 		if err != nil {
 			return fmt.Errorf("%w `%v`", errSDPInvalidValue, parts)
 		}

server.go

@@ -415,7 +415,7 @@ func (s *Server) runInner() error {
 					continue
 				}
 
-				ss := &ServerSession{
+				ss = &ServerSession{
 					s:      s,
 					author: req.sc,
 				}

server_conn_reader.go

@@ -85,7 +85,7 @@ func (cr *serverConnReader) readFuncStandard() error {
 			req := readReq{req: what, res: cres}
 			cr.chRequest <- req
 
-			err := <-cres
+			err = <-cres
 			if err != nil {
 				return err
 			}
@@ -121,7 +121,7 @@ func (cr *serverConnReader) readFuncTCP() error {
 			req := readReq{req: what, res: cres}
 			cr.chRequest <- req
 
-			err := <-cres
+			err = <-cres
 			if err != nil {
 				return err
 			}

server_play_test.go

@@ -40,7 +40,8 @@ func multicastCapableIP(t *testing.T) string {
 
 	for _, intf := range intfs {
 		if (intf.Flags & net.FlagMulticast) != 0 {
-			addrs, err := intf.Addrs()
+			var addrs []net.Addr
+			addrs, err = intf.Addrs()
 			if err != nil {
 				continue
 			}
@@ -541,7 +542,8 @@ func TestServerPlaySetupErrorSameUDPPortsAndIP(t *testing.T) {
 	defer stream.Close()
 
 	for i := 0; i < 2; i++ {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
@@ -555,7 +557,8 @@ func TestServerPlaySetupErrorSameUDPPortsAndIP(t *testing.T) {
 
 		desc := doDescribe(t, conn, false)
 
-		res, err := writeReqReadRes(conn, base.Request{
+		var res *base.Response
+		res, err = writeReqReadRes(conn, base.Request{
 			Method: base.Setup,
 			URL:    mediaURL(t, desc.BaseURL, desc.Medias[0]),
 			Header: base.Header{
@@ -1150,7 +1153,8 @@ func TestServerPlaySocketError(t *testing.T) {
 			require.NoError(t, err)
 
 			func() {
-				nconn, err := net.Dial("tcp", listenIP+":8554")
+				var nconn net.Conn
+				nconn, err = net.Dial("tcp", listenIP+":8554")
 				require.NoError(t, err)
 				defer nconn.Close()
 
@@ -1356,28 +1360,28 @@ func TestServerPlayDecodeErrors(t *testing.T) {
 
 			switch { //nolint:dupl
 			case ca.proto == "udp" && ca.name == "rtcp invalid":
-				_, err := l2.WriteTo([]byte{0x01, 0x02}, &net.UDPAddr{
+				_, err = l2.WriteTo([]byte{0x01, 0x02}, &net.UDPAddr{
 					IP:   net.ParseIP("127.0.0.1"),
 					Port: resTH.ServerPorts[1],
 				})
 				require.NoError(t, err)
 
 			case ca.proto == "udp" && ca.name == "rtcp too big":
-				_, err := l2.WriteTo(bytes.Repeat([]byte{0x01, 0x02}, 2000/2), &net.UDPAddr{
+				_, err = l2.WriteTo(bytes.Repeat([]byte{0x01, 0x02}, 2000/2), &net.UDPAddr{
 					IP:   net.ParseIP("127.0.0.1"),
 					Port: resTH.ServerPorts[1],
 				})
 				require.NoError(t, err)
 
 			case ca.proto == "tcp" && ca.name == "rtcp invalid":
-				err := conn.WriteInterleavedFrame(&base.InterleavedFrame{
+				err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
 					Channel: 1,
 					Payload: []byte{0x01, 0x02},
 				}, make([]byte, 2048))
 				require.NoError(t, err)
 
 			case ca.proto == "tcp" && ca.name == "rtcp too big":
-				err := conn.WriteInterleavedFrame(&base.InterleavedFrame{
+				err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
 					Channel: 1,
 					Payload: bytes.Repeat([]byte{0x01, 0x02}, 2000/2),
 				}, make([]byte, 2048))
@@ -1621,7 +1625,7 @@ func TestServerPlayTCPResponseBeforeFrames(t *testing.T) {
 					for {
 						select {
 						case <-ti.C:
-							err := stream.WritePacketRTP(stream.Description().Medias[0], &testRTPPacket)
+							err = stream.WritePacketRTP(stream.Description().Medias[0], &testRTPPacket)
 							require.NoError(t, err)
 						case <-writerTerminate:
 							return
@@ -2099,7 +2103,8 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
 	sxID := ""
 
 	func() {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
@@ -2123,12 +2128,14 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
 	}()
 
 	func() {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		res, err := writeReqReadRes(conn, base.Request{
+		var res *base.Response
+		res, err = writeReqReadRes(conn, base.Request{
 			Method: base.GetParameter,
 			URL:    mustParseURL("rtsp://localhost:8554/teststream/"),
 			Header: base.Header{
@@ -2467,10 +2474,11 @@ func TestServerPlayNoInterleavedIDs(t *testing.T) {
 	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 	for i := range 2 {
-		err := stream.WritePacketRTP(stream.Description().Medias[i], &testRTPPacket)
+		err = stream.WritePacketRTP(stream.Description().Medias[i], &testRTPPacket)
 		require.NoError(t, err)
 
-		f, err := conn.ReadInterleavedFrame()
+		var f *base.InterleavedFrame
+		f, err = conn.ReadInterleavedFrame()
 		require.NoError(t, err)
 		require.Equal(t, i*2, f.Channel)
 

server_record_test.go

@@ -646,8 +646,8 @@ func TestServerRecord(t *testing.T) {
 								ctx.Session.AnnouncedDescription().Medias[i],
 								func(pkt rtcp.Packet) {
 									require.Equal(t, &testRTCPPacket, pkt)
-									err := ctx.Session.WritePacketRTCP(ctx.Session.AnnouncedDescription().Medias[ci], &testRTCPPacket)
+									err2 := ctx.Session.WritePacketRTCP(ctx.Session.AnnouncedDescription().Medias[ci], &testRTCPPacket)
-									require.NoError(t, err)
+									require.NoError(t, err2)
 								})
 						}
 
@@ -1316,7 +1316,8 @@ func TestServerRecordUDPChangeConn(t *testing.T) {
 	sxID := ""
 
 	func() {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
@@ -1342,12 +1343,14 @@ func TestServerRecordUDPChangeConn(t *testing.T) {
 	}()
 
 	func() {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		res, err := writeReqReadRes(conn, base.Request{
+		var res *base.Response
+		res, err = writeReqReadRes(conn, base.Request{
 			Method: base.GetParameter,
 			URL:    mustParseURL("rtsp://localhost:8554/teststream/"),
 			Header: base.Header{
@@ -1574,7 +1577,7 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 				}))
 
 			case ca.proto == "udp" && ca.name == "rtp too big":
-				_, err := l1.WriteTo(bytes.Repeat([]byte{0x01, 0x02}, 2000/2), &net.UDPAddr{
+				_, err = l1.WriteTo(bytes.Repeat([]byte{0x01, 0x02}, 2000/2), &net.UDPAddr{
 					IP:   net.ParseIP("127.0.0.1"),
 					Port: resTH.ServerPorts[0],
 				})

server_session_format.go

@@ -170,7 +170,7 @@ func (sf *serverSessionFormat) onPacketRTPLost(lost uint64) {
 			Session: sf.sm.ss,
 			Lost:    lost,
 		})
-	} else if h, ok := sf.sm.ss.s.Handler.(ServerHandlerOnPacketLost); ok {
+	} else if h, ok2 := sf.sm.ss.s.Handler.(ServerHandlerOnPacketLost); ok2 {
 		h.OnPacketLost(&ServerHandlerOnPacketLostCtx{
 			Session: sf.sm.ss,
 			Error:   liberrors.ErrServerRTPPacketsLost{Lost: uint(lost)}, //nolint:staticcheck

server_stream_format.go

@@ -121,7 +121,7 @@ func (sf *serverStreamFormat) writePacketRTP(pkt *rtp.Packet, ntp time.Time) err
 			rsf := rsm.formats[pkt.PayloadType]
 
 			if r.setuppedSecure {
-				err := rsf.writePacketRTPEncoded(encr)
+				err = rsf.writePacketRTPEncoded(encr)
 				if err != nil {
 					r.onStreamWriteError(err)
 					continue
@@ -129,7 +129,7 @@ func (sf *serverStreamFormat) writePacketRTP(pkt *rtp.Packet, ntp time.Time) err
 
 				atomic.AddUint64(sf.sm.bytesSent, encrLen)
 			} else {
-				err := rsf.writePacketRTPEncoded(plain)
+				err = rsf.writePacketRTPEncoded(plain)
 				if err != nil {
 					r.onStreamWriteError(err)
 					continue
@@ -145,14 +145,14 @@ func (sf *serverStreamFormat) writePacketRTP(pkt *rtp.Packet, ntp time.Time) err
 	// send multicast
 	if sf.sm.multicastWriter != nil {
 		if sf.sm.srtpOutCtx != nil {
-			err := sf.sm.multicastWriter.writePacketRTP(encr)
+			err = sf.sm.multicastWriter.writePacketRTP(encr)
 			if err != nil {
 				return err
 			}
 
 			atomic.AddUint64(sf.sm.bytesSent, encrLen)
 		} else {
-			err := sf.sm.multicastWriter.writePacketRTP(plain)
+			err = sf.sm.multicastWriter.writePacketRTP(plain)
 			if err != nil {
 				return err
 			}

server_stream_media.go

@@ -111,7 +111,7 @@ func (sm *serverStreamMedia) writePacketRTCP(pkt rtcp.Packet) error {
 	for r := range sm.st.activeUnicastReaders {
 		if sm, ok := r.setuppedMedias[sm.media]; ok {
 			if r.setuppedSecure {
-				err := sm.writePacketRTCPEncoded(encr)
+				err = sm.writePacketRTCPEncoded(encr)
 				if err != nil {
 					r.onStreamWriteError(err)
 					continue
@@ -119,7 +119,7 @@ func (sm *serverStreamMedia) writePacketRTCP(pkt rtcp.Packet) error {
 
 				atomic.AddUint64(sm.bytesSent, encrLen)
 			} else {
-				err := sm.writePacketRTCPEncoded(plain)
+				err = sm.writePacketRTCPEncoded(plain)
 				if err != nil {
 					r.onStreamWriteError(err)
 					continue
@@ -135,14 +135,14 @@ func (sm *serverStreamMedia) writePacketRTCP(pkt rtcp.Packet) error {
 	// send multicast
 	if sm.multicastWriter != nil {
 		if sm.srtpOutCtx != nil {
-			err := sm.multicastWriter.writePacketRTCP(encr)
+			err = sm.multicastWriter.writePacketRTCP(encr)
 			if err != nil {
 				return err
 			}
 
 			atomic.AddUint64(sm.bytesSent, encrLen)
 		} else {
-			err := sm.multicastWriter.writePacketRTCP(plain)
+			err = sm.multicastWriter.writePacketRTCP(plain)
 			if err != nil {
 				return err
 			}