mirror of
https://github.com/aler9/gortsplib
synced 2025-10-05 15:16:51 +08:00
44aaa0977a
Some IP cameras (e.g. CostarHD) have been observed to emit single fragment RTP FU-A packets, with start and end bit both set, for sufficiently small H.264 P-frames. Rather than emit an error, workaround such non-compliant frames.
307 lines
6.6 KiB
Go
307 lines
6.6 KiB
Go
package rtph264
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
|
|
"github.com/pion/rtp"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestDecode(t *testing.T) {
|
|
for _, ca := range cases {
|
|
t.Run(ca.name, func(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
var nalus [][]byte
|
|
|
|
for _, pkt := range ca.pkts {
|
|
clone := pkt.Clone()
|
|
|
|
addNALUs, err := d.Decode(pkt)
|
|
|
|
// test input integrity
|
|
require.Equal(t, clone, pkt)
|
|
|
|
if errors.Is(err, ErrMorePacketsNeeded) {
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
nalus = append(nalus, addNALUs...)
|
|
}
|
|
|
|
require.Equal(t, ca.nalus, nalus)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDecodeCorruptedFragment(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
_, err = d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
Timestamp: 2289527317,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: mergeBytes(
|
|
[]byte{
|
|
0x1c, 0x85,
|
|
},
|
|
bytes.Repeat([]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 182),
|
|
[]byte{0x00, 0x01},
|
|
),
|
|
})
|
|
require.Equal(t, ErrMorePacketsNeeded, err)
|
|
|
|
nalus, err := d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17646,
|
|
Timestamp: 2289527317,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{0x01, 0x00},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{{0x01, 0x00}}, nalus)
|
|
}
|
|
|
|
func TestDecodeNoncompliantFragment(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
nalus, err := d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 18853,
|
|
Timestamp: 1731630255,
|
|
SSRC: 0x466b0000,
|
|
},
|
|
|
|
// FU-A with both start and end bit intentionally set
|
|
// While not compliant with RFC 6184, IP cameras from some vendors
|
|
// (e.g. CostarHD) have been observed to produce such FU-A payloads for
|
|
// sufficiently small P-frames.
|
|
Payload: mergeBytes(
|
|
[]byte{
|
|
0x3c, // FU indicator
|
|
0xc1, // FU header (start and end bit both intentionally set)
|
|
0xe7, 0x00, // DON
|
|
0xca, 0xfe, // Payload
|
|
},
|
|
),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{{0x21, 0xe7, 0x00, 0xca, 0xfe}}, nalus)
|
|
}
|
|
|
|
func TestDecodeSTAPAWithPadding(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
pkt := rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{
|
|
0x18, 0x00, 0x02, 0xaa,
|
|
0xbb, 0x00, 0x02, 0xcc, 0xdd, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
},
|
|
}
|
|
|
|
nalus, err := d.Decode(&pkt)
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{
|
|
{0xaa, 0xbb},
|
|
{0xcc, 0xdd},
|
|
}, nalus)
|
|
}
|
|
|
|
func TestDecodeAnnexB(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
nalus, err := d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17647,
|
|
Timestamp: 2289531307,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: mergeBytes(
|
|
[]byte{0x01, 0x02, 0x03, 0x04},
|
|
),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{
|
|
{0x01, 0x02, 0x03, 0x04},
|
|
}, nalus)
|
|
|
|
for i := 0; i < 2; i++ {
|
|
nalus, err := d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17647,
|
|
Timestamp: 2289531307,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: mergeBytes(
|
|
[]byte{0x00, 0x00, 0x00, 0x01},
|
|
[]byte{0x01, 0x02, 0x03, 0x04},
|
|
[]byte{0x00, 0x00, 0x00, 0x01},
|
|
[]byte{0x01, 0x02, 0x03, 0x04},
|
|
),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{
|
|
{0x01, 0x02, 0x03, 0x04},
|
|
{0x01, 0x02, 0x03, 0x04},
|
|
}, nalus)
|
|
}
|
|
}
|
|
|
|
func TestDecodeAccessUnit(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
nalus, err := d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17647,
|
|
Timestamp: 2289531307,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{0x01, 0x02},
|
|
})
|
|
require.Equal(t, ErrMorePacketsNeeded, err)
|
|
require.Equal(t, [][]byte(nil), nalus)
|
|
|
|
nalus, err = d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: true,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17647,
|
|
Timestamp: 2289531307,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{0x01, 0x02},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, [][]byte{{0x01, 0x02}, {0x01, 0x02}}, nalus)
|
|
}
|
|
|
|
func TestDecoderErrorLimit(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i <= h264.MaxNALUsPerAccessUnit; i++ {
|
|
_, err = d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
Timestamp: 2289527317,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{1, 2, 3, 4},
|
|
})
|
|
}
|
|
|
|
require.EqualError(t, err, "NALU count exceeds maximum allowed (25)")
|
|
}
|
|
|
|
func TestDecodeErrorMissingPacket(t *testing.T) {
|
|
d := &Decoder{}
|
|
err := d.Init()
|
|
require.NoError(t, err)
|
|
|
|
_, err = d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{0x1c, 0x85, 0x01, 0x02},
|
|
})
|
|
require.Equal(t, ErrMorePacketsNeeded, err)
|
|
|
|
_, err = d.Decode(&rtp.Packet{
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17647,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: []byte{0x1c, 0x05, 0x01, 0x02},
|
|
})
|
|
require.EqualError(t, err, "discarding frame since a RTP packet is missing")
|
|
}
|
|
|
|
func FuzzDecoder(f *testing.F) {
|
|
f.Fuzz(func(_ *testing.T, a []byte, b []byte) {
|
|
d := &Decoder{}
|
|
d.Init() //nolint:errcheck
|
|
|
|
d.Decode(&rtp.Packet{ //nolint:errcheck
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
Timestamp: 2289527317,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: a,
|
|
})
|
|
|
|
d.Decode(&rtp.Packet{ //nolint:errcheck
|
|
Header: rtp.Header{
|
|
Version: 2,
|
|
Marker: false,
|
|
PayloadType: 96,
|
|
SequenceNumber: 17645,
|
|
Timestamp: 2289527317,
|
|
SSRC: 0x9dbb7812,
|
|
},
|
|
Payload: b,
|
|
})
|
|
})
|
|
}
|