end2end_unittest.cc 49 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <math.h>
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <algorithm>
  8. #include <functional>
  9. #include <list>
  10. #include <map>
  11. #include <memory>
  12. #include <utility>
  13. #include "base/bind.h"
  14. #include "base/callback_helpers.h"
  15. #include "base/logging.h"
  16. #include "base/memory/ptr_util.h"
  17. #include "base/memory/raw_ptr.h"
  18. #include "base/strings/string_number_conversions.h"
  19. #include "base/sys_byteorder.h"
  20. #include "base/test/simple_test_tick_clock.h"
  21. #include "base/test/task_environment.h"
  22. #include "base/time/tick_clock.h"
  23. #include "base/time/time.h"
  24. #include "build/build_config.h"
  25. #include "media/base/audio_bus.h"
  26. #include "media/base/fake_single_thread_task_runner.h"
  27. #include "media/base/video_frame.h"
  28. #include "media/cast/cast_config.h"
  29. #include "media/cast/cast_environment.h"
  30. #include "media/cast/cast_sender.h"
  31. #include "media/cast/logging/simple_event_subscriber.h"
  32. #include "media/cast/net/cast_transport.h"
  33. #include "media/cast/net/cast_transport_config.h"
  34. #include "media/cast/net/cast_transport_defines.h"
  35. #include "media/cast/net/cast_transport_impl.h"
  36. #include "media/cast/test/receiver/cast_receiver.h"
  37. #include "media/cast/test/skewed_single_thread_task_runner.h"
  38. #include "media/cast/test/skewed_tick_clock.h"
  39. #include "media/cast/test/utility/audio_utility.h"
  40. #include "media/cast/test/utility/default_config.h"
  41. #include "media/cast/test/utility/udp_proxy.h"
  42. #include "media/cast/test/utility/video_utility.h"
  43. #include "testing/gtest/include/gtest/gtest.h"
  44. namespace media {
  45. namespace cast {
  46. namespace {
  47. // This test suite generates synthetic data. For audio, it's a sinusoid waveform
  48. // with frequency kSoundFrequency and different amplitudes. For video, it's a
  49. // pattern that is shifting by one pixel per frame. Each pixels' neighbors right
  50. // and down is incremented by one; since the pixel value is 8 bit it will wrap
  51. // frequently within the image. Visually, this creates diagonal color bands that
  52. // move across the screen.
  53. constexpr int64_t kStartMillisecond = INT64_C(1245);
  54. constexpr int kAudioChannels = 2;
  55. constexpr double kSoundFrequency = 314.15926535897; // Freq of sine wave.
  56. constexpr float kSoundVolume = 0.5f;
  57. constexpr int kVideoWidth = 320;
  58. constexpr int kVideoHeight = 180;
  59. // Since the video encoded and decoded an error will be introduced; when
  60. // comparing individual pixels the error can be quite large; we allow a PSNR of
  61. // at least |kVideoAcceptedPSNR|.
  62. constexpr double kVideoAcceptedPSNR = 38.0;
  63. // The tests are commonly implemented with |kFrameTimerInterval| RunTask
  64. // function; a normal video is 30 fps hence the 33 ms between frames.
  65. constexpr base::TimeDelta kFrameTimerInterval = base::Milliseconds(33);
  66. // The size of audio frames. The encoder joins/breaks all inserted audio into
  67. // chunks of this size.
  68. constexpr base::TimeDelta kAudioFrameDuration = base::Milliseconds(10);
  69. // The amount of time between frame capture on the sender and playout on the
  70. // receiver.
  71. constexpr base::TimeDelta kTargetPlayoutDelay = base::Milliseconds(400);
  72. // The maximum amount of deviation expected in the playout times emitted by the
  73. // receiver.
  74. constexpr base::TimeDelta kMaxAllowedPlayoutError = base::Milliseconds(30);
  75. std::string ConvertFromBase16String(const std::string& base_16) {
  76. std::string compressed;
  77. DCHECK_EQ(base_16.size() % 2, 0u) << "Must be a multiple of 2";
  78. compressed.reserve(base_16.size() / 2);
  79. if (!base::HexStringToString(base_16, &compressed)) {
  80. NOTREACHED();
  81. }
  82. return compressed;
  83. }
  84. void ExpectSuccessOperationalStatus(OperationalStatus status) {
  85. EXPECT_EQ(STATUS_INITIALIZED, status);
  86. }
  87. // This is wrapped in a struct because it needs to be put into a std::map.
  88. typedef struct {
  89. int counter[kNumOfLoggingEvents];
  90. } LoggingEventCounts;
  91. // Constructs a map from each frame (RTP timestamp) to counts of each event
  92. // type logged for that frame.
  93. std::map<RtpTimeTicks, LoggingEventCounts> GetEventCountsForFrameEvents(
  94. const std::vector<FrameEvent>& frame_events) {
  95. std::map<RtpTimeTicks, LoggingEventCounts> event_counter_for_frame;
  96. for (const FrameEvent& frame_event : frame_events) {
  97. auto map_it = event_counter_for_frame.find(frame_event.rtp_timestamp);
  98. if (map_it == event_counter_for_frame.end()) {
  99. LoggingEventCounts new_counter;
  100. memset(&new_counter, 0, sizeof(new_counter));
  101. ++(new_counter.counter[frame_event.type]);
  102. event_counter_for_frame.insert(
  103. std::make_pair(frame_event.rtp_timestamp, new_counter));
  104. } else {
  105. ++(map_it->second.counter[frame_event.type]);
  106. }
  107. }
  108. return event_counter_for_frame;
  109. }
  110. // Constructs a map from each packet (Packet ID) to counts of each event
  111. // type logged for that packet.
  112. std::map<uint16_t, LoggingEventCounts> GetEventCountsForPacketEvents(
  113. const std::vector<PacketEvent>& packet_events) {
  114. std::map<uint16_t, LoggingEventCounts> event_counter_for_packet;
  115. for (const PacketEvent& packet_event : packet_events) {
  116. auto map_it = event_counter_for_packet.find(packet_event.packet_id);
  117. if (map_it == event_counter_for_packet.end()) {
  118. LoggingEventCounts new_counter;
  119. memset(&new_counter, 0, sizeof(new_counter));
  120. ++(new_counter.counter[packet_event.type]);
  121. event_counter_for_packet.insert(
  122. std::make_pair(packet_event.packet_id, new_counter));
  123. } else {
  124. ++(map_it->second.counter[packet_event.type]);
  125. }
  126. }
  127. return event_counter_for_packet;
  128. }
  129. // Shim that turns forwards packets from a test::PacketPipe to a
  130. // PacketReceiverCallback.
  131. class LoopBackPacketPipe final : public test::PacketPipe {
  132. public:
  133. explicit LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver)
  134. : packet_receiver_(packet_receiver) {}
  135. ~LoopBackPacketPipe() override = default;
  136. // PacketPipe implementations.
  137. void Send(std::unique_ptr<Packet> packet) override {
  138. packet_receiver_.Run(std::move(packet));
  139. }
  140. private:
  141. PacketReceiverCallback packet_receiver_;
  142. };
  143. // Class that sends the packet direct from sender into the receiver with the
  144. // ability to drop packets between the two.
  145. class LoopBackTransport : public PacketTransport {
  146. public:
  147. explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
  148. : send_packets_(true),
  149. drop_packets_belonging_to_odd_frames_(false),
  150. cast_environment_(cast_environment),
  151. bytes_sent_(0) {}
  152. void SetPacketReceiver(
  153. const PacketReceiverCallback& packet_receiver,
  154. const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  155. const base::TickClock* clock) {
  156. std::unique_ptr<test::PacketPipe> loopback_pipe(
  157. new LoopBackPacketPipe(packet_receiver));
  158. if (packet_pipe_) {
  159. packet_pipe_->AppendToPipe(std::move(loopback_pipe));
  160. } else {
  161. packet_pipe_ = std::move(loopback_pipe);
  162. }
  163. packet_pipe_->InitOnIOThread(task_runner, clock);
  164. }
  165. bool SendPacket(PacketRef packet, base::OnceClosure cb) final {
  166. DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
  167. if (!send_packets_)
  168. return true;
  169. bytes_sent_ += packet->data.size();
  170. if (drop_packets_belonging_to_odd_frames_) {
  171. const uint8_t truncated_frame_id = packet->data[13];
  172. if (truncated_frame_id % 2 == 1)
  173. return true;
  174. }
  175. std::unique_ptr<Packet> packet_copy(new Packet(packet->data));
  176. packet_pipe_->Send(std::move(packet_copy));
  177. return true;
  178. }
  179. int64_t GetBytesSent() final { return bytes_sent_; }
  180. void StartReceiving(PacketReceiverCallbackWithStatus packet_receiver) final {}
  181. void StopReceiving() final {}
  182. void SetSendPackets(bool send_packets) { send_packets_ = send_packets; }
  183. void DropAllPacketsBelongingToOddFrames() {
  184. drop_packets_belonging_to_odd_frames_ = true;
  185. }
  186. void SetPacketPipe(std::unique_ptr<test::PacketPipe> pipe) {
  187. // Append the loopback pipe to the end.
  188. pipe->AppendToPipe(std::move(packet_pipe_));
  189. packet_pipe_ = std::move(pipe);
  190. }
  191. private:
  192. bool send_packets_;
  193. bool drop_packets_belonging_to_odd_frames_;
  194. scoped_refptr<CastEnvironment> cast_environment_;
  195. std::unique_ptr<test::PacketPipe> packet_pipe_;
  196. int64_t bytes_sent_;
  197. };
  198. // Class that verifies the audio frames coming out of the receiver.
  199. class TestReceiverAudioCallback
  200. : public base::RefCountedThreadSafe<TestReceiverAudioCallback> {
  201. public:
  202. struct ExpectedAudioFrame {
  203. std::unique_ptr<AudioBus> audio_bus;
  204. base::TimeTicks playout_time;
  205. };
  206. TestReceiverAudioCallback() : num_called_(0) {}
  207. void SetExpectedSamplingFrequency(int expected_sampling_frequency) {
  208. expected_sampling_frequency_ = expected_sampling_frequency;
  209. }
  210. void AddExpectedResult(const AudioBus& audio_bus,
  211. base::TimeTicks playout_time) {
  212. std::unique_ptr<ExpectedAudioFrame> expected_audio_frame(
  213. new ExpectedAudioFrame());
  214. expected_audio_frame->audio_bus =
  215. AudioBus::Create(audio_bus.channels(), audio_bus.frames());
  216. audio_bus.CopyTo(expected_audio_frame->audio_bus.get());
  217. expected_audio_frame->playout_time = playout_time;
  218. expected_frames_.push_back(std::move(expected_audio_frame));
  219. }
  220. void IgnoreAudioFrame(std::unique_ptr<AudioBus> audio_bus,
  221. base::TimeTicks playout_time,
  222. bool is_continuous) {
  223. ++num_called_;
  224. }
  225. void CheckAudioFrame(std::unique_ptr<AudioBus> audio_bus,
  226. base::TimeTicks playout_time,
  227. bool is_continuous) {
  228. ++num_called_;
  229. ASSERT_TRUE(audio_bus);
  230. ASSERT_FALSE(expected_frames_.empty());
  231. const std::unique_ptr<ExpectedAudioFrame> expected_audio_frame =
  232. std::move(expected_frames_.front());
  233. expected_frames_.pop_front();
  234. EXPECT_EQ(audio_bus->channels(), kAudioChannels);
  235. EXPECT_EQ(audio_bus->frames(), expected_audio_frame->audio_bus->frames());
  236. for (int ch = 0; ch < audio_bus->channels(); ++ch) {
  237. EXPECT_NEAR(
  238. CountZeroCrossings(expected_audio_frame->audio_bus->channel(ch),
  239. expected_audio_frame->audio_bus->frames()),
  240. CountZeroCrossings(audio_bus->channel(ch), audio_bus->frames()), 1);
  241. }
  242. EXPECT_NEAR(
  243. (playout_time - expected_audio_frame->playout_time).InMillisecondsF(),
  244. 0.0, kMaxAllowedPlayoutError.InMilliseconds());
  245. VLOG_IF(1, !last_playout_time_.is_null())
  246. << "Audio frame playout time delta (compared to last frame) is "
  247. << (playout_time - last_playout_time_).InMicroseconds() << " usec.";
  248. last_playout_time_ = playout_time;
  249. EXPECT_TRUE(is_continuous);
  250. }
  251. int number_times_called() const { return num_called_; }
  252. protected:
  253. virtual ~TestReceiverAudioCallback() = default;
  254. private:
  255. friend class base::RefCountedThreadSafe<TestReceiverAudioCallback>;
  256. int num_called_;
  257. int expected_sampling_frequency_;
  258. std::list<std::unique_ptr<ExpectedAudioFrame>> expected_frames_;
  259. base::TimeTicks last_playout_time_;
  260. };
  261. // Class that verifies the video frames coming out of the receiver.
  262. class TestReceiverVideoCallback
  263. : public base::RefCountedThreadSafe<TestReceiverVideoCallback> {
  264. public:
  265. struct ExpectedVideoFrame {
  266. int frame_number;
  267. gfx::Size size;
  268. base::TimeTicks playout_time;
  269. bool should_be_continuous;
  270. };
  271. TestReceiverVideoCallback() : num_called_(0) {}
  272. void AddExpectedResult(int frame_number,
  273. const gfx::Size& size,
  274. base::TimeTicks playout_time,
  275. bool should_be_continuous) {
  276. ExpectedVideoFrame expected_video_frame;
  277. expected_video_frame.frame_number = frame_number;
  278. expected_video_frame.size = size;
  279. expected_video_frame.playout_time = playout_time;
  280. expected_video_frame.should_be_continuous = should_be_continuous;
  281. expected_frame_.push_back(expected_video_frame);
  282. }
  283. void CheckVideoFrame(bool examine_content,
  284. scoped_refptr<media::VideoFrame> video_frame,
  285. base::TimeTicks playout_time,
  286. bool is_continuous) {
  287. ++num_called_;
  288. ASSERT_TRUE(video_frame);
  289. ASSERT_FALSE(expected_frame_.empty());
  290. ExpectedVideoFrame expected_video_frame = expected_frame_.front();
  291. expected_frame_.pop_front();
  292. EXPECT_EQ(expected_video_frame.size.width(),
  293. video_frame->visible_rect().width());
  294. EXPECT_EQ(expected_video_frame.size.height(),
  295. video_frame->visible_rect().height());
  296. if (examine_content && expected_video_frame.should_be_continuous) {
  297. scoped_refptr<media::VideoFrame> expected_I420_frame =
  298. media::VideoFrame::CreateFrame(
  299. PIXEL_FORMAT_I420, expected_video_frame.size,
  300. gfx::Rect(expected_video_frame.size), expected_video_frame.size,
  301. base::TimeDelta());
  302. PopulateVideoFrame(expected_I420_frame.get(),
  303. expected_video_frame.frame_number);
  304. EXPECT_LE(kVideoAcceptedPSNR,
  305. I420PSNR(*expected_I420_frame, *video_frame));
  306. }
  307. EXPECT_NEAR(
  308. (playout_time - expected_video_frame.playout_time).InMillisecondsF(),
  309. 0.0, kMaxAllowedPlayoutError.InMilliseconds());
  310. VLOG_IF(1, !last_playout_time_.is_null())
  311. << "Video frame playout time delta (compared to last frame) is "
  312. << (playout_time - last_playout_time_).InMicroseconds() << " usec.";
  313. last_playout_time_ = playout_time;
  314. EXPECT_EQ(expected_video_frame.should_be_continuous, is_continuous);
  315. }
  316. int number_times_called() const { return num_called_; }
  317. protected:
  318. virtual ~TestReceiverVideoCallback() = default;
  319. private:
  320. friend class base::RefCountedThreadSafe<TestReceiverVideoCallback>;
  321. int num_called_;
  322. std::list<ExpectedVideoFrame> expected_frame_;
  323. base::TimeTicks last_playout_time_;
  324. };
  325. } // namespace
  326. // The actual test class, generate synthetic data for both audio and video and
  327. // send those through the sender and receiver and analyzes the result.
  328. class End2EndTest : public ::testing::Test {
  329. public:
  330. void ReceivePacket(std::unique_ptr<media::cast::Packet> packet) {
  331. cast_receiver_->ReceivePacket(std::move(packet));
  332. }
  333. protected:
  334. End2EndTest()
  335. : start_time_(),
  336. task_runner_(new FakeSingleThreadTaskRunner(&testing_clock_)),
  337. testing_clock_sender_(&testing_clock_),
  338. task_runner_sender_(
  339. new test::SkewedSingleThreadTaskRunner(task_runner_)),
  340. testing_clock_receiver_(&testing_clock_),
  341. task_runner_receiver_(
  342. new test::SkewedSingleThreadTaskRunner(task_runner_)),
  343. cast_environment_sender_(new CastEnvironment(&testing_clock_sender_,
  344. task_runner_sender_,
  345. task_runner_sender_,
  346. task_runner_sender_)),
  347. cast_environment_receiver_(new CastEnvironment(&testing_clock_receiver_,
  348. task_runner_receiver_,
  349. task_runner_receiver_,
  350. task_runner_receiver_)),
  351. receiver_to_sender_(new LoopBackTransport(cast_environment_receiver_)),
  352. sender_to_receiver_(new LoopBackTransport(cast_environment_sender_)),
  353. test_receiver_audio_callback_(new TestReceiverAudioCallback()),
  354. test_receiver_video_callback_(new TestReceiverVideoCallback()) {
  355. testing_clock_.Advance(base::Milliseconds(kStartMillisecond));
  356. cast_environment_sender_->logger()->Subscribe(&event_subscriber_sender_);
  357. }
  358. void Configure(Codec video_codec, Codec audio_codec) {
  359. audio_sender_config_.sender_ssrc = 1;
  360. audio_sender_config_.receiver_ssrc = 2;
  361. audio_sender_config_.max_playout_delay = kTargetPlayoutDelay;
  362. audio_sender_config_.rtp_payload_type = RtpPayloadType::AUDIO_OPUS;
  363. audio_sender_config_.use_external_encoder = false;
  364. audio_sender_config_.rtp_timebase = kDefaultAudioSamplingRate;
  365. audio_sender_config_.channels = kAudioChannels;
  366. audio_sender_config_.max_bitrate = kDefaultAudioEncoderBitrate;
  367. audio_sender_config_.codec = audio_codec;
  368. audio_sender_config_.aes_iv_mask =
  369. ConvertFromBase16String("abcdeffedcba12345678900987654321");
  370. audio_sender_config_.aes_key =
  371. ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
  372. audio_receiver_config_.receiver_ssrc = audio_sender_config_.receiver_ssrc;
  373. audio_receiver_config_.sender_ssrc = audio_sender_config_.sender_ssrc;
  374. audio_receiver_config_.rtp_max_delay_ms =
  375. kTargetPlayoutDelay.InMilliseconds();
  376. audio_receiver_config_.rtp_payload_type =
  377. audio_sender_config_.rtp_payload_type;
  378. audio_receiver_config_.rtp_timebase = audio_sender_config_.rtp_timebase;
  379. audio_receiver_config_.channels = kAudioChannels;
  380. audio_receiver_config_.target_frame_rate = 100;
  381. audio_receiver_config_.codec = audio_sender_config_.codec;
  382. audio_receiver_config_.aes_iv_mask = audio_sender_config_.aes_iv_mask;
  383. audio_receiver_config_.aes_key = audio_sender_config_.aes_key;
  384. test_receiver_audio_callback_->SetExpectedSamplingFrequency(
  385. audio_receiver_config_.rtp_timebase);
  386. if (video_codec == CODEC_VIDEO_FAKE)
  387. video_sender_config_.enable_fake_codec_for_tests = true;
  388. video_sender_config_.sender_ssrc = 3;
  389. video_sender_config_.receiver_ssrc = 4;
  390. video_sender_config_.max_playout_delay = kTargetPlayoutDelay;
  391. video_sender_config_.rtp_payload_type = RtpPayloadType::VIDEO_VP8;
  392. video_sender_config_.use_external_encoder = false;
  393. video_sender_config_.rtp_timebase = kVideoFrequency;
  394. video_sender_config_.max_bitrate = 50000;
  395. video_sender_config_.min_bitrate = 10000;
  396. video_sender_config_.start_bitrate = 10000;
  397. video_sender_config_.video_codec_params.max_qp = 30;
  398. video_sender_config_.video_codec_params.min_qp = 4;
  399. video_sender_config_.max_frame_rate = 30;
  400. video_sender_config_.codec = video_codec;
  401. video_sender_config_.aes_iv_mask =
  402. ConvertFromBase16String("1234567890abcdeffedcba0987654321");
  403. video_sender_config_.aes_key =
  404. ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
  405. video_receiver_config_.receiver_ssrc = video_sender_config_.receiver_ssrc;
  406. video_receiver_config_.sender_ssrc = video_sender_config_.sender_ssrc;
  407. video_receiver_config_.rtp_max_delay_ms =
  408. kTargetPlayoutDelay.InMilliseconds();
  409. video_receiver_config_.rtp_payload_type =
  410. video_sender_config_.rtp_payload_type;
  411. video_receiver_config_.rtp_timebase = kVideoFrequency;
  412. video_receiver_config_.channels = 1;
  413. video_receiver_config_.target_frame_rate =
  414. video_sender_config_.max_frame_rate;
  415. video_receiver_config_.codec = video_sender_config_.codec;
  416. video_receiver_config_.aes_iv_mask = video_sender_config_.aes_iv_mask;
  417. video_receiver_config_.aes_key = video_sender_config_.aes_key;
  418. }
  419. void SetReceiverSkew(double skew, base::TimeDelta offset) {
  420. testing_clock_receiver_.SetSkew(skew, offset);
  421. task_runner_receiver_->SetSkew(1.0 / skew);
  422. }
  423. // Specify the minimum/maximum difference in playout times between two
  424. // consecutive frames. Also, specify the maximum absolute rate of change over
  425. // each three consecutive frames.
  426. void SetExpectedVideoPlayoutSmoothness(base::TimeDelta min_delta,
  427. base::TimeDelta max_delta,
  428. base::TimeDelta max_curvature) {
  429. min_video_playout_delta_ = min_delta;
  430. max_video_playout_delta_ = max_delta;
  431. max_video_playout_curvature_ = max_curvature;
  432. }
  433. void FeedAudioFrames(int count, bool will_be_checked) {
  434. for (int i = 0; i < count; ++i) {
  435. std::unique_ptr<AudioBus> audio_bus(
  436. audio_bus_factory_->NextAudioBus(kAudioFrameDuration));
  437. const base::TimeTicks reference_time =
  438. testing_clock_sender_.NowTicks() + i * kAudioFrameDuration;
  439. if (will_be_checked) {
  440. test_receiver_audio_callback_->AddExpectedResult(
  441. *audio_bus, reference_time + kTargetPlayoutDelay);
  442. }
  443. audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
  444. }
  445. }
  446. void FeedAudioFramesWithExpectedDelay(int count, base::TimeDelta delay) {
  447. for (int i = 0; i < count; ++i) {
  448. std::unique_ptr<AudioBus> audio_bus(
  449. audio_bus_factory_->NextAudioBus(kAudioFrameDuration));
  450. const base::TimeTicks reference_time =
  451. testing_clock_sender_.NowTicks() + i * kAudioFrameDuration;
  452. test_receiver_audio_callback_->AddExpectedResult(
  453. *audio_bus, reference_time + delay + kTargetPlayoutDelay);
  454. audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
  455. }
  456. }
  457. void RequestAudioFrames(int count, bool with_check) {
  458. for (int i = 0; i < count; ++i) {
  459. cast_receiver_->RequestDecodedAudioFrame(base::BindRepeating(
  460. with_check ? &TestReceiverAudioCallback::CheckAudioFrame
  461. : &TestReceiverAudioCallback::IgnoreAudioFrame,
  462. test_receiver_audio_callback_));
  463. }
  464. }
  465. void Create();
  466. ~End2EndTest() override {
  467. cast_environment_sender_->logger()->Unsubscribe(&event_subscriber_sender_);
  468. }
  469. void TearDown() final {
  470. cast_sender_.reset();
  471. cast_receiver_.reset();
  472. task_runner_->RunTasks();
  473. }
  474. gfx::Size GetTestVideoFrameSize() const {
  475. if (video_sender_config_.codec == CODEC_VIDEO_FAKE)
  476. return gfx::Size(2, 2);
  477. else
  478. return gfx::Size(kVideoWidth, kVideoHeight);
  479. }
  480. void SendVideoFrame(int frame_number, base::TimeTicks reference_time) {
  481. if (start_time_.is_null())
  482. start_time_ = reference_time;
  483. const base::TimeDelta time_diff = reference_time - start_time_;
  484. scoped_refptr<media::VideoFrame> video_frame;
  485. if (video_sender_config_.codec == CODEC_VIDEO_FAKE) {
  486. video_frame =
  487. media::VideoFrame::CreateBlackFrame(GetTestVideoFrameSize());
  488. } else {
  489. const gfx::Size size = GetTestVideoFrameSize();
  490. video_frame = media::VideoFrame::CreateFrame(
  491. PIXEL_FORMAT_I420, size, gfx::Rect(size), size, time_diff);
  492. PopulateVideoFrame(video_frame.get(), frame_number);
  493. }
  494. video_frame->set_timestamp(reference_time - start_time_);
  495. video_frame_input_->InsertRawVideoFrame(video_frame, reference_time);
  496. }
  497. void RunTasks(base::TimeDelta sleep_delay) {
  498. task_runner_->Sleep(sleep_delay);
  499. }
  500. // Send and receive audio and video frames for the given |duration|. Returns
  501. // the total number of audio and video frames sent.
  502. std::pair<int, int> RunAudioVideoLoop(base::TimeDelta duration) {
  503. base::TimeTicks next_video_frame_at = testing_clock_.NowTicks();
  504. base::TimeTicks video_reference_time;
  505. int audio_frames_sent = 0;
  506. int video_frames_sent = 0;
  507. const base::TimeTicks end_time = testing_clock_.NowTicks() + duration;
  508. while (testing_clock_.NowTicks() < end_time) {
  509. // Opus introduces a tiny delay before the sinewave starts; so don't
  510. // examine the first audio frame's data receiver-side.
  511. const bool verify_audio_data =
  512. audio_frames_sent > 0 ||
  513. audio_sender_config_.codec == CODEC_AUDIO_PCM16;
  514. FeedAudioFrames(1, verify_audio_data);
  515. ++audio_frames_sent;
  516. const bool send_and_receive_a_video_frame =
  517. testing_clock_.NowTicks() >= next_video_frame_at;
  518. if (send_and_receive_a_video_frame) {
  519. video_reference_time = next_video_frame_at;
  520. next_video_frame_at += kFrameTimerInterval;
  521. test_receiver_video_callback_->AddExpectedResult(
  522. video_frames_sent, GetTestVideoFrameSize(),
  523. testing_clock_.NowTicks() + kTargetPlayoutDelay, true);
  524. SendVideoFrame(video_frames_sent, video_reference_time);
  525. ++video_frames_sent;
  526. }
  527. RunTasks(kAudioFrameDuration);
  528. RequestAudioFrames(1, verify_audio_data);
  529. if (send_and_receive_a_video_frame) {
  530. cast_receiver_->RequestDecodedVideoFrame(base::BindRepeating(
  531. &TestReceiverVideoCallback::CheckVideoFrame,
  532. test_receiver_video_callback_,
  533. video_sender_config_.codec != CODEC_VIDEO_FAKE));
  534. }
  535. }
  536. // Verify all audio and video frames were received.
  537. RunTasks(kFrameTimerInterval + kTargetPlayoutDelay);
  538. EXPECT_EQ(audio_frames_sent,
  539. test_receiver_audio_callback_->number_times_called());
  540. EXPECT_EQ(video_frames_sent,
  541. test_receiver_video_callback_->number_times_called());
  542. return std::make_pair(audio_frames_sent, video_frames_sent);
  543. }
  544. // Queries the EventSubscriber for all accumulated frame and packet events for
  545. // audio and video and verifies all logging information was captured
  546. // correctly.
  547. void VerifyLogging(int num_expected_audio_frames,
  548. int num_expected_video_frames) {
  549. // Partition the frame and packet events into separate vectors for audio
  550. // versus video.
  551. std::vector<FrameEvent> all_frame_events;
  552. event_subscriber_sender_.GetFrameEventsAndReset(&all_frame_events);
  553. std::vector<FrameEvent> audio_frame_events;
  554. std::vector<FrameEvent> video_frame_events;
  555. for (const FrameEvent& event : all_frame_events) {
  556. switch (event.media_type) {
  557. case AUDIO_EVENT:
  558. audio_frame_events.push_back(event);
  559. break;
  560. case VIDEO_EVENT:
  561. video_frame_events.push_back(event);
  562. break;
  563. default:
  564. FAIL();
  565. }
  566. }
  567. std::vector<PacketEvent> all_packet_events;
  568. event_subscriber_sender_.GetPacketEventsAndReset(&all_packet_events);
  569. std::vector<PacketEvent> audio_packet_events;
  570. std::vector<PacketEvent> video_packet_events;
  571. for (const PacketEvent& event : all_packet_events) {
  572. switch (event.media_type) {
  573. case AUDIO_EVENT:
  574. audio_packet_events.push_back(event);
  575. break;
  576. case VIDEO_EVENT:
  577. video_packet_events.push_back(event);
  578. break;
  579. default:
  580. FAIL();
  581. }
  582. }
  583. // For each frame, count the number of events that occurred for each event
  584. // for that frame.
  585. std::map<RtpTimeTicks, LoggingEventCounts> audio_event_counts_by_frame =
  586. GetEventCountsForFrameEvents(audio_frame_events);
  587. EXPECT_EQ(static_cast<size_t>(num_expected_audio_frames),
  588. audio_event_counts_by_frame.size());
  589. std::map<RtpTimeTicks, LoggingEventCounts> video_event_counts_by_frame =
  590. GetEventCountsForFrameEvents(video_frame_events);
  591. EXPECT_EQ(static_cast<size_t>(num_expected_video_frames),
  592. video_event_counts_by_frame.size());
  593. // Examine the types of each frame and packet event and verify required
  594. // events are present and unknown ones are not.
  595. VerifyLoggingEventCounts(audio_event_counts_by_frame,
  596. GetEventCountsForPacketEvents(audio_packet_events),
  597. true);
  598. VerifyLoggingEventCounts(video_event_counts_by_frame,
  599. GetEventCountsForPacketEvents(video_packet_events),
  600. false);
  601. }
  602. // Examines histograms of event types to verify all logging information was
  603. // captured correctly.
  604. static void VerifyLoggingEventCounts(
  605. const std::map<RtpTimeTicks, LoggingEventCounts>& event_counts_by_frame,
  606. const std::map<uint16_t, LoggingEventCounts>& event_counts_by_packet,
  607. bool for_audio) {
  608. // Verify that each frame has the expected types of events logged.
  609. for (const auto& e : event_counts_by_frame) {
  610. int total_event_count_for_frame = 0;
  611. for (int i = 0; i < kNumOfLoggingEvents; ++i) {
  612. total_event_count_for_frame += e.second.counter[i];
  613. }
  614. int count_of_valid_events = 0;
  615. if (!for_audio) {
  616. EXPECT_EQ(1, e.second.counter[FRAME_CAPTURE_BEGIN]);
  617. ++count_of_valid_events;
  618. EXPECT_EQ(1, e.second.counter[FRAME_CAPTURE_END]);
  619. ++count_of_valid_events;
  620. }
  621. EXPECT_EQ(1, e.second.counter[FRAME_ENCODED]);
  622. ++count_of_valid_events;
  623. EXPECT_EQ(1, e.second.counter[FRAME_DECODED]);
  624. ++count_of_valid_events;
  625. EXPECT_EQ(1, e.second.counter[FRAME_PLAYOUT]);
  626. ++count_of_valid_events;
  627. // There is no guarantee that FRAME_ACK_SENT is logged exactly once per
  628. // frame.
  629. EXPECT_GT(e.second.counter[FRAME_ACK_SENT], 0);
  630. count_of_valid_events += e.second.counter[FRAME_ACK_SENT];
  631. // There is no guarantee that FRAME_ACK_RECEIVED is logged exactly once
  632. // per frame.
  633. EXPECT_GT(e.second.counter[FRAME_ACK_RECEIVED], 0);
  634. count_of_valid_events += e.second.counter[FRAME_ACK_RECEIVED];
  635. // Verify that there were no unexpected events logged with respect to this
  636. // frame.
  637. EXPECT_EQ(count_of_valid_events, total_event_count_for_frame);
  638. }
  639. // Verify that each packet has the expected types of events logged.
  640. for (const auto& e : event_counts_by_packet) {
  641. int total_event_count_for_packet = 0;
  642. for (int i = 0; i < kNumOfLoggingEvents; ++i) {
  643. total_event_count_for_packet += e.second.counter[i];
  644. }
  645. EXPECT_GT(e.second.counter[PACKET_RECEIVED], 0);
  646. const int packets_received = e.second.counter[PACKET_RECEIVED];
  647. const int packets_sent = e.second.counter[PACKET_SENT_TO_NETWORK];
  648. EXPECT_EQ(packets_sent, packets_received);
  649. // Verify that there were no other events logged with respect to this
  650. // packet. An assumption here is that there was no packet loss nor
  651. // retransmits during the end-to-end run.
  652. EXPECT_EQ(packets_received + packets_sent, total_event_count_for_packet);
  653. }
  654. }
  655. void BasicPlayerGotVideoFrame(scoped_refptr<media::VideoFrame> video_frame,
  656. base::TimeTicks playout_time,
  657. bool continuous) {
  658. // The following tests that the sender and receiver clocks can be
  659. // out-of-sync, drift, and jitter with respect to one another; and depsite
  660. // this, the receiver will produce smoothly-progressing playout times.
  661. // Both first-order and second-order effects are tested.
  662. if (!last_video_playout_time_.is_null() &&
  663. min_video_playout_delta_.is_positive()) {
  664. const base::TimeDelta delta = playout_time - last_video_playout_time_;
  665. VLOG(1) << "Video frame playout time delta (compared to last frame) is "
  666. << delta.InMicroseconds() << " usec.";
  667. EXPECT_LE(min_video_playout_delta_.InMicroseconds(),
  668. delta.InMicroseconds());
  669. EXPECT_GE(max_video_playout_delta_.InMicroseconds(),
  670. delta.InMicroseconds());
  671. if (last_video_playout_delta_.is_positive()) {
  672. base::TimeDelta abs_curvature = delta - last_video_playout_delta_;
  673. if (abs_curvature.is_negative())
  674. abs_curvature = -abs_curvature;
  675. EXPECT_GE(max_video_playout_curvature_.InMicroseconds(),
  676. abs_curvature.InMicroseconds());
  677. }
  678. last_video_playout_delta_ = delta;
  679. }
  680. last_video_playout_time_ = playout_time;
  681. video_ticks_.push_back(
  682. std::make_pair(testing_clock_receiver_.NowTicks(), playout_time));
  683. cast_receiver_->RequestDecodedVideoFrame(base::BindRepeating(
  684. &End2EndTest::BasicPlayerGotVideoFrame, base::Unretained(this)));
  685. }
  686. void BasicPlayerGotAudioFrame(std::unique_ptr<AudioBus> audio_bus,
  687. base::TimeTicks playout_time,
  688. bool is_continuous) {
  689. VLOG_IF(1, !last_audio_playout_time_.is_null())
  690. << "Audio frame playout time delta (compared to last frame) is "
  691. << (playout_time - last_audio_playout_time_).InMicroseconds()
  692. << " usec.";
  693. last_audio_playout_time_ = playout_time;
  694. audio_ticks_.push_back(
  695. std::make_pair(testing_clock_receiver_.NowTicks(), playout_time));
  696. cast_receiver_->RequestDecodedAudioFrame(base::BindRepeating(
  697. &End2EndTest::BasicPlayerGotAudioFrame, base::Unretained(this)));
  698. }
  699. void StartBasicPlayer() {
  700. cast_receiver_->RequestDecodedVideoFrame(base::BindRepeating(
  701. &End2EndTest::BasicPlayerGotVideoFrame, base::Unretained(this)));
  702. cast_receiver_->RequestDecodedAudioFrame(base::BindRepeating(
  703. &End2EndTest::BasicPlayerGotAudioFrame, base::Unretained(this)));
  704. }
  705. FrameReceiverConfig audio_receiver_config_;
  706. FrameReceiverConfig video_receiver_config_;
  707. FrameSenderConfig audio_sender_config_;
  708. FrameSenderConfig video_sender_config_;
  709. base::TimeTicks start_time_;
  710. // These run in "test time"
  711. base::SimpleTestTickClock testing_clock_;
  712. scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
  713. // These run on the sender timeline.
  714. test::SkewedTickClock testing_clock_sender_;
  715. scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_;
  716. // These run on the receiver timeline.
  717. test::SkewedTickClock testing_clock_receiver_;
  718. scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_receiver_;
  719. base::TimeDelta min_video_playout_delta_;
  720. base::TimeDelta max_video_playout_delta_;
  721. base::TimeDelta max_video_playout_curvature_;
  722. base::TimeTicks last_video_playout_time_;
  723. base::TimeDelta last_video_playout_delta_;
  724. base::TimeTicks last_audio_playout_time_;
  725. scoped_refptr<CastEnvironment> cast_environment_sender_;
  726. scoped_refptr<CastEnvironment> cast_environment_receiver_;
  727. raw_ptr<LoopBackTransport> receiver_to_sender_; // Owned by CastTransport.
  728. raw_ptr<LoopBackTransport> sender_to_receiver_; // Owned by CastTransport.
  729. std::unique_ptr<CastTransportImpl> transport_sender_;
  730. std::unique_ptr<CastTransportImpl> transport_receiver_;
  731. std::unique_ptr<CastReceiver> cast_receiver_;
  732. std::unique_ptr<CastSender> cast_sender_;
  733. scoped_refptr<AudioFrameInput> audio_frame_input_;
  734. scoped_refptr<VideoFrameInput> video_frame_input_;
  735. scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
  736. scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
  737. std::unique_ptr<TestAudioBusFactory> audio_bus_factory_;
  738. SimpleEventSubscriber event_subscriber_sender_;
  739. std::vector<std::pair<base::TimeTicks, base::TimeTicks>> audio_ticks_;
  740. std::vector<std::pair<base::TimeTicks, base::TimeTicks>> video_ticks_;
  741. // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
  742. base::test::SingleThreadTaskEnvironment task_environment_;
  743. };
  744. namespace {
  745. class TransportClient : public CastTransport::Client {
  746. public:
  747. TransportClient(LogEventDispatcher* log_event_dispatcher,
  748. End2EndTest* e2e_test)
  749. : log_event_dispatcher_(log_event_dispatcher), e2e_test_(e2e_test) {}
  750. TransportClient(const TransportClient&) = delete;
  751. TransportClient& operator=(const TransportClient&) = delete;
  752. void OnStatusChanged(media::cast::CastTransportStatus status) final {
  753. EXPECT_EQ(TRANSPORT_STREAM_INITIALIZED, status);
  754. }
  755. void OnLoggingEventsReceived(
  756. std::unique_ptr<std::vector<FrameEvent>> frame_events,
  757. std::unique_ptr<std::vector<PacketEvent>> packet_events) final {
  758. log_event_dispatcher_->DispatchBatchOfEvents(std::move(frame_events),
  759. std::move(packet_events));
  760. }
  761. void ProcessRtpPacket(std::unique_ptr<Packet> packet) final {
  762. if (e2e_test_)
  763. e2e_test_->ReceivePacket(std::move(packet));
  764. }
  765. private:
  766. const raw_ptr<LogEventDispatcher>
  767. log_event_dispatcher_; // Not owned by this class.
  768. const raw_ptr<End2EndTest> e2e_test_; // Not owned by this class.
  769. };
  770. } // namespace
  771. void End2EndTest::Create() {
  772. transport_sender_ = std::make_unique<CastTransportImpl>(
  773. &testing_clock_sender_, base::Milliseconds(1),
  774. std::make_unique<TransportClient>(cast_environment_sender_->logger(),
  775. nullptr),
  776. base::WrapUnique(sender_to_receiver_.get()), task_runner_sender_);
  777. transport_receiver_ = std::make_unique<CastTransportImpl>(
  778. &testing_clock_sender_, base::Milliseconds(1),
  779. std::make_unique<TransportClient>(cast_environment_receiver_->logger(),
  780. this),
  781. base::WrapUnique(receiver_to_sender_.get()), task_runner_sender_);
  782. cast_receiver_ =
  783. CastReceiver::Create(cast_environment_receiver_, audio_receiver_config_,
  784. video_receiver_config_, transport_receiver_.get());
  785. cast_sender_ =
  786. CastSender::Create(cast_environment_sender_, transport_sender_.get());
  787. // Initializing audio and video senders.
  788. cast_sender_->InitializeAudio(
  789. audio_sender_config_, base::BindOnce(&ExpectSuccessOperationalStatus));
  790. cast_sender_->InitializeVideo(
  791. video_sender_config_,
  792. base::BindRepeating(&ExpectSuccessOperationalStatus), base::DoNothing());
  793. task_runner_->RunTasks();
  794. receiver_to_sender_->SetPacketReceiver(
  795. transport_sender_->PacketReceiverForTesting(), task_runner_,
  796. &testing_clock_);
  797. sender_to_receiver_->SetPacketReceiver(
  798. transport_receiver_->PacketReceiverForTesting(), task_runner_,
  799. &testing_clock_);
  800. audio_frame_input_ = cast_sender_->audio_frame_input();
  801. video_frame_input_ = cast_sender_->video_frame_input();
  802. audio_bus_factory_ = std::make_unique<TestAudioBusFactory>(
  803. audio_sender_config_.channels, audio_sender_config_.rtp_timebase,
  804. kSoundFrequency, kSoundVolume);
  805. }
  806. TEST_F(End2EndTest, LoopWithLosslessEncoding) {
  807. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  808. Create();
  809. const auto frames_sent = RunAudioVideoLoop(base::Seconds(3));
  810. // Make sure that we send a RTCP message containing receiver log data, then
  811. // verify the accumulated logging data.
  812. RunTasks(base::Milliseconds(750));
  813. VerifyLogging(frames_sent.first, frames_sent.second);
  814. }
  815. TEST_F(End2EndTest, LoopWithLossyEncoding) {
  816. Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS);
  817. Create();
  818. const auto frames_sent = RunAudioVideoLoop(base::Seconds(1));
  819. // Run tasks for 750 ms to ensure RTCP messages containing log data from the
  820. // receiver are sent and processed by the sender. Then, verify the expected
  821. // logging data is present.
  822. RunTasks(base::Milliseconds(750));
  823. VerifyLogging(frames_sent.first, frames_sent.second);
  824. }
  825. // This tests start sending audio and video at start-up time before the receiver
  826. // is ready; it sends 2 frames before the receiver comes online.
  827. //
  828. // Test disabled due to flakiness: It appears that the RTCP synchronization
  829. // sometimes kicks in, and sometimes doesn't. When it does, there's a sharp
  830. // discontinuity in the timeline, throwing off the test expectations. See TODOs
  831. // in audio_receiver.cc for likely cause(s) of this bug.
  832. // http://crbug.com/573126 (history: http://crbug.com/314233)
  833. TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
  834. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  835. Create();
  836. int frame_number = 0;
  837. int audio_diff = kFrameTimerInterval.InMilliseconds();
  838. sender_to_receiver_->SetSendPackets(false);
  839. constexpr base::TimeDelta kTestDelay = base::Milliseconds(100);
  840. const int kNumVideoFramesBeforeReceiverStarted = 2;
  841. const base::TimeTicks initial_send_time = testing_clock_sender_.NowTicks();
  842. const base::TimeDelta expected_delay = kTestDelay + kFrameTimerInterval;
  843. for (int i = 0; i < kNumVideoFramesBeforeReceiverStarted; ++i) {
  844. const int num_audio_frames =
  845. audio_diff / kAudioFrameDuration.InMilliseconds();
  846. audio_diff -= num_audio_frames * kAudioFrameDuration.InMilliseconds();
  847. if (num_audio_frames > 0)
  848. FeedAudioFramesWithExpectedDelay(1, expected_delay);
  849. // Frame will be rendered with 100mS delay, as the transmission is delayed.
  850. // The receiver at this point cannot be synced to the sender's clock, as no
  851. // packets, and specifically no RTCP packets were sent.
  852. test_receiver_video_callback_->AddExpectedResult(
  853. frame_number, GetTestVideoFrameSize(),
  854. initial_send_time + expected_delay + kTargetPlayoutDelay, true);
  855. SendVideoFrame(frame_number++, testing_clock_sender_.NowTicks());
  856. if (num_audio_frames > 0)
  857. RunTasks(kAudioFrameDuration);
  858. if (num_audio_frames > 1)
  859. FeedAudioFramesWithExpectedDelay(num_audio_frames - 1, expected_delay);
  860. RunTasks(kFrameTimerInterval - kAudioFrameDuration);
  861. audio_diff += kFrameTimerInterval.InMilliseconds();
  862. }
  863. RunTasks(kTestDelay);
  864. sender_to_receiver_->SetSendPackets(true);
  865. int num_audio_frames_requested = 0;
  866. for (int j = 0; j < 10; ++j) {
  867. const int num_audio_frames =
  868. audio_diff / kAudioFrameDuration.InMilliseconds();
  869. audio_diff -= num_audio_frames * kAudioFrameDuration.InMilliseconds();
  870. if (num_audio_frames > 0)
  871. FeedAudioFrames(1, true);
  872. test_receiver_video_callback_->AddExpectedResult(
  873. frame_number, GetTestVideoFrameSize(),
  874. testing_clock_sender_.NowTicks() + kTargetPlayoutDelay, true);
  875. SendVideoFrame(frame_number++, testing_clock_sender_.NowTicks());
  876. if (num_audio_frames > 0)
  877. RunTasks(kAudioFrameDuration);
  878. if (num_audio_frames > 1)
  879. FeedAudioFrames(num_audio_frames - 1, true);
  880. RequestAudioFrames(num_audio_frames, true);
  881. num_audio_frames_requested += num_audio_frames;
  882. cast_receiver_->RequestDecodedVideoFrame(
  883. base::BindRepeating(&TestReceiverVideoCallback::CheckVideoFrame,
  884. test_receiver_video_callback_,
  885. video_sender_config_.codec != CODEC_VIDEO_FAKE));
  886. RunTasks(kFrameTimerInterval - kAudioFrameDuration);
  887. audio_diff += kFrameTimerInterval.InMilliseconds();
  888. }
  889. RunTasks(2 * kFrameTimerInterval +
  890. base::Milliseconds(1)); // Empty the receiver pipeline.
  891. EXPECT_EQ(num_audio_frames_requested,
  892. test_receiver_audio_callback_->number_times_called());
  893. EXPECT_EQ(10, test_receiver_video_callback_->number_times_called());
  894. }
  895. TEST_F(End2EndTest, BasicFakeSoftwareVideo) {
  896. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  897. Create();
  898. StartBasicPlayer();
  899. SetReceiverSkew(1.0, base::Milliseconds(1));
  900. // Expect very smooth playout when there is no clock skew.
  901. SetExpectedVideoPlayoutSmoothness(kFrameTimerInterval * 99 / 100,
  902. kFrameTimerInterval * 101 / 100,
  903. kFrameTimerInterval / 100);
  904. int frames_counter = 0;
  905. for (; frames_counter < 30; ++frames_counter) {
  906. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  907. RunTasks(kFrameTimerInterval);
  908. }
  909. RunTasks(2 * kFrameTimerInterval +
  910. base::Milliseconds(1)); // Empty the pipeline.
  911. EXPECT_EQ(30ul, video_ticks_.size());
  912. }
  913. // The following tests run many many iterations to make sure that buffers don't
  914. // fill, timers don't go askew etc. However, these high-level tests are too
  915. // expensive when running under sanitizers, or in non-optimized debug builds.
  916. // In these cases, we reduce the number of iterations.
  917. #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
  918. defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
  919. defined(UNDEFINED_SANITIZER)
  920. const int kLongTestIterations = 500; // http://crbug.com/487033
  921. #elif defined(NDEBUG)
  922. const int kLongTestIterations = 10000;
  923. #else
  924. const int kLongTestIterations = 1000;
  925. #endif
  926. TEST_F(End2EndTest, ReceiverClockFast) {
  927. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  928. Create();
  929. StartBasicPlayer();
  930. SetReceiverSkew(2.0, base::Microseconds(1234567));
  931. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  932. ++frames_counter) {
  933. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  934. RunTasks(kFrameTimerInterval);
  935. }
  936. RunTasks(2 * kFrameTimerInterval +
  937. base::Milliseconds(1)); // Empty the pipeline.
  938. EXPECT_EQ(static_cast<size_t>(kLongTestIterations), video_ticks_.size());
  939. }
  940. TEST_F(End2EndTest, ReceiverClockSlow) {
  941. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  942. Create();
  943. StartBasicPlayer();
  944. SetReceiverSkew(0.5, base::Microseconds(-765432));
  945. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  946. ++frames_counter) {
  947. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  948. RunTasks(kFrameTimerInterval);
  949. }
  950. RunTasks(2 * kFrameTimerInterval +
  951. base::Milliseconds(1)); // Empty the pipeline.
  952. EXPECT_EQ(static_cast<size_t>(kLongTestIterations), video_ticks_.size());
  953. }
  954. TEST_F(End2EndTest, SmoothPlayoutWithFivePercentClockRateSkew) {
  955. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  956. Create();
  957. StartBasicPlayer();
  958. SetReceiverSkew(1.05, base::Milliseconds(-42));
  959. // Expect smooth playout when there is 5% skew.
  960. SetExpectedVideoPlayoutSmoothness(kFrameTimerInterval * 90 / 100,
  961. kFrameTimerInterval * 110 / 100,
  962. kFrameTimerInterval / 10);
  963. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  964. ++frames_counter) {
  965. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  966. RunTasks(kFrameTimerInterval);
  967. }
  968. RunTasks(2 * kFrameTimerInterval +
  969. base::Milliseconds(1)); // Empty the pipeline.
  970. EXPECT_EQ(static_cast<size_t>(kLongTestIterations), video_ticks_.size());
  971. }
  972. TEST_F(End2EndTest, EvilNetwork) {
  973. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  974. receiver_to_sender_->SetPacketPipe(test::EvilNetwork());
  975. sender_to_receiver_->SetPacketPipe(test::EvilNetwork());
  976. Create();
  977. StartBasicPlayer();
  978. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  979. ++frames_counter) {
  980. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  981. RunTasks(kFrameTimerInterval);
  982. }
  983. base::TimeTicks test_end = testing_clock_receiver_.NowTicks();
  984. RunTasks(100 * kFrameTimerInterval +
  985. base::Milliseconds(1)); // Empty the pipeline.
  986. EXPECT_LT(static_cast<size_t>(kLongTestIterations / 100),
  987. video_ticks_.size());
  988. VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
  989. EXPECT_GT(1000, (video_ticks_.back().second - test_end).InMilliseconds());
  990. }
  991. // Tests that a system configured for 30 FPS drops frames when input is provided
  992. // at a much higher frame rate.
  993. TEST_F(End2EndTest, ShoveHighFrameRateDownYerThroat) {
  994. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  995. receiver_to_sender_->SetPacketPipe(test::EvilNetwork());
  996. sender_to_receiver_->SetPacketPipe(test::EvilNetwork());
  997. Create();
  998. StartBasicPlayer();
  999. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  1000. ++frames_counter) {
  1001. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  1002. RunTasks(base::Milliseconds(10) /* 10 ms, but 33.3 expected by system */);
  1003. }
  1004. base::TimeTicks test_end = testing_clock_receiver_.NowTicks();
  1005. RunTasks(100 * kFrameTimerInterval +
  1006. base::Milliseconds(1)); // Empty the pipeline.
  1007. EXPECT_LT(static_cast<size_t>(kLongTestIterations / 100),
  1008. video_ticks_.size());
  1009. #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
  1010. defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
  1011. defined(UNDEFINED_SANITIZER)
  1012. // We want to ensure that at least one frame is dropped on ASAN builds.
  1013. const size_t max_iterations = kLongTestIterations - 1;
  1014. #else
  1015. // Otherwise ensure that at least half of the frames are dropped.
  1016. const size_t max_iterations = kLongTestIterations / 2;
  1017. #endif
  1018. EXPECT_GE(max_iterations, video_ticks_.size());
  1019. VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
  1020. EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
  1021. }
  1022. TEST_F(End2EndTest, OldPacketNetwork) {
  1023. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  1024. sender_to_receiver_->SetPacketPipe(test::NewRandomDrop(0.01));
  1025. std::unique_ptr<test::PacketPipe> echo_chamber(
  1026. test::NewDuplicateAndDelay(1, 10 * kFrameTimerInterval.InMilliseconds()));
  1027. echo_chamber->AppendToPipe(
  1028. test::NewDuplicateAndDelay(1, 20 * kFrameTimerInterval.InMilliseconds()));
  1029. echo_chamber->AppendToPipe(
  1030. test::NewDuplicateAndDelay(1, 40 * kFrameTimerInterval.InMilliseconds()));
  1031. echo_chamber->AppendToPipe(
  1032. test::NewDuplicateAndDelay(1, 80 * kFrameTimerInterval.InMilliseconds()));
  1033. echo_chamber->AppendToPipe(test::NewDuplicateAndDelay(
  1034. 1, 160 * kFrameTimerInterval.InMilliseconds()));
  1035. receiver_to_sender_->SetPacketPipe(std::move(echo_chamber));
  1036. Create();
  1037. StartBasicPlayer();
  1038. SetExpectedVideoPlayoutSmoothness(kFrameTimerInterval * 90 / 100,
  1039. kFrameTimerInterval * 110 / 100,
  1040. kFrameTimerInterval / 10);
  1041. for (int frames_counter = 0; frames_counter < kLongTestIterations;
  1042. ++frames_counter) {
  1043. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  1044. RunTasks(kFrameTimerInterval);
  1045. }
  1046. RunTasks(100 * kFrameTimerInterval +
  1047. base::Milliseconds(1)); // Empty the pipeline.
  1048. EXPECT_EQ(static_cast<size_t>(kLongTestIterations), video_ticks_.size());
  1049. }
  1050. TEST_F(End2EndTest, TestSetPlayoutDelay) {
  1051. Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
  1052. video_sender_config_.min_playout_delay =
  1053. video_sender_config_.max_playout_delay;
  1054. audio_sender_config_.min_playout_delay =
  1055. audio_sender_config_.max_playout_delay;
  1056. video_sender_config_.max_playout_delay = base::Seconds(1);
  1057. audio_sender_config_.max_playout_delay = base::Seconds(1);
  1058. Create();
  1059. StartBasicPlayer();
  1060. constexpr base::TimeDelta kNewDelay = base::Milliseconds(600);
  1061. int frames_counter = 0;
  1062. for (; frames_counter < 50; ++frames_counter) {
  1063. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  1064. RunTasks(kFrameTimerInterval);
  1065. }
  1066. cast_sender_->SetTargetPlayoutDelay(kNewDelay);
  1067. for (; frames_counter < 100; ++frames_counter) {
  1068. SendVideoFrame(frames_counter, testing_clock_sender_.NowTicks());
  1069. RunTasks(kFrameTimerInterval);
  1070. }
  1071. RunTasks(100 * kFrameTimerInterval +
  1072. base::Milliseconds(1)); // Empty the pipeline.
  1073. size_t jump = 0;
  1074. for (size_t i = 1; i < video_ticks_.size(); i++) {
  1075. const base::TimeDelta delta =
  1076. video_ticks_[i].second - video_ticks_[i - 1].second;
  1077. if (delta.InMilliseconds() > 100) {
  1078. EXPECT_EQ(kNewDelay - kTargetPlayoutDelay + kFrameTimerInterval, delta);
  1079. EXPECT_EQ(0u, jump);
  1080. jump = i;
  1081. }
  1082. }
  1083. EXPECT_GT(jump, 49u);
  1084. EXPECT_LT(jump, 120u);
  1085. }
  1086. } // namespace cast
  1087. } // namespace media
  1088. #undef CAST_E2E_TEST