diff --git a/pkg/formats/rtph264/decoder_test.go b/pkg/formats/rtph264/decoder_test.go
index 450618d0..e00ca2bf 100644
--- a/pkg/formats/rtph264/decoder_test.go
+++ b/pkg/formats/rtph264/decoder_test.go
@@ -14,35 +14,17 @@ func TestDecode(t *testing.T) {
 			d := &Decoder{}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					PayloadType:    96,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x06, 0x00},
-			}
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var nalus [][]byte
 
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addNALUs, pts, err := d.Decode(pkt)
+				addNALUs, _, err := d.Decode(pkt)
 				if err == ErrMorePacketsNeeded {
 					continue
 				}
 
 				require.NoError(t, err)
-				require.Equal(t, ca.pts, pts)
 				nalus = append(nalus, addNALUs...)
 
 				// test input integrity
diff --git a/pkg/formats/rtph265/decoder_test.go b/pkg/formats/rtph265/decoder_test.go
index 478c9d55..371693b8 100644
--- a/pkg/formats/rtph265/decoder_test.go
+++ b/pkg/formats/rtph265/decoder_test.go
@@ -13,35 +13,17 @@ func TestDecode(t *testing.T) {
 			d := &Decoder{}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					PayloadType:    96,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x06, 0x00},
-			}
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var nalus [][]byte
 
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addNALUs, pts, err := d.Decode(pkt)
+				addNALUs, _, err := d.Decode(pkt)
 				if err == ErrMorePacketsNeeded {
 					continue
 				}
 
 				require.NoError(t, err)
-				require.Equal(t, ca.pts, pts)
 				nalus = append(nalus, addNALUs...)
 
 				// test input integrity
diff --git a/pkg/formats/rtplpcm/decoder_test.go b/pkg/formats/rtplpcm/decoder_test.go
index b932c555..c1f9106f 100644
--- a/pkg/formats/rtplpcm/decoder_test.go
+++ b/pkg/formats/rtplpcm/decoder_test.go
@@ -2,7 +2,6 @@ package rtplpcm
 
 import (
 	"testing"
-	"time"
 
 	"github.com/pion/rtp"
 	"github.com/stretchr/testify/require"
@@ -18,32 +17,12 @@ func TestDecode(t *testing.T) {
 			}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         false,
-					PayloadType:    0,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06},
-			}
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var samples []byte
-			expPTS := ca.pts
 
 			for _, pkt := range ca.pkts {
-				partial, pts, err := d.Decode(pkt)
+				partial, _, err := d.Decode(pkt)
 				require.NoError(t, err)
-				require.Equal(t, expPTS, pts)
 				samples = append(samples, partial...)
-				expPTS += time.Duration(len(partial)/(24*2/8)) * time.Second / 48000
 			}
 
 			require.Equal(t, ca.samples, samples)
diff --git a/pkg/formats/rtpmpeg2audio/decoder.go b/pkg/formats/rtpmpeg2audio/decoder.go
index d3da4de6..121dfb31 100644
--- a/pkg/formats/rtpmpeg2audio/decoder.go
+++ b/pkg/formats/rtpmpeg2audio/decoder.go
@@ -1,6 +1,7 @@
 package rtpmpeg2audio
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
@@ -10,10 +11,16 @@ import (
 	"github.com/bluenviron/gortsplib/v3/pkg/rtptime"
 )
 
+// ErrMorePacketsNeeded is returned when more packets are needed.
+var ErrMorePacketsNeeded = errors.New("need more packets")
+
 // Decoder is a RTP/MPEG2-audio decoder.
 // Specification: https://datatracker.ietf.org/doc/html/rfc2250
 type Decoder struct {
-	timeDecoder *rtptime.Decoder
+	timeDecoder       *rtptime.Decoder
+	fragments         [][]byte
+	fragmentedSize    int
+	fragmentsExpected int
 }
 
 // Init initializes the decoder.
@@ -33,13 +40,70 @@ func (d *Decoder) Decode(pkt *rtp.Packet) ([][]byte, time.Duration, error) {
 	}
 
 	offset := uint16(pkt.Payload[2])<<8 | uint16(pkt.Payload[3])
-	if offset != 0 {
-		return nil, 0, fmt.Errorf("fragmented units are not supported")
-	}
 
-	frames, err := mpeg2audio.SplitFrames(pkt.Payload[4:])
-	if err != nil {
-		return nil, 0, err
+	var frames [][]byte
+
+	if len(d.fragments) == 0 {
+		if offset != 0 {
+			return nil, 0, fmt.Errorf("invalid offset")
+		}
+
+		buf := pkt.Payload[4:]
+		for {
+			var h mpeg2audio.FrameHeader
+			err := h.Unmarshal(buf)
+			if err != nil {
+				return nil, 0, err
+			}
+
+			fl := h.FrameLen()
+			bl := len(buf)
+			if bl >= fl {
+				frames = append(frames, buf[:fl])
+				buf = buf[fl:]
+				if len(buf) == 0 {
+					break
+				}
+			} else {
+				if len(frames) != 0 {
+					return nil, 0, fmt.Errorf("invalid packet")
+				}
+
+				d.fragments = append(d.fragments, buf)
+				d.fragmentedSize = bl
+				d.fragmentsExpected = fl - bl
+				return nil, 0, ErrMorePacketsNeeded
+			}
+		}
+	} else {
+		if int(offset) != d.fragmentedSize {
+			d.fragments = d.fragments[:0] // discard pending fragmented packets
+			return nil, 0, fmt.Errorf("unexpected offset %v, expected %v", offset, d.fragmentedSize)
+		}
+
+		bl := len(pkt.Payload[4:])
+		d.fragmentedSize += bl
+		d.fragmentsExpected -= bl
+
+		if d.fragmentsExpected < 0 {
+			d.fragments = d.fragments[:0] // discard pending fragmented packets
+			return nil, 0, fmt.Errorf("fragment is too big")
+		}
+
+		d.fragments = append(d.fragments, pkt.Payload[4:])
+
+		if d.fragmentsExpected > 0 {
+			return nil, 0, ErrMorePacketsNeeded
+		}
+
+		ret := make([]byte, d.fragmentedSize)
+		n := 0
+		for _, p := range d.fragments {
+			n += copy(ret[n:], p)
+		}
+		frames = [][]byte{ret}
+
+		d.fragments = d.fragments[:0]
 	}
 
 	return frames, d.timeDecoder.Decode(pkt.Timestamp), nil
diff --git a/pkg/formats/rtpmpeg2audio/decoder_test.go b/pkg/formats/rtpmpeg2audio/decoder_test.go
index 7047da25..359b15c9 100644
--- a/pkg/formats/rtpmpeg2audio/decoder_test.go
+++ b/pkg/formats/rtpmpeg2audio/decoder_test.go
@@ -13,7 +13,13 @@ func TestDecode(t *testing.T) {
 			d := &Decoder{}
 			d.Init()
 
-			frames, _, err := d.Decode(ca.pkt)
+			var frames [][]byte
+			var err error
+
+			for _, pkt := range ca.pkts {
+				frames, _, err = d.Decode(pkt)
+			}
+
 			require.NoError(t, err)
 			require.Equal(t, ca.frames, frames)
 		})
@@ -24,15 +30,26 @@ func FuzzDecoder(f *testing.F) {
 	d := &Decoder{}
 	d.Init()
 
-	f.Fuzz(func(t *testing.T, b []byte) {
+	f.Fuzz(func(t *testing.T, a []byte, b []byte) {
 		d.Decode(&rtp.Packet{
 			Header: rtp.Header{
 				Version:        2,
-				PayloadType:    96,
+				PayloadType:    14,
 				SequenceNumber: 17645,
 				Timestamp:      2289527317,
 				SSRC:           0x9dbb7812,
 			},
+			Payload: a,
+		})
+
+		d.Decode(&rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				PayloadType:    14,
+				SequenceNumber: 17646,
+				Timestamp:      2289527317,
+				SSRC:           0x9dbb7812,
+			},
 			Payload: b,
 		})
 	})
diff --git a/pkg/formats/rtpmpeg2audio/encoder.go b/pkg/formats/rtpmpeg2audio/encoder.go
index 9cdf3ca5..41454a28 100644
--- a/pkg/formats/rtpmpeg2audio/encoder.go
+++ b/pkg/formats/rtpmpeg2audio/encoder.go
@@ -2,7 +2,6 @@ package rtpmpeg2audio
 
 import (
 	"crypto/rand"
-	"fmt"
 	"time"
 
 	"github.com/bluenviron/mediacommon/pkg/codecs/mpeg2audio"
@@ -80,20 +79,16 @@ func (e *Encoder) Encode(frames [][]byte, pts time.Duration) ([]*rtp.Packet, err
 	var batch [][]byte
 
 	for _, frame := range frames {
-		if len(frame) > e.PayloadMaxSize {
-			return nil, fmt.Errorf("frame is too big")
-		}
-
 		if lenAggregated(batch, frame) <= e.PayloadMaxSize {
 			batch = append(batch, frame)
 		} else {
 			// write last batch
 			if batch != nil {
-				pkt, err := e.writeBatch(batch, pts)
+				pkts, err := e.writeBatch(batch, pts)
 				if err != nil {
 					return nil, err
 				}
-				rets = append(rets, pkt)
+				rets = append(rets, pkts...)
 
 				for _, frame := range batch {
 					var h mpeg2audio.FrameHeader
@@ -112,22 +107,71 @@ func (e *Encoder) Encode(frames [][]byte, pts time.Duration) ([]*rtp.Packet, err
 	}
 
 	// write last batch
-	pkt, err := e.writeBatch(batch, pts)
+	pkts, err := e.writeBatch(batch, pts)
 	if err != nil {
 		return nil, err
 	}
-	rets = append(rets, pkt)
+	rets = append(rets, pkts...)
 
 	return rets, nil
 }
 
-func (e *Encoder) writeBatch(frames [][]byte, pts time.Duration) (*rtp.Packet, error) {
-	l := 4
-	for _, frame := range frames {
-		l += len(frame)
+func (e *Encoder) writeBatch(frames [][]byte, pts time.Duration) ([]*rtp.Packet, error) {
+	if len(frames) != 1 || lenAggregated(frames, nil) < e.PayloadMaxSize {
+		return e.writeAggregated(frames, pts)
 	}
 
-	payload := make([]byte, l)
+	return e.writeFragmented(frames[0], pts)
+}
+
+func (e *Encoder) writeFragmented(frame []byte, pts time.Duration) ([]*rtp.Packet, error) {
+	availPerPacket := e.PayloadMaxSize - 4
+	le := len(frame)
+	packetCount := le / availPerPacket
+	lastPacketSize := le % availPerPacket
+	if lastPacketSize > 0 {
+		packetCount++
+	}
+
+	pos := 0
+	ret := make([]*rtp.Packet, packetCount)
+	encPTS := e.timeEncoder.Encode(pts)
+
+	for i := range ret {
+		var le int
+		if i != (packetCount - 1) {
+			le = availPerPacket
+		} else {
+			le = lastPacketSize
+		}
+
+		payload := make([]byte, 4+le)
+		payload[2] = byte(pos >> 8)
+		payload[3] = byte(pos)
+
+		pos += copy(payload[4:], frame[pos:])
+
+		ret[i] = &rtp.Packet{
+			Header: rtp.Header{
+				Version:        rtpVersion,
+				PayloadType:    14,
+				SequenceNumber: e.sequenceNumber,
+				Timestamp:      encPTS,
+				SSRC:           *e.SSRC,
+				Marker:         true,
+			},
+			Payload: payload,
+		}
+
+		e.sequenceNumber++
+	}
+
+	return ret, nil
+}
+
+func (e *Encoder) writeAggregated(frames [][]byte, pts time.Duration) ([]*rtp.Packet, error) {
+	payload := make([]byte, lenAggregated(frames, nil))
+
 	n := 4
 	for _, frame := range frames {
 		n += copy(payload[n:], frame)
@@ -147,5 +191,5 @@ func (e *Encoder) writeBatch(frames [][]byte, pts time.Duration) (*rtp.Packet, e
 
 	e.sequenceNumber++
 
-	return pkt, nil
+	return []*rtp.Packet{pkt}, nil
 }
diff --git a/pkg/formats/rtpmpeg2audio/encoder_test.go b/pkg/formats/rtpmpeg2audio/encoder_test.go
index 8476d1cf..1fbde0fb 100644
--- a/pkg/formats/rtpmpeg2audio/encoder_test.go
+++ b/pkg/formats/rtpmpeg2audio/encoder_test.go
@@ -10,27 +10,25 @@ import (
 var cases = []struct {
 	name   string
 	frames [][]byte
-	pkt    *rtp.Packet
+	pkts   []*rtp.Packet
 }{
 	{
 		"single",
-		[][]byte{
-			{
-				0xff, 0xfb, 0x14, 0x64, 0x00, 0x0f, 0xf0, 0x00,
-				0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
-				0x0d, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
-				0xa4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34,
-				0x80, 0x00, 0x00, 0x04, 0x4c, 0x41, 0x4d, 0x45,
-				0x33, 0x2e, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55,
-				0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-				0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-				0x55, 0xc0, 0x65, 0xf4, 0xa0, 0x31, 0x8f, 0xce,
-				0x8d, 0x46, 0xfc, 0x8c, 0x73, 0xb9, 0x34, 0x3e,
-				0xb5, 0x03, 0x39, 0xc0, 0x04, 0x01, 0x98, 0x44,
-				0x38, 0xe0, 0x98, 0x10, 0x9b, 0xa8, 0x0f, 0xa8,
-			},
-		},
-		&rtp.Packet{
+		[][]byte{{
+			0xff, 0xfb, 0x14, 0x64, 0x00, 0x0f, 0xf0, 0x00,
+			0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+			0x0d, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
+			0xa4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34,
+			0x80, 0x00, 0x00, 0x04, 0x4c, 0x41, 0x4d, 0x45,
+			0x33, 0x2e, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55,
+			0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+			0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+			0x55, 0xc0, 0x65, 0xf4, 0xa0, 0x31, 0x8f, 0xce,
+			0x8d, 0x46, 0xfc, 0x8c, 0x73, 0xb9, 0x34, 0x3e,
+			0xb5, 0x03, 0x39, 0xc0, 0x04, 0x01, 0x98, 0x44,
+			0x38, 0xe0, 0x98, 0x10, 0x9b, 0xa8, 0x0f, 0xa8,
+		}},
+		[]*rtp.Packet{{
 			Header: rtp.Header{
 				Version:        2,
 				Marker:         true,
@@ -54,7 +52,7 @@ var cases = []struct {
 				0xb5, 0x03, 0x39, 0xc0, 0x04, 0x01, 0x98, 0x44,
 				0x38, 0xe0, 0x98, 0x10, 0x9b, 0xa8, 0x0f, 0xa8,
 			},
-		},
+		}},
 	},
 	{
 		"aggregated",
@@ -88,7 +86,7 @@ var cases = []struct {
 				0xc4, 0x02, 0x72, 0x81, 0x89, 0xc3, 0xe4, 0x0a,
 			},
 		},
-		&rtp.Packet{
+		[]*rtp.Packet{{
 			Header: rtp.Header{
 				Version:        2,
 				Marker:         true,
@@ -124,6 +122,340 @@ var cases = []struct {
 				0x21, 0x27, 0x31, 0x08, 0x47, 0x18, 0x00, 0x06,
 				0xc4, 0x02, 0x72, 0x81, 0x89, 0xc3, 0xe4, 0x0a,
 			},
+		}},
+	},
+	{
+		"fragmented",
+		[][]byte{{
+			0xff, 0xfd, 0xc8, 0x00, 0x33, 0x33, 0x33, 0x66,
+			0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0xb6,
+			0xdb, 0x64, 0x92, 0x49, 0x24, 0x6d, 0xb6, 0xdb,
+			0xfa, 0xaa, 0x55, 0x0a, 0xaa, 0xaa, 0xaa, 0xaa,
+			0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			0xaa, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x77, 0x77,
+			0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xad, 0x8b, 0x62,
+			0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x2d,
+			0x8b, 0x63, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb,
+			0x6d, 0xb6, 0xdb, 0xff, 0xfb, 0xff, 0xfb, 0xff,
+			0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xe7,
+			0xcf, 0x9f, 0x3e, 0x7c, 0xd6, 0xb5, 0xae, 0xee,
+			0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0x77, 0x77, 0x77, 0x77,
+			0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x5b, 0x16,
+			0xc5, 0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c,
+			0x5b, 0x16, 0xc6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d,
+			0xb6, 0xdb, 0x6d, 0xb7, 0xff, 0xf7, 0xff, 0xf7,
+			0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7,
+			0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xad, 0x6b, 0x5d,
+			0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xee, 0xee, 0xee, 0xee,
+			0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xb6,
+			0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x62,
+			0xd8, 0xb6, 0x2d, 0x8d, 0xb6, 0xdb, 0x6d, 0xb6,
+			0xdb, 0x6d, 0xb6, 0xdb, 0x6f, 0xff, 0xef, 0xff,
+			0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff,
+			0xef, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0x5a, 0xd6,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xbb, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xdd, 0xdd, 0xdd,
+			0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16,
+			0xc5, 0xb1, 0x6c, 0x5b, 0x1b, 0x6d, 0xb6, 0xdb,
+			0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdf, 0xff, 0xdf,
+			0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf,
+			0xff, 0xdf, 0x3e, 0x7c, 0xf9, 0xf3, 0xe6, 0xb5,
+			0xad, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+			0x77, 0x77, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbb, 0xbb,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xba, 0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6,
+			0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x36, 0xdb, 0x6d,
+			0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xbf, 0xff,
+			0xbf, 0xff, 0xbf, 0xff, 0xbf, 0xff, 0xbf, 0xff,
+			0xbf, 0xff, 0xbe, 0x7c, 0xf9, 0xf3, 0xe7, 0xcd,
+			0x6b, 0x5a, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+			0xee, 0xee, 0xee, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x77,
+			0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+			0x77, 0x75, 0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+			0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x6d, 0xb6,
+			0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x7f,
+			0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f,
+			0xff, 0x7f, 0xff, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf,
+			0x9a, 0xd6, 0xb5, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			0xdd, 0xdd, 0xdd, 0xdd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+			0xee, 0xee, 0xeb, 0x62, 0xd8, 0xb6, 0x2d, 0x8b,
+			0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xdb,
+			0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6,
+			0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe,
+			0xff, 0xfe, 0xff, 0xfe, 0xf9, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x35, 0xad, 0x6b, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			0xdd, 0xdd, 0xdd, 0xd6, 0xc5, 0xb1, 0x6c, 0x5b,
+			0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+			0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb,
+			0x6d, 0xff, 0xfd, 0xff, 0xfd, 0xff, 0xfd, 0xff,
+			0xfd, 0xff, 0xfd, 0xff, 0xfd, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x6b, 0x5a, 0xd7, 0x77, 0x77, 0x77,
+			0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xad, 0x8b, 0x62, 0xd8,
+			0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8b,
+			0x63, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d,
+			0xb6, 0xdb, 0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb,
+			0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x7c, 0xd6, 0xb5, 0xae, 0xee, 0xee,
+			0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+			0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0x77, 0x77, 0x77, 0x77, 0x77,
+			0x77, 0x77, 0x77, 0x77, 0x77, 0x5b, 0x16, 0xc5,
+			0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b,
+			0x16, 0xc6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6,
+			0xdb, 0x6d, 0xb7, 0xff, 0xf7, 0xff, 0xf7, 0xff,
+			0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xcf,
+			0x9f, 0x3e, 0x7c, 0xf9, 0xad, 0x6b, 0x5d, 0xdd,
+			0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xde,
+			0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xee, 0xee, 0xee, 0xee, 0xee,
+			0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xb6, 0x2d,
+			0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8,
+			0xb6, 0x2d, 0x8d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb,
+			0x6d, 0xb6, 0xdb, 0x6f, 0xff, 0xef, 0xff, 0xef,
+			0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef,
+			0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0x5a, 0xd6, 0xbb,
+			0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xde, 0xf7, 0xbd, 0xef,
+			0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+			0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+			0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			0xdd, 0xdd, 0xdd, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+			0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x1b,
+			0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6,
+			0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff,
+			0xdf, 0xff, 0xdf, 0xff, 0xdf, 0x3e, 0x7c, 0xf9,
+			0xf3, 0xe6, 0xb5, 0xad,
+		}},
+		[]*rtp.Packet{
+			{ //nolint:dupl
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					PayloadType:    14,
+					SequenceNumber: 17645,
+					Timestamp:      2289526357,
+					SSRC:           0x9dbb7812,
+				},
+				Payload: []byte{
+					0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xc8, 0x00,
+					0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66,
+					0x66, 0x66, 0x65, 0xb6, 0xdb, 0x64, 0x92, 0x49,
+					0x24, 0x6d, 0xb6, 0xdb, 0xfa, 0xaa, 0x55, 0x0a,
+					0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+					0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xff, 0xff,
+					0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+					0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+					0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+					0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+					0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+					0xff, 0xf7, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x77, 0x77, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xbb, 0xad, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8b,
+					0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x63, 0x6d, 0xb6,
+					0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0xff,
+					0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xff,
+					0xfb, 0xff, 0xfb, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+					0xd6, 0xb5, 0xae, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xee, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x77, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b,
+					0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16, 0xc6, 0xdb,
+					0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb7,
+					0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7,
+					0xff, 0xf7, 0xff, 0xf7, 0xcf, 0x9f, 0x3e, 0x7c,
+					0xf9, 0xad, 0x6b, 0x5d, 0xdd, 0xdd, 0xdd, 0xdd,
+					0xdd, 0xdd, 0xdd, 0xdd, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xee, 0xb6, 0x2d, 0x8b, 0x62, 0xd8,
+					0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8d,
+					0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb,
+					0x6f, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff,
+					0xef, 0xff, 0xef, 0xff, 0xef, 0x9f, 0x3e, 0x7c,
+					0xf9, 0xf3, 0x5a, 0xd6, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				},
+			},
+			{ //nolint:dupl
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					PayloadType:    14,
+					SequenceNumber: 17646,
+					Timestamp:      2289526357,
+					SSRC:           0x9dbb7812,
+				},
+				Payload: []byte{
+					0x00, 0x00, 0x01, 0x8c, 0xdd, 0xdd, 0xdd, 0xdd,
+					0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16,
+					0xc5, 0xb1, 0x6c, 0x5b, 0x1b, 0x6d, 0xb6, 0xdb,
+					0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdf, 0xff, 0xdf,
+					0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf,
+					0xff, 0xdf, 0x3e, 0x7c, 0xf9, 0xf3, 0xe6, 0xb5,
+					0xad, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x77, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbb, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xba, 0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6,
+					0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x36, 0xdb, 0x6d,
+					0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xbf, 0xff,
+					0xbf, 0xff, 0xbf, 0xff, 0xbf, 0xff, 0xbf, 0xff,
+					0xbf, 0xff, 0xbe, 0x7c, 0xf9, 0xf3, 0xe7, 0xcd,
+					0x6b, 0x5a, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xee, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x77,
+					0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x75, 0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+					0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x6d, 0xb6,
+					0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x7f,
+					0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f,
+					0xff, 0x7f, 0xff, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf,
+					0x9a, 0xd6, 0xb5, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+					0xdd, 0xdd, 0xdd, 0xdd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xeb, 0x62, 0xd8, 0xb6, 0x2d, 0x8b,
+					0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xdb,
+					0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6,
+					0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe,
+					0xff, 0xfe, 0xff, 0xfe, 0xf9, 0xf3, 0xe7, 0xcf,
+					0x9f, 0x35, 0xad, 0x6b, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+					0xdd, 0xdd, 0xdd, 0xd6, 0xc5, 0xb1, 0x6c, 0x5b,
+					0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+					0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb,
+					0x6d, 0xff, 0xfd, 0xff, 0xfd, 0xff, 0xfd, 0xff,
+					0xfd, 0xff, 0xfd, 0xff, 0xfd, 0xf3, 0xe7, 0xcf,
+				},
+			},
+			{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					PayloadType:    14,
+					SequenceNumber: 17647,
+					Timestamp:      2289526357,
+					SSRC:           0x9dbb7812,
+				},
+				Payload: []byte{
+					0x00, 0x00, 0x03, 0x18, 0x9f, 0x3e, 0x6b, 0x5a,
+					0xd7, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x77, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xbb, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xad, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8b, 0x62,
+					0xd8, 0xb6, 0x2d, 0x8b, 0x63, 0x6d, 0xb6, 0xdb,
+					0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0xff, 0xfb,
+					0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb, 0xff, 0xfb,
+					0xff, 0xfb, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xd6,
+					0xb5, 0xae, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0x77,
+					0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+					0x77, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x16,
+					0xc5, 0xb1, 0x6c, 0x5b, 0x16, 0xc6, 0xdb, 0x6d,
+					0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb7, 0xff,
+					0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff,
+					0xf7, 0xff, 0xf7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
+					0xad, 0x6b, 0x5d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+					0xdd, 0xdd, 0xdd, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd,
+					0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xee,
+					0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+					0xee, 0xee, 0xb6, 0x2d, 0x8b, 0x62, 0xd8, 0xb6,
+					0x2d, 0x8b, 0x62, 0xd8, 0xb6, 0x2d, 0x8d, 0xb6,
+					0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6f,
+					0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef,
+					0xff, 0xef, 0xff, 0xef, 0x9f, 0x3e, 0x7c, 0xf9,
+					0xf3, 0x5a, 0xd6, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+					0xbb, 0xbb, 0xbb, 0xbb, 0xbd, 0xef, 0x7b, 0xde,
+					0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef,
+					0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b, 0xde, 0xf7,
+					0xbd, 0xef, 0x7b, 0xde, 0xf7, 0xbd, 0xef, 0x7b,
+					0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+					0xdd, 0xdd, 0xdd, 0x6c, 0x5b, 0x16, 0xc5, 0xb1,
+					0x6c, 0x5b, 0x16, 0xc5, 0xb1, 0x6c, 0x5b, 0x1b,
+					0x6d, 0xb6, 0xdb, 0x6d, 0xb6, 0xdb, 0x6d, 0xb6,
+					0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff,
+					0xdf, 0xff, 0xdf, 0xff, 0xdf, 0x3e, 0x7c, 0xf9,
+					0xf3, 0xe6, 0xb5, 0xad,
+				},
+			},
 		},
 	},
 }
@@ -144,12 +476,13 @@ func TestEncode(t *testing.T) {
 					v := uint32(0x88776655)
 					return &v
 				}(),
+				PayloadMaxSize: 400,
 			}
 			e.Init()
 
 			pkts, err := e.Encode(ca.frames, 0)
 			require.NoError(t, err)
-			require.Equal(t, ca.pkt, pkts[0])
+			require.Equal(t, ca.pkts, pkts)
 		})
 	}
 }
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/b456f27416f443a7 b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/2dcc1140d95305bd
similarity index 78%
rename from pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/b456f27416f443a7
rename to pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/2dcc1140d95305bd
index 831db5dd..ccf6b516 100644
--- a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/b456f27416f443a7
+++ b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/2dcc1140d95305bd
@@ -1,2 +1,3 @@
 go test fuzz v1
 []byte("\x00\x00\x00\x000")
+[]byte("0")
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/582528ddfad69eb5 b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/582528ddfad69eb5
deleted file mode 100644
index a96f5599..00000000
--- a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/582528ddfad69eb5
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-[]byte("0")
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/5ca224fc27648f98 b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/5ca224fc27648f98
new file mode 100644
index 00000000..61b76d08
--- /dev/null
+++ b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/5ca224fc27648f98
@@ -0,0 +1,3 @@
+go test fuzz v1
+[]byte("\x00\x00\x00\x05\xff\xff\x05000000000000000000000000000000000000000\xcf\x1c\xe9b\x01NUI00000000000000000000000000000000000000000000000000000000")
+[]byte("\x00\x00\x00\x05\xff\xff\x0500")
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/d92bed38676468bc b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/683a55702a751897
similarity index 76%
rename from pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/d92bed38676468bc
rename to pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/683a55702a751897
index bb74629d..f3b1b0b4 100644
--- a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/d92bed38676468bc
+++ b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/683a55702a751897
@@ -1,2 +1,3 @@
 go test fuzz v1
+[]byte("0")
 []byte("\x00\x00000")
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/ce0da9a3a282358d b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/ce0da9a3a282358d
new file mode 100644
index 00000000..1b4685a0
--- /dev/null
+++ b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/ce0da9a3a282358d
@@ -0,0 +1,3 @@
+go test fuzz v1
+[]byte("0")
+[]byte("\x00\x00\x00\x00\xff\xfa\x160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\xff\xfa000")
diff --git a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/f34630c44c11bb13 b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/dda10e4cae014fda
similarity index 74%
rename from pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/f34630c44c11bb13
rename to pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/dda10e4cae014fda
index a389d3c6..1697b101 100644
--- a/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/f34630c44c11bb13
+++ b/pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/dda10e4cae014fda
@@ -1,2 +1,3 @@
 go test fuzz v1
+[]byte("")
 []byte("00000")
diff --git a/pkg/formats/rtpmpeg4audio/decoder.go b/pkg/formats/rtpmpeg4audio/decoder.go
index 427c11a6..af069e09 100644
--- a/pkg/formats/rtpmpeg4audio/decoder.go
+++ b/pkg/formats/rtpmpeg4audio/decoder.go
@@ -54,6 +54,7 @@ func (d *Decoder) Decode(pkt *rtp.Packet) ([][]byte, time.Duration, error) {
 	// AU-headers-length (16 bits)
 	headersLen := int(uint16(pkt.Payload[0])<<8 | uint16(pkt.Payload[1]))
 	if headersLen == 0 {
+		d.fragments = d.fragments[:0] // discard pending fragmented packets
 		return nil, 0, fmt.Errorf("invalid AU-headers-length")
 	}
 	payload := pkt.Payload[2:]
diff --git a/pkg/formats/rtpmpeg4audio/decoder_test.go b/pkg/formats/rtpmpeg4audio/decoder_test.go
index 5149605e..8d2209c6 100644
--- a/pkg/formats/rtpmpeg4audio/decoder_test.go
+++ b/pkg/formats/rtpmpeg4audio/decoder_test.go
@@ -2,12 +2,9 @@ package rtpmpeg4audio
 
 import (
 	"testing"
-	"time"
 
 	"github.com/pion/rtp"
 	"github.com/stretchr/testify/require"
-
-	"github.com/bluenviron/mediacommon/pkg/codecs/mpeg4audio"
 )
 
 func TestDecode(t *testing.T) {
@@ -21,52 +18,18 @@ func TestDecode(t *testing.T) {
 			}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					PayloadType:    96,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-			}
-
-			switch {
-			case ca.sizeLength == 13 && ca.indexLength == 3:
-				pkt.Payload = []byte{0x00, 0x10, 0x00, 0x08, 0x0}
-
-			case ca.sizeLength == 13 && ca.indexLength == 0:
-				pkt.Payload = []byte{0x00, 0x0d, 0x00, 0x08, 0x0}
-
-			case ca.sizeLength == 6:
-				pkt.Payload = []byte{0x00, 0x08, 0x04, 0x0}
-
-			case ca.sizeLength == 21:
-				pkt.Payload = []byte{0x00, 0x18, 0x00, 0x0, 0x08, 0x00}
-			}
-
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var aus [][]byte
-			expPTS := ca.pts
 
 			for _, pkt := range ca.pkts {
 				clone := pkt.Clone()
 
-				addAUs, pts, err := d.Decode(pkt)
+				addAUs, _, err := d.Decode(pkt)
 				if err == ErrMorePacketsNeeded {
 					continue
 				}
 
 				require.NoError(t, err)
-				require.Equal(t, expPTS, pts)
 				aus = append(aus, addAUs...)
-				expPTS += time.Duration(len(aus)) * mpeg4audio.SamplesPerAccessUnit * time.Second / 48000
 
 				// test input integrity
 				require.Equal(t, clone, pkt)
@@ -115,16 +78,28 @@ func FuzzDecoder(f *testing.F) {
 	}
 	d.Init()
 
-	f.Fuzz(func(t *testing.T, b []byte, m bool) {
+	f.Fuzz(func(t *testing.T, a []byte, am bool, b []byte, bm bool) {
 		d.Decode(&rtp.Packet{
 			Header: rtp.Header{
 				Version:        2,
-				Marker:         m,
+				Marker:         am,
 				PayloadType:    96,
 				SequenceNumber: 17645,
 				Timestamp:      2289527317,
 				SSRC:           0x9dbb7812,
 			},
+			Payload: a,
+		})
+
+		d.Decode(&rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         bm,
+				PayloadType:    96,
+				SequenceNumber: 17646,
+				Timestamp:      2289527317,
+				SSRC:           0x9dbb7812,
+			},
 			Payload: b,
 		})
 	})
diff --git a/pkg/formats/rtpmpeg4audio/encoder.go b/pkg/formats/rtpmpeg4audio/encoder.go
index a93748f4..366339e4 100644
--- a/pkg/formats/rtpmpeg4audio/encoder.go
+++ b/pkg/formats/rtpmpeg4audio/encoder.go
@@ -118,17 +118,11 @@ func (e *Encoder) Encode(aus [][]byte, pts time.Duration) ([]*rtp.Packet, error)
 }
 
 func (e *Encoder) writeBatch(aus [][]byte, pts time.Duration) ([]*rtp.Packet, error) {
-	if len(aus) == 1 {
-		// the AU fits into a single RTP packet
-		if len(aus[0]) < e.PayloadMaxSize {
-			return e.writeAggregated(aus, pts)
-		}
-
-		// split the AU into multiple fragmentation packet
-		return e.writeFragmented(aus[0], pts)
+	if len(aus) != 1 || e.lenAggregated(aus, nil) < e.PayloadMaxSize {
+		return e.writeAggregated(aus, pts)
 	}
 
-	return e.writeAggregated(aus, pts)
+	return e.writeFragmented(aus[0], pts)
 }
 
 func (e *Encoder) writeFragmented(au []byte, pts time.Duration) ([]*rtp.Packet, error) {
@@ -137,9 +131,11 @@ func (e *Encoder) writeFragmented(au []byte, pts time.Duration) ([]*rtp.Packet,
 	if (auHeadersLen % 8) != 0 {
 		auHeadersLenBytes++
 	}
+
 	auMaxSize := e.PayloadMaxSize - 2 - auHeadersLenBytes
-	packetCount := len(au) / auMaxSize
-	lastPacketSize := len(au) % auMaxSize
+	le := len(au)
+	packetCount := le / auMaxSize
+	lastPacketSize := le % auMaxSize
 	if lastPacketSize > 0 {
 		packetCount++
 	}
@@ -155,19 +151,19 @@ func (e *Encoder) writeFragmented(au []byte, pts time.Duration) ([]*rtp.Packet,
 			le = lastPacketSize
 		}
 
-		byts := make([]byte, 2+auHeadersLenBytes+le)
+		payload := make([]byte, 2+auHeadersLenBytes+le)
 
 		// AU-headers-length
-		byts[0] = byte(auHeadersLen >> 8)
-		byts[1] = byte(auHeadersLen)
+		payload[0] = byte(auHeadersLen >> 8)
+		payload[1] = byte(auHeadersLen)
 
 		// AU-headers
 		pos := 0
-		bits.WriteBits(byts[2:], &pos, uint64(le), e.SizeLength)
-		bits.WriteBits(byts[2:], &pos, 0, e.IndexLength)
+		bits.WriteBits(payload[2:], &pos, uint64(le), e.SizeLength)
+		bits.WriteBits(payload[2:], &pos, 0, e.IndexLength)
 
 		// AU
-		copy(byts[2+auHeadersLenBytes:], au[:le])
+		copy(payload[2+auHeadersLenBytes:], au[:le])
 		au = au[le:]
 
 		ret[i] = &rtp.Packet{
@@ -179,7 +175,7 @@ func (e *Encoder) writeFragmented(au []byte, pts time.Duration) ([]*rtp.Packet,
 				SSRC:           *e.SSRC,
 				Marker:         (i == (packetCount - 1)),
 			},
-			Payload: byts,
+			Payload: payload,
 		}
 
 		e.sequenceNumber++
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/82ab2d91fd10f5f409473e000b93d979dcea2547839dece510544e4f2243b80b b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/12dc1f3e61a87bba
similarity index 63%
rename from pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/82ab2d91fd10f5f409473e000b93d979dcea2547839dece510544e4f2243b80b
rename to pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/12dc1f3e61a87bba
index 0fd3a327..06c1dc08 100644
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/82ab2d91fd10f5f409473e000b93d979dcea2547839dece510544e4f2243b80b
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/12dc1f3e61a87bba
@@ -1,3 +1,5 @@
 go test fuzz v1
 []byte("00")
+bool(false)
+[]byte("")
 bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17b3f3cab1067ee0ee8464bd3f7890cc1a42ed3f47f13ee83ffdc3ddec1879ef b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17b3f3cab1067ee0ee8464bd3f7890cc1a42ed3f47f13ee83ffdc3ddec1879ef
deleted file mode 100644
index 41e904d6..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17b3f3cab1067ee0ee8464bd3f7890cc1a42ed3f47f13ee83ffdc3ddec1879ef
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("\x00\x0100")
-bool(false)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17f38ee4db10b1296a5bdbd03e35ab29e7e86c1008f89d4437529302df6ecb59 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17f38ee4db10b1296a5bdbd03e35ab29e7e86c1008f89d4437529302df6ecb59
deleted file mode 100644
index 1f256e22..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17f38ee4db10b1296a5bdbd03e35ab29e7e86c1008f89d4437529302df6ecb59
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("000001")
-bool(false)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/23e26cf358a800e8 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/23e26cf358a800e8
new file mode 100644
index 00000000..a0907f15
--- /dev/null
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/23e26cf358a800e8
@@ -0,0 +1,5 @@
+go test fuzz v1
+[]byte("00")
+bool(false)
+[]byte("\x00\f00")
+bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/4c3e593e59c1f853f845a7e3c992d1837f63c5052d805c21db6734a64c3ee1e0 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/2f6d3f58d465483d
similarity index 66%
rename from pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/4c3e593e59c1f853f845a7e3c992d1837f63c5052d805c21db6734a64c3ee1e0
rename to pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/2f6d3f58d465483d
index 21407995..d0e26d7a 100644
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/4c3e593e59c1f853f845a7e3c992d1837f63c5052d805c21db6734a64c3ee1e0
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/2f6d3f58d465483d
@@ -1,3 +1,5 @@
 go test fuzz v1
 []byte("\x00\x00")
+bool(false)
+[]byte("")
 bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/38d1a2c06720135e2d5accd1afc1f312bc4b6991cd97c1444c86690b4ed6df70 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/38d1a2c06720135e2d5accd1afc1f312bc4b6991cd97c1444c86690b4ed6df70
deleted file mode 100644
index 1075fee9..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/38d1a2c06720135e2d5accd1afc1f312bc4b6991cd97c1444c86690b4ed6df70
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("\x000000000")
-bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/3f92dc5bae9d3239
similarity index 56%
rename from pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099
rename to pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/3f92dc5bae9d3239
index 53d50f6b..54a3aa3e 100644
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/3f92dc5bae9d3239
@@ -1,3 +1,5 @@
 go test fuzz v1
 []byte("0")
 bool(false)
+[]byte("\x00\f00")
+bool(false)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/524481b3acf39020 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/524481b3acf39020
new file mode 100644
index 00000000..b45dccaa
--- /dev/null
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/524481b3acf39020
@@ -0,0 +1,5 @@
+go test fuzz v1
+[]byte("")
+bool(false)
+[]byte("")
+bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/592eac8c14ce0985 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/592eac8c14ce0985
new file mode 100644
index 00000000..efd27a6e
--- /dev/null
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/592eac8c14ce0985
@@ -0,0 +1,5 @@
+go test fuzz v1
+[]byte("\x000\x00\x00\xd8\xd8\xd8\xc8\xd8\xd801")
+bool(true)
+[]byte("\x00\x01\x00\x00")
+bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/6b33266efc1ae023 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/6b33266efc1ae023
new file mode 100644
index 00000000..b4f0272a
--- /dev/null
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/6b33266efc1ae023
@@ -0,0 +1,5 @@
+go test fuzz v1
+[]byte("\x00000000000")
+bool(false)
+[]byte("")
+bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/7b9886f07cd0d1b52d80762d475eda9b446e4861160e9a79b294eeb75345ebc5 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/7b9886f07cd0d1b52d80762d475eda9b446e4861160e9a79b294eeb75345ebc5
deleted file mode 100644
index 18b04a4b..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/7b9886f07cd0d1b52d80762d475eda9b446e4861160e9a79b294eeb75345ebc5
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("0001")
-bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a253c894d4f7ea0c24ff61014f52a33011acd37d246b6e81527f5544c00140b6 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a253c894d4f7ea0c24ff61014f52a33011acd37d246b6e81527f5544c00140b6
deleted file mode 100644
index ed018f35..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a253c894d4f7ea0c24ff61014f52a33011acd37d246b6e81527f5544c00140b6
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("\x00\x0100")
-bool(true)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a2d4352b624b7e9e5fefbc9881be89bcf82806ed6644dbb3c0914215e484c015 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a2d4352b624b7e9e5fefbc9881be89bcf82806ed6644dbb3c0914215e484c015
deleted file mode 100644
index 287c2699..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a2d4352b624b7e9e5fefbc9881be89bcf82806ed6644dbb3c0914215e484c015
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("\x00\x10\x80\x00")
-bool(false)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/c00c7308cebe5e4a b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/c00c7308cebe5e4a
new file mode 100644
index 00000000..916529c5
--- /dev/null
+++ b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/c00c7308cebe5e4a
@@ -0,0 +1,5 @@
+go test fuzz v1
+[]byte("\x00\x10\x00\x00")
+bool(false)
+[]byte("\x00\x1000")
+bool(false)
diff --git a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/fc47c4c80ffd62dfd9c7adf40b38f9d9fe0bf9466af436b5c3487f2c4b9b90e4 b/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/fc47c4c80ffd62dfd9c7adf40b38f9d9fe0bf9466af436b5c3487f2c4b9b90e4
deleted file mode 100644
index f1cd9e57..00000000
--- a/pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/fc47c4c80ffd62dfd9c7adf40b38f9d9fe0bf9466af436b5c3487f2c4b9b90e4
+++ /dev/null
@@ -1,3 +0,0 @@
-go test fuzz v1
-[]byte("\x000000000")
-bool(false)
diff --git a/pkg/formats/rtpsimpleaudio/decoder_test.go b/pkg/formats/rtpsimpleaudio/decoder_test.go
index 1059e2df..0cb55d0a 100644
--- a/pkg/formats/rtpsimpleaudio/decoder_test.go
+++ b/pkg/formats/rtpsimpleaudio/decoder_test.go
@@ -3,7 +3,6 @@ package rtpsimpleaudio
 import (
 	"testing"
 
-	"github.com/pion/rtp"
 	"github.com/stretchr/testify/require"
 )
 
@@ -15,27 +14,8 @@ func TestDecode(t *testing.T) {
 			}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         false,
-					PayloadType:    0,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x01, 0x02, 0x03, 0x04},
-			}
-			_, _, err := d.Decode(&pkt)
+			frame, _, err := d.Decode(ca.pkt)
 			require.NoError(t, err)
-
-			frame, pts, err := d.Decode(ca.pkt)
-			require.NoError(t, err)
-			require.Equal(t, ca.pts, pts)
-
 			require.Equal(t, ca.frame, frame)
 		})
 	}
diff --git a/pkg/formats/rtpvp8/decoder_test.go b/pkg/formats/rtpvp8/decoder_test.go
index 7de7d368..9bb9dbd8 100644
--- a/pkg/formats/rtpvp8/decoder_test.go
+++ b/pkg/formats/rtpvp8/decoder_test.go
@@ -2,7 +2,6 @@ package rtpvp8
 
 import (
 	"testing"
-	"time"
 
 	"github.com/pion/rtp"
 	"github.com/stretchr/testify/require"
@@ -14,36 +13,14 @@ func TestDecode(t *testing.T) {
 			d := &Decoder{}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					PayloadType:    96,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x10, 0x01, 0x02, 0x03, 0x04},
-			}
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var frame []byte
+			var err error
 
 			for _, pkt := range ca.pkts {
-				var pts time.Duration
-				frame, pts, err = d.Decode(pkt)
-				if err == ErrMorePacketsNeeded {
-					continue
-				}
-
-				require.NoError(t, err)
-				require.Equal(t, ca.pts, pts)
+				frame, _, err = d.Decode(pkt)
 			}
 
+			require.NoError(t, err)
 			require.Equal(t, ca.frame, frame)
 		})
 	}
diff --git a/pkg/formats/rtpvp9/decoder_test.go b/pkg/formats/rtpvp9/decoder_test.go
index 10ee5c91..53414bcf 100644
--- a/pkg/formats/rtpvp9/decoder_test.go
+++ b/pkg/formats/rtpvp9/decoder_test.go
@@ -2,7 +2,6 @@ package rtpvp9
 
 import (
 	"testing"
-	"time"
 
 	"github.com/pion/rtp"
 	"github.com/stretchr/testify/require"
@@ -14,36 +13,14 @@ func TestDecode(t *testing.T) {
 			d := &Decoder{}
 			d.Init()
 
-			// send an initial packet downstream
-			// in order to compute the right timestamp,
-			// that is relative to the initial packet
-			pkt := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					PayloadType:    96,
-					SequenceNumber: 17645,
-					Timestamp:      2289526357,
-					SSRC:           0x9dbb7812,
-				},
-				Payload: []byte{0x9c, 0xb5, 0xaf, 0x01, 0x02, 0x03, 0x04},
-			}
-			_, _, err := d.Decode(&pkt)
-			require.NoError(t, err)
-
 			var frame []byte
+			var err error
 
 			for _, pkt := range ca.pkts {
-				var pts time.Duration
-				frame, pts, err = d.Decode(pkt)
-				if err == ErrMorePacketsNeeded {
-					continue
-				}
-
-				require.NoError(t, err)
-				require.Equal(t, ca.pts, pts)
+				frame, _, err = d.Decode(pkt)
 			}
 
+			require.NoError(t, err)
 			require.Equal(t, ca.frame, frame)
 		})
 	}