qiurui
/
uvgrtp-base
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: Replicate a frame size bug in formats with tests

This commit is contained in:
Joni Räsänen 2022-03-25 10:31:48 +02:00
parent c289d357f8
commit ec53c76d4a
4 changed files with 128 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
test/test_2_rtp.cpp
View File

@ -5,10 +5,10 @@
// 4) test sending and receiving within same test while checking frame size
// parameters for this test. You can change these to suit your network environment
constexpr uint16_t LOCAL_PORT = 9300;
constexpr uint16_t SEND_PORT = 9300;
constexpr char REMOTE_ADDRESS[] = "127.0.0.1";
constexpr uint16_t REMOTE_PORT = 9302;
constexpr uint16_t RECEIVE_PORT = 9302;
void rtp_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame);
void process_rtp_frame(uvgrtp::frame::rtp_frame* frame);
@ -33,6 +33,30 @@ void test_wait(int time_ms, uvgrtp::media_stream* receiver)
}
}
TEST(RTPTests, rtp_hook)
{
// Tests installing a hook to uvgRTP
std::cout << "Starting RTP hook test" << std::endl;
uvgrtp::context ctx;
uvgrtp::session* sess = ctx.create_session(REMOTE_ADDRESS);
uvgrtp::media_stream* sender = nullptr;
uvgrtp::media_stream* receiver = nullptr;
int flags = RCE_FRAGMENT_GENERIC;
if (sess)
{
sender = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_GENERIC, flags);
receiver = sess->create_stream(SEND_PORT, RECEIVE_PORT, RTP_FORMAT_GENERIC, flags);
}
test_packet_size(1000, sess, sender, receiver);
test_packet_size(2000, sess, sender, receiver);
cleanup_ms(sess, receiver);
cleanup_sess(ctx, sess);
}
TEST(RTPTests, rtp_send_test)
{
// Tests installing a hook to uvgRTP
@ -41,54 +65,22 @@ TEST(RTPTests, rtp_send_test)
uvgrtp::session* sess = ctx.create_session(REMOTE_ADDRESS);
uvgrtp::media_stream* sender = nullptr;
uvgrtp::media_stream* receiver = nullptr;
int flags = RTP_NO_FLAGS;
int flags = RCE_FRAGMENT_GENERIC;
if (sess)
{
sender = sess->create_stream(LOCAL_PORT, REMOTE_PORT, RTP_FORMAT_H265, flags);
sender = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_GENERIC, flags);
receiver = sess->create_stream(SEND_PORT, RECEIVE_PORT, RTP_FORMAT_GENERIC, flags);
}
send_packets(sess, sender, 10, 1000, 33, true, false);
send_packets(sess, sender, 10, 1458, 33, true, false);
send_packets(sess, sender, 10, 1459, 33, true, false);
send_packets(sess, sender, 10, 1501, 33, true, false);
send_packets(sess, sender, 10, 15000, 33, true, false);
send_packets(sess, sender, 10, 150000, 33, true, false);
test_packet_size(1500, sess, sender, receiver);
cleanup_ms(sess, sender);
cleanup_sess(ctx, sess);
}
TEST(RTPTests, rtp_hook)
{
// Tests installing a hook to uvgRTP
std::cout << "Starting RTP hook test" << std::endl;
uvgrtp::context ctx;
uvgrtp::session* sess = ctx.create_session(REMOTE_ADDRESS);
uvgrtp::media_stream* receiver = nullptr;
uvgrtp::media_stream* sender = nullptr;
int flags = RTP_NO_FLAGS;
if (sess)
{
sender = sess->create_stream(REMOTE_PORT, LOCAL_PORT, RTP_FORMAT_H265, flags);
receiver = sess->create_stream(LOCAL_PORT, REMOTE_PORT, RTP_FORMAT_H265, flags);
}
int packets = 10;
Test_receiver* tester = new Test_receiver(packets);
add_hook(tester, receiver, rtp_receive_hook);
send_packets(sess, sender, packets, 1000, 33, true, false);
tester->gotAll();
delete tester;
cleanup_ms(sess, receiver);
cleanup_sess(ctx, sess);
}
TEST(RTPTests, rtp_poll)
{
@ -99,13 +91,13 @@ TEST(RTPTests, rtp_poll)
uvgrtp::media_stream* sender = nullptr;
uvgrtp::media_stream* receiver = nullptr;
int flags = RCE_NO_FLAGS;
int flags = RCE_FRAGMENT_GENERIC;
EXPECT_NE(nullptr, sess);
if (sess)
{
sender = sess->create_stream(LOCAL_PORT, REMOTE_PORT, RTP_FORMAT_H265, flags);
receiver = sess->create_stream(REMOTE_PORT, LOCAL_PORT, RTP_FORMAT_H265, flags);
sender = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_GENERIC, flags);
receiver = sess->create_stream(SEND_PORT, RECEIVE_PORT, RTP_FORMAT_GENERIC, flags);
}
int test_packets = 10;
@ -191,13 +183,13 @@ TEST(RTPTests, send_too_much)
uvgrtp::media_stream* sender = nullptr;
uvgrtp::media_stream* receiver = nullptr;
int flags = RTP_NO_FLAGS;
int flags = RCE_FRAGMENT_GENERIC;
EXPECT_NE(nullptr, sess);
if (sess)
{
sender = sess->create_stream(LOCAL_PORT, REMOTE_PORT, RTP_FORMAT_H265, flags);
receiver = sess->create_stream(REMOTE_PORT, LOCAL_PORT, RTP_FORMAT_H265, flags);
sender = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_GENERIC, flags);
receiver = sess->create_stream(SEND_PORT, RECEIVE_PORT, RTP_FORMAT_GENERIC, flags);
}
add_hook(nullptr, receiver, rtp_receive_hook);
@ -211,23 +203,4 @@ TEST(RTPTests, send_too_much)
cleanup_ms(sess, sender);
cleanup_ms(sess, receiver);
cleanup_sess(ctx, sess);
}
void rtp_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame)
{
if (arg != nullptr)
{
Test_receiver* tester = (Test_receiver*)arg;
tester->receive();
}
process_rtp_frame(frame);
}
void process_rtp_frame(uvgrtp::frame::rtp_frame* frame)
{
EXPECT_NE(0, frame->payload_len);
EXPECT_EQ(2, frame->header.version);
(void)uvgrtp::frame::dealloc_frame(frame);
}

62
test/test_4_formats.cpp
View File

@ -7,11 +7,6 @@ constexpr uint16_t RECEIVE_PORT = 9102;
constexpr int AMOUNT_OF_TEST_PACKETS = 100;
constexpr size_t PAYLOAD_LEN = 100;
void format_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame);
void process_format_frame(uvgrtp::frame::rtp_frame* frame);
// TODO: Use real files
TEST(FormatTests, h264)
@ -29,8 +24,18 @@ TEST(FormatTests, h264)
receiver = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_H264, RCE_H26X_PREPEND_SC);
}
add_hook(nullptr, receiver, format_receive_hook);
send_packets(sess, sender, AMOUNT_OF_TEST_PACKETS, PAYLOAD_LEN, 0, true, false);
// the default packet limit for RTP is 1458 where 12 bytes are dedicated to RTP header
test_packet_size(1443, sess, sender, receiver);
test_packet_size(1444, sess, sender, receiver);
test_packet_size(1445, sess, sender, receiver);
test_packet_size(1446, sess, sender, receiver);
test_packet_size(1447, sess, sender, receiver);
test_packet_size(1448, sess, sender, receiver);
test_packet_size(1449, sess, sender, receiver);
test_packet_size(1450, sess, sender, receiver);
test_packet_size(1501, sess, sender, receiver);
test_packet_size(15000, sess, sender, receiver);
test_packet_size(150000, sess, sender, receiver);
cleanup_ms(sess, sender);
cleanup_ms(sess, receiver);
@ -52,8 +57,18 @@ TEST(FormatTests, h265)
receiver = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_H265, RCE_H26X_PREPEND_SC);
}
add_hook(nullptr, receiver, format_receive_hook);
send_packets(sess, sender, AMOUNT_OF_TEST_PACKETS, PAYLOAD_LEN, 0, true, false);
// the default packet limit for RTP is 1458 where 12 bytes are dedicated to RTP header
test_packet_size(1443, sess, sender, receiver);
test_packet_size(1444, sess, sender, receiver);
test_packet_size(1445, sess, sender, receiver);
test_packet_size(1446, sess, sender, receiver);
test_packet_size(1447, sess, sender, receiver);
test_packet_size(1448, sess, sender, receiver);
test_packet_size(1449, sess, sender, receiver);
test_packet_size(1450, sess, sender, receiver);
test_packet_size(1501, sess, sender, receiver);
test_packet_size(15000, sess, sender, receiver);
test_packet_size(150000, sess, sender, receiver);
cleanup_ms(sess, sender);
cleanup_ms(sess, receiver);
@ -75,25 +90,20 @@ TEST(FormatTests, h266)
receiver = sess->create_stream(RECEIVE_PORT, SEND_PORT, RTP_FORMAT_H266, RCE_H26X_PREPEND_SC);
}
add_hook(nullptr, receiver, format_receive_hook);
send_packets(sess, sender, AMOUNT_OF_TEST_PACKETS, PAYLOAD_LEN, 0, true, false);
// the default packet limit for RTP is 1458 where 12 bytes are dedicated to RTP header
test_packet_size(1443, sess, sender, receiver);
test_packet_size(1444, sess, sender, receiver);
test_packet_size(1445, sess, sender, receiver);
test_packet_size(1446, sess, sender, receiver);
test_packet_size(1447, sess, sender, receiver);
test_packet_size(1448, sess, sender, receiver);
test_packet_size(1449, sess, sender, receiver);
test_packet_size(1450, sess, sender, receiver);
test_packet_size(1501, sess, sender, receiver);
test_packet_size(15000, sess, sender, receiver);
test_packet_size(150000, sess, sender, receiver);
cleanup_ms(sess, sender);
cleanup_ms(sess, receiver);
cleanup_sess(ctx, sess);
}
void format_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame)
{
process_format_frame(frame);
}
void process_format_frame(uvgrtp::frame::rtp_frame* frame)
{
//std::cout << "Receiving frame with seq: " << frame->header.seq
// << " and timestamp: " << frame->header.timestamp << std::endl;
EXPECT_EQ(frame->header.version, 2);
EXPECT_EQ(PAYLOAD_LEN, frame->payload_len);
(void)uvgrtp::frame::dealloc_frame(frame);
}

12
test/test_5_srtp_zrtp.cpp
View File

@ -17,7 +17,6 @@ constexpr int KEY_SIZE_BYTES = KEY_SIZE / 8;
constexpr int SALT_SIZE = 112;
constexpr int SALT_SIZE_BYTES = SALT_SIZE / 8;
void process_frame(uvgrtp::frame::rtp_frame* frame);
void receive_func(uint8_t key[KEY_SIZE_BYTES], uint8_t salt[SALT_SIZE_BYTES]);
@ -112,20 +111,11 @@ void receive_func(uint8_t key[KEY_SIZE_BYTES], uint8_t salt[SALT_SIZE_BYTES])
frame = recv->pull_frame(10);
if (frame)
{
process_frame(frame);
process_rtp_frame(frame);
}
}
}
cleanup_ms(receiver_session, recv);
cleanup_sess(ctx, receiver_session);
}
void process_frame(uvgrtp::frame::rtp_frame* frame)
{
std::string payload = std::string((char*)frame->payload, frame->payload_len);
EXPECT_NE(0, frame->payload_len);
(void)uvgrtp::frame::dealloc_frame(frame);
}

54
test/test_common.hh
View File

@ -12,9 +12,14 @@ inline void send_packets(uvgrtp::session* sess, uvgrtp::media_stream* sender,
int packets, size_t size, int packet_interval_ms, bool add_start_code, bool print_progress);
inline void add_hook(Test_receiver* tester, uvgrtp::media_stream* receiver, void (*hook)(void*, uvgrtp::frame::rtp_frame*));
inline void test_packet_size(size_t size, uvgrtp::media_stream* sender, uvgrtp::media_stream* receiver);
inline void cleanup_sess(uvgrtp::context& ctx, uvgrtp::session* sess);
inline void cleanup_ms(uvgrtp::session* sess, uvgrtp::media_stream* ms);
inline void process_rtp_frame(uvgrtp::frame::rtp_frame* frame);
inline void rtp_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame);
class Test_receiver
{
public:
@ -116,6 +121,36 @@ inline void cleanup_ms(uvgrtp::session* sess, uvgrtp::media_stream* ms)
}
inline void test_packet_size(size_t size, uvgrtp::session* sess, uvgrtp::media_stream* sender,
uvgrtp::media_stream* receiver)
{
EXPECT_NE(nullptr, sess);
EXPECT_NE(nullptr, sender);
EXPECT_NE(nullptr, receiver);
if (sess && sender && receiver)
{
int packets = 10;
Test_receiver* tester = new Test_receiver(packets);
add_hook(tester, receiver, rtp_receive_hook);
send_packets(sess, sender, packets, size, 10, true, false);
if (size > 20000)
{
std::this_thread::sleep_for(std::chrono::milliseconds(150));
}
else
{
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
tester->gotAll();
delete tester;
}
}
inline void add_hook(Test_receiver* tester, uvgrtp::media_stream* receiver,
void (*hook)(void*, uvgrtp::frame::rtp_frame*))
{
@ -125,4 +160,23 @@ inline void add_hook(Test_receiver* tester, uvgrtp::media_stream* receiver,
std::cout << "Installing hook" << std::endl;
EXPECT_EQ(RTP_OK, receiver->install_receive_hook(tester, hook));
}
}
inline void rtp_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame)
{
if (arg != nullptr)
{
Test_receiver* tester = (Test_receiver*)arg;
tester->receive();
}
process_rtp_frame(frame);
}
inline void process_rtp_frame(uvgrtp::frame::rtp_frame* frame)
{
EXPECT_NE(0, frame->payload_len);
EXPECT_EQ(2, frame->header.version);
(void)uvgrtp::frame::dealloc_frame(frame);
}