package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 23:26:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

support fragmented MPEG-2 audio frames (#259)

Browse Source
This commit is contained in:
Alessandro Ros
2023-04-26 00:56:11 +02:00
committed by GitHub
parent 2ac93dadbd
commit 4d594cfe6b
34 changed files with 584 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
pkg/formats/rtph264/decoder_test.go
View File

@@ -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

20
pkg/formats/rtph265/decoder_test.go
View File

@@ -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

23
pkg/formats/rtplpcm/decoder_test.go
View File

@@ -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)

78
pkg/formats/rtpmpeg2audio/decoder.go
View File

@@ -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

23
pkg/formats/rtpmpeg2audio/decoder_test.go
View File

@@ -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,
})
})

74
pkg/formats/rtpmpeg2audio/encoder.go
View File

@@ -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
}

375
pkg/formats/rtpmpeg2audio/encoder_test.go
View File

@@ -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)
})
}
}

1
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/b456f27416f443a7 → pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/2dcc1140d95305bd vendored
View File

@@ -1,2 +1,3 @@
go test fuzz v1
[]byte("\x00\x00\x00\x000")
[]byte("0")

2
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/582528ddfad69eb5 vendored
View File

@@ -1,2 +0,0 @@
go test fuzz v1
[]byte("0")

3
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/5ca224fc27648f98 vendored Normal file
View File

@@ -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")

1
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/d92bed38676468bc → pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/683a55702a751897 vendored
View File

@@ -1,2 +1,3 @@
go test fuzz v1
[]byte("0")
[]byte("\x00\x00000")

3
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/ce0da9a3a282358d vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0")
[]byte("\x00\x00\x00\x00\xff\xfa\x160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\xff\xfa000")

1
pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/f34630c44c11bb13 → pkg/formats/rtpmpeg2audio/testdata/fuzz/FuzzDecoder/dda10e4cae014fda vendored
View File

@@ -1,2 +1,3 @@
go test fuzz v1
[]byte("")
[]byte("00000")

1
pkg/formats/rtpmpeg4audio/decoder.go
View File

@@ -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:]

55
pkg/formats/rtpmpeg4audio/decoder_test.go
View File

@@ -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,
})
})

32
pkg/formats/rtpmpeg4audio/encoder.go
View File

@@ -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++

2
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/82ab2d91fd10f5f409473e000b93d979dcea2547839dece510544e4f2243b80b → pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/12dc1f3e61a87bba vendored
View File

@@ -1,3 +1,5 @@
go test fuzz v1
[]byte("00")
bool(false)
[]byte("")
bool(true)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17b3f3cab1067ee0ee8464bd3f7890cc1a42ed3f47f13ee83ffdc3ddec1879ef vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("\x00\x0100")
bool(false)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/17f38ee4db10b1296a5bdbd03e35ab29e7e86c1008f89d4437529302df6ecb59 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("000001")
bool(false)

5
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/23e26cf358a800e8 vendored Normal file
View File

@@ -0,0 +1,5 @@
go test fuzz v1
[]byte("00")
bool(false)
[]byte("\x00\f00")
bool(true)

2
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/4c3e593e59c1f853f845a7e3c992d1837f63c5052d805c21db6734a64c3ee1e0 → pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/2f6d3f58d465483d vendored
View File

@@ -1,3 +1,5 @@
go test fuzz v1
[]byte("\x00\x00")
bool(false)
[]byte("")
bool(true)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/38d1a2c06720135e2d5accd1afc1f312bc4b6991cd97c1444c86690b4ed6df70 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("\x000000000")
bool(true)

2
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099 → pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/3f92dc5bae9d3239 vendored
View File

@@ -1,3 +1,5 @@
go test fuzz v1
[]byte("0")
bool(false)
[]byte("\x00\f00")
bool(false)

5
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/524481b3acf39020 vendored Normal file
View File

@@ -0,0 +1,5 @@
go test fuzz v1
[]byte("")
bool(false)
[]byte("")
bool(true)

5
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/592eac8c14ce0985 vendored Normal file
View File

@@ -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)

5
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/6b33266efc1ae023 vendored Normal file
View File

@@ -0,0 +1,5 @@
go test fuzz v1
[]byte("\x00000000000")
bool(false)
[]byte("")
bool(true)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/7b9886f07cd0d1b52d80762d475eda9b446e4861160e9a79b294eeb75345ebc5 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("0001")
bool(true)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a253c894d4f7ea0c24ff61014f52a33011acd37d246b6e81527f5544c00140b6 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("\x00\x0100")
bool(true)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/a2d4352b624b7e9e5fefbc9881be89bcf82806ed6644dbb3c0914215e484c015 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("\x00\x10\x80\x00")
bool(false)

5
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/c00c7308cebe5e4a vendored Normal file
View File

@@ -0,0 +1,5 @@
go test fuzz v1
[]byte("\x00\x10\x00\x00")
bool(false)
[]byte("\x00\x1000")
bool(false)

3
pkg/formats/rtpmpeg4audio/testdata/fuzz/FuzzDecoder/fc47c4c80ffd62dfd9c7adf40b38f9d9fe0bf9466af436b5c3487f2c4b9b90e4 vendored
View File

@@ -1,3 +0,0 @@
go test fuzz v1
[]byte("\x000000000")
bool(false)

22
pkg/formats/rtpsimpleaudio/decoder_test.go
View File

@@ -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)
})
}

29
pkg/formats/rtpvp8/decoder_test.go
View File

@@ -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)
})
}

29
pkg/formats/rtpvp9/decoder_test.go
View File

@@ -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)
})
}