#include "webrtc/call.h"
#include "webrtc/frame_callback.h"
-#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/event_wrapper.h"
static unsigned int kDefaultTimeoutMs = 30 * 1000;
static unsigned int kLongTimeoutMs = 120 * 1000;
static const uint32_t kSendSsrc = 0x654321;
+static const uint32_t kSendRtxSsrc = 0x424242;
static const uint32_t kReceiverLocalSsrc = 0x123456;
static const uint8_t kSendPayloadType = 125;
+static const uint8_t kSendRtxPayloadType = 126;
class CallTest : public ::testing::Test {
public:
receive_stream_ = NULL;
}
+ void DecodesRetransmittedFrame(bool retransmit_over_rtx);
void ReceivesPliAndRecovers(int rtp_history_ms);
void RespectsRtcpMode(newapi::RtcpMode rtcp_mode);
void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
- EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)));
-
RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
private:
- virtual void FrameCallback(I420VideoFrame* frame) {
+ virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
SleepMs(kDelayRenderCallbackMs);
event_->Set();
}
DestroyStreams();
}
+// This test drops second RTP packet with a marker bit set, makes sure it's
+// retransmitted and renders. Retransmission SSRCs are also checked.
+void CallTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
+ static const int kDroppedFrameNumber = 2;
+ class RetransmissionObserver : public test::RtpRtcpObserver,
+ public I420FrameCallback {
+ public:
+ RetransmissionObserver(bool expect_rtx)
+ : RtpRtcpObserver(kDefaultTimeoutMs),
+ retransmission_ssrc_(expect_rtx ? kSendRtxSsrc : kSendSsrc),
+ retransmission_payload_type_(expect_rtx ? kSendRtxPayloadType
+ : kSendPayloadType),
+ marker_bits_observed_(0),
+ retransmitted_timestamp_(0),
+ frame_retransmitted_(false) {}
+
+ private:
+ virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
+ RTPHeader header;
+ EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
+
+ if (header.timestamp == retransmitted_timestamp_) {
+ EXPECT_EQ(retransmission_ssrc_, header.ssrc);
+ EXPECT_EQ(retransmission_payload_type_, header.payloadType);
+ frame_retransmitted_ = true;
+ return SEND_PACKET;
+ }
+
+ EXPECT_EQ(kSendSsrc, header.ssrc);
+ EXPECT_EQ(kSendPayloadType, header.payloadType);
+
+ // Found the second frame's final packet, drop this and expect a
+ // retransmission.
+ if (header.markerBit && ++marker_bits_observed_ == kDroppedFrameNumber) {
+ retransmitted_timestamp_ = header.timestamp;
+ return DROP_PACKET;
+ }
+
+ return SEND_PACKET;
+ }
+
+ virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
+ CriticalSectionScoped crit_(lock_.get());
+ if (frame->timestamp() == retransmitted_timestamp_) {
+ EXPECT_TRUE(frame_retransmitted_);
+ observation_complete_->Set();
+ }
+ }
+
+ const uint32_t retransmission_ssrc_;
+ const int retransmission_payload_type_;
+ int marker_bits_observed_;
+ uint32_t retransmitted_timestamp_;
+ bool frame_retransmitted_;
+ } observer(retransmit_over_rtx);
+
+ CreateCalls(Call::Config(observer.SendTransport()),
+ Call::Config(observer.ReceiveTransport()));
+
+ observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+
+ CreateTestConfigs();
+ send_config_.rtp.nack.rtp_history_ms =
+ receive_config_.rtp.nack.rtp_history_ms = 1000;
+ if (retransmit_over_rtx) {
+ send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrc);
+ send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
+ int payload_type = send_config_.codec.plType;
+ receive_config_.rtp.rtx[payload_type].ssrc = kSendRtxSsrc;
+ receive_config_.rtp.rtx[payload_type].payload_type = kSendRtxPayloadType;
+ }
+ receive_config_.pre_render_callback = &observer;
+
+ CreateStreams();
+ CreateFrameGenerator();
+ StartSending();
+
+ EXPECT_EQ(kEventSignaled, observer.Wait())
+ << "Timed out while waiting for retransmission to render.";
+
+ StopSending();
+ observer.StopSending();
+ DestroyStreams();
+}
+
+TEST_F(CallTest, DecodesRetransmittedFrame) {
+ DecodesRetransmittedFrame(false);
+}
+
+TEST_F(CallTest, DecodesRetransmittedFrameOverRtx) {
+ DecodesRetransmittedFrame(true);
+}
+
TEST_F(CallTest, UsesFrameCallbacks) {
static const int kWidth = 320;
static const int kHeight = 240;
public:
explicit PliObserver(bool nack_enabled)
: test::RtpRtcpObserver(kLongTimeoutMs),
- rtp_header_parser_(RtpHeaderParser::Create()),
nack_enabled_(nack_enabled),
highest_dropped_timestamp_(0),
frames_to_drop_(0),
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
- EXPECT_TRUE(
- rtp_header_parser_->Parse(packet, static_cast<int>(length), &header));
+ EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
// Drop all retransmitted packets to force a PLI.
if (header.timestamp <= highest_dropped_timestamp_)
private:
static const int kPacketsToDrop = 1;
- scoped_ptr<RtpHeaderParser> rtp_header_parser_;
bool nack_enabled_;
uint32_t highest_dropped_timestamp_;
int frames_to_drop_;
TEST_F(CallTest, ObserversEncodedFrames) {
class EncodedFrameTestObserver : public EncodedFrameObserver {
public:
- EncodedFrameTestObserver() : length_(0),
- frame_type_(kFrameEmpty),
- called_(EventWrapper::Create()) {}
+ EncodedFrameTestObserver()
+ : length_(0),
+ frame_type_(kFrameEmpty),
+ called_(EventWrapper::Create()) {}
virtual ~EncodedFrameTestObserver() {}
virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
called_->Set();
}
- EventTypeWrapper Wait() {
- return called_->Wait(kDefaultTimeoutMs);
- }
+ EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
ASSERT_EQ(length_, observer.length_)
sent_rtcp_rr_(0),
sent_rtcp_rrtr_(0),
sent_rtcp_dlrr_(0) {}
+
private:
// Receive stream should send RR packets (and RRTR packets if enabled).
virtual Action OnReceiveRtcp(const uint8_t* packet,
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpRrCode) {
++sent_rtcp_rr_;
- } else if (
- packet_type == RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
+ } else if (packet_type ==
+ RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
++sent_rtcp_rrtr_;
}
EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
CreateCalls(Call::Config(observer.SendTransport()),
Call::Config(observer.ReceiveTransport()));
- observer.SetReceivers(receiver_call_->Receiver(),
- sender_call_->Receiver());
+ observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
CreateTestConfigs();
receive_config_.rtp.rtcp_mode = newapi::kRtcpReducedSize;
DestroyStreams();
}
+class StatsObserver : public test::RtpRtcpObserver, public I420FrameCallback {
+ public:
+ StatsObserver()
+ : test::RtpRtcpObserver(kLongTimeoutMs),
+ receive_stream_(NULL),
+ send_stream_(NULL),
+ expected_receive_ssrc_(),
+ expected_send_ssrcs_(),
+ check_stats_event_(EventWrapper::Create()) {}
+
+ void SetExpectedReceiveSsrc(uint32_t ssrc) { expected_receive_ssrc_ = ssrc; }
+
+ void SetExpectedSendSsrcs(const std::vector<uint32_t>& ssrcs) {
+ for (std::vector<uint32_t>::const_iterator it = ssrcs.begin();
+ it != ssrcs.end();
+ ++it) {
+ expected_send_ssrcs_.insert(*it);
+ }
+ }
+
+ void SetExpectedCName(std::string cname) { expected_cname_ = cname; }
+
+ void SetReceiveStream(VideoReceiveStream* stream) {
+ receive_stream_ = stream;
+ }
+
+ void SetSendStream(VideoSendStream* stream) { send_stream_ = stream; }
+
+ void WaitForFilledStats() {
+ Clock* clock = Clock::GetRealTimeClock();
+ int64_t now = clock->TimeInMilliseconds();
+ int64_t stop_time = now + kLongTimeoutMs;
+ bool receive_ok = false;
+ bool send_ok = false;
+
+ while (now < stop_time) {
+ if (!receive_ok)
+ receive_ok = CheckReceiveStats();
+ if (!send_ok)
+ send_ok = CheckSendStats();
+
+ if (receive_ok && send_ok)
+ return;
+
+ int64_t time_until_timout_ = stop_time - now;
+ if (time_until_timout_ > 0)
+ check_stats_event_->Wait(time_until_timout_);
+ now = clock->TimeInMilliseconds();
+ }
+
+ ADD_FAILURE() << "Timed out waiting for filled stats.";
+ for (std::map<std::string, bool>::const_iterator it =
+ receive_stats_filled_.begin();
+ it != receive_stats_filled_.end();
+ ++it) {
+ if (!it->second) {
+ ADD_FAILURE() << "Missing receive stats: " << it->first;
+ }
+ }
+
+ for (std::map<std::string, bool>::const_iterator it =
+ send_stats_filled_.begin();
+ it != send_stats_filled_.end();
+ ++it) {
+ if (!it->second) {
+ ADD_FAILURE() << "Missing send stats: " << it->first;
+ }
+ }
+ }
+
+ private:
+ virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
+ check_stats_event_->Set();
+ return SEND_PACKET;
+ }
+
+ virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
+ check_stats_event_->Set();
+ return SEND_PACKET;
+ }
+
+ virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE {
+ check_stats_event_->Set();
+ return SEND_PACKET;
+ }
+
+ virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
+ check_stats_event_->Set();
+ return SEND_PACKET;
+ }
+
+ virtual void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
+ // Ensure that we have at least 5ms send side delay.
+ int64_t render_time = video_frame->render_time_ms();
+ if (render_time > 0)
+ video_frame->set_render_time_ms(render_time - 5);
+ }
+
+ bool CheckReceiveStats() {
+ assert(receive_stream_ != NULL);
+ VideoReceiveStream::Stats stats = receive_stream_->GetStats();
+ EXPECT_EQ(expected_receive_ssrc_, stats.ssrc);
+
+ // Make sure all fields have been populated.
+
+ receive_stats_filled_["IncomingRate"] |=
+ stats.network_frame_rate != 0 || stats.bitrate_bps != 0;
+
+ receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0;
+
+ receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0;
+
+ receive_stats_filled_["StatisticsUpdated"] |=
+ stats.rtcp_stats.cumulative_lost != 0 ||
+ stats.rtcp_stats.extended_max_sequence_number != 0 ||
+ stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0;
+
+ receive_stats_filled_["DataCountersUpdated"] |=
+ stats.rtp_stats.bytes != 0 || stats.rtp_stats.fec_packets != 0 ||
+ stats.rtp_stats.header_bytes != 0 || stats.rtp_stats.packets != 0 ||
+ stats.rtp_stats.padding_bytes != 0 ||
+ stats.rtp_stats.retransmitted_packets != 0;
+
+ receive_stats_filled_["CodecStats"] |=
+ stats.avg_delay_ms != 0 || stats.discarded_packets != 0 ||
+ stats.key_frames != 0 || stats.delta_frames != 0;
+
+ receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
+
+ return AllStatsFilled(receive_stats_filled_);
+ }
+
+ bool CheckSendStats() {
+ assert(send_stream_ != NULL);
+ VideoSendStream::Stats stats = send_stream_->GetStats();
+
+ send_stats_filled_["NumStreams"] |=
+ stats.substreams.size() == expected_send_ssrcs_.size();
+
+ send_stats_filled_["Delay"] |=
+ stats.avg_delay_ms != 0 || stats.max_delay_ms != 0;
+
+ receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
+
+ for (std::map<uint32_t, StreamStats>::const_iterator it =
+ stats.substreams.begin();
+ it != stats.substreams.end();
+ ++it) {
+ EXPECT_TRUE(expected_send_ssrcs_.find(it->first) !=
+ expected_send_ssrcs_.end());
+
+ send_stats_filled_[CompoundKey("IncomingRate", it->first)] |=
+ stats.input_frame_rate != 0;
+
+ const StreamStats& stream_stats = it->second;
+
+ send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |=
+ stream_stats.rtcp_stats.cumulative_lost != 0 ||
+ stream_stats.rtcp_stats.extended_max_sequence_number != 0 ||
+ stream_stats.rtcp_stats.fraction_lost != 0;
+
+ send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |=
+ stream_stats.rtp_stats.fec_packets != 0 ||
+ stream_stats.rtp_stats.padding_bytes != 0 ||
+ stream_stats.rtp_stats.retransmitted_packets != 0 ||
+ stream_stats.rtp_stats.packets != 0;
+
+ send_stats_filled_[CompoundKey("BitrateStatisticsObserver", it->first)] |=
+ stream_stats.bitrate_bps != 0;
+
+ send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |=
+ stream_stats.delta_frames != 0 || stream_stats.key_frames != 0;
+
+ send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |=
+ stats.encode_frame_rate != 0;
+ }
+
+ return AllStatsFilled(send_stats_filled_);
+ }
+
+ std::string CompoundKey(const char* name, uint32_t ssrc) {
+ std::ostringstream oss;
+ oss << name << "_" << ssrc;
+ return oss.str();
+ }
+
+ bool AllStatsFilled(const std::map<std::string, bool>& stats_map) {
+ for (std::map<std::string, bool>::const_iterator it = stats_map.begin();
+ it != stats_map.end();
+ ++it) {
+ if (!it->second)
+ return false;
+ }
+ return true;
+ }
+
+ VideoReceiveStream* receive_stream_;
+ std::map<std::string, bool> receive_stats_filled_;
+
+ VideoSendStream* send_stream_;
+ std::map<std::string, bool> send_stats_filled_;
+
+ uint32_t expected_receive_ssrc_;
+ std::set<uint32_t> expected_send_ssrcs_;
+ std::string expected_cname_;
+
+ scoped_ptr<EventWrapper> check_stats_event_;
+};
+
+TEST_F(CallTest, GetStats) {
+ StatsObserver observer;
+
+ CreateCalls(Call::Config(observer.SendTransport()),
+ Call::Config(observer.ReceiveTransport()));
+
+ observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+
+ CreateTestConfigs();
+ send_config_.pre_encode_callback = &observer; // Used to inject delay.
+ send_config_.rtp.c_name = "SomeCName";
+
+ observer.SetExpectedReceiveSsrc(receive_config_.rtp.local_ssrc);
+ observer.SetExpectedSendSsrcs(send_config_.rtp.ssrcs);
+ observer.SetExpectedCName(send_config_.rtp.c_name);
+
+ CreateStreams();
+ observer.SetReceiveStream(receive_stream_);
+ observer.SetSendStream(send_stream_);
+ CreateFrameGenerator();
+ StartSending();
+
+ observer.WaitForFilledStats();
+
+ StopSending();
+ observer.StopSending();
+ DestroyStreams();
+}
+
TEST_F(CallTest, ReceiverReferenceTimeReportEnabled) {
TestXrReceiverReferenceTimeReport(true);
}
projects / platform / framework / web / crosswalk.git / blobdiff