OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
43 EXPECT_TRUE_WAIT((r).num_rendered_frames() >= (c) && \ | 43 EXPECT_TRUE_WAIT((r).num_rendered_frames() >= (c) && \ |
44 (w) == (r).width() && \ | 44 (w) == (r).width() && \ |
45 (h) == (r).height(), (t)); \ | 45 (h) == (r).height(), (t)); \ |
46 EXPECT_EQ(0, (r).errors()); | 46 EXPECT_EQ(0, (r).errors()); |
47 | 47 |
48 static const uint32_t kTimeout = 5000U; | 48 static const uint32_t kTimeout = 5000U; |
49 static const uint32_t kDefaultReceiveSsrc = 0; | 49 static const uint32_t kDefaultReceiveSsrc = 0; |
50 static const uint32_t kSsrc = 1234u; | 50 static const uint32_t kSsrc = 1234u; |
51 static const uint32_t kRtxSsrc = 4321u; | 51 static const uint32_t kRtxSsrc = 4321u; |
52 static const uint32_t kSsrcs4[] = {1, 2, 3, 4}; | 52 static const uint32_t kSsrcs4[] = {1, 2, 3, 4}; |
53 | 53 static const int kVideoWidth = 640; |
54 inline bool IsEqualRes(const cricket::VideoCodec& a, int w, int h, int fps) { | 54 static const int kVideoHeight = 360; |
55 return a.width == w && a.height == h && a.framerate == fps; | 55 static const int kFramerate = 30; |
56 } | |
57 | 56 |
58 inline bool IsEqualCodec(const cricket::VideoCodec& a, | 57 inline bool IsEqualCodec(const cricket::VideoCodec& a, |
59 const cricket::VideoCodec& b) { | 58 const cricket::VideoCodec& b) { |
60 return a.id == b.id && a.name == b.name && | 59 return a.id == b.id && a.name == b.name; |
61 IsEqualRes(a, b.width, b.height, b.framerate); | |
62 } | 60 } |
63 | 61 |
64 namespace std { | 62 namespace std { |
65 inline std::ostream& operator<<(std::ostream& s, const cricket::VideoCodec& c) { | 63 inline std::ostream& operator<<(std::ostream& s, const cricket::VideoCodec& c) { |
66 s << "{" << c.name << "(" << c.id << "), " | 64 s << "{" << c.name << "(" << c.id << ")" |
67 << c.width << "x" << c.height << "x" << c.framerate << "}"; | 65 << "}"; |
68 return s; | 66 return s; |
69 } | 67 } |
70 } // namespace std | 68 } // namespace std |
71 | 69 |
72 inline int TimeBetweenSend(const cricket::VideoCodec& codec) { | |
73 return static_cast<int>( | |
74 cricket::VideoFormat::FpsToInterval(codec.framerate) / | |
75 rtc::kNumNanosecsPerMillisec); | |
76 } | |
77 | |
78 template<class E, class C> | 70 template<class E, class C> |
79 class VideoMediaChannelTest : public testing::Test, | 71 class VideoMediaChannelTest : public testing::Test, |
80 public sigslot::has_slots<> { | 72 public sigslot::has_slots<> { |
81 protected: | 73 protected: |
82 VideoMediaChannelTest<E, C>() | 74 VideoMediaChannelTest<E, C>() |
83 : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))) {} | 75 : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))) {} |
84 | 76 |
85 virtual cricket::VideoCodec DefaultCodec() = 0; | 77 virtual cricket::VideoCodec DefaultCodec() = 0; |
86 | 78 |
87 virtual cricket::StreamParams DefaultSendStreamParams() { | 79 virtual cricket::StreamParams DefaultSendStreamParams() { |
88 return cricket::StreamParams::CreateLegacy(kSsrc); | 80 return cricket::StreamParams::CreateLegacy(kSsrc); |
89 } | 81 } |
90 | 82 |
91 virtual void SetUp() { | 83 virtual void SetUp() { |
92 engine_.Init(); | 84 engine_.Init(); |
93 channel_.reset(engine_.CreateChannel(call_.get(), cricket::MediaConfig(), | 85 channel_.reset(engine_.CreateChannel(call_.get(), cricket::MediaConfig(), |
94 cricket::VideoOptions())); | 86 cricket::VideoOptions())); |
95 EXPECT_TRUE(channel_.get() != NULL); | 87 EXPECT_TRUE(channel_.get() != NULL); |
96 network_interface_.SetDestination(channel_.get()); | 88 network_interface_.SetDestination(channel_.get()); |
97 channel_->SetInterface(&network_interface_); | 89 channel_->SetInterface(&network_interface_); |
98 media_error_ = cricket::VideoMediaChannel::ERROR_NONE; | 90 media_error_ = cricket::VideoMediaChannel::ERROR_NONE; |
99 cricket::VideoRecvParameters parameters; | 91 cricket::VideoRecvParameters parameters; |
100 parameters.codecs = engine_.codecs(); | 92 parameters.codecs = engine_.codecs(); |
101 channel_->SetRecvParameters(parameters); | 93 channel_->SetRecvParameters(parameters); |
102 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams())); | 94 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams())); |
103 video_capturer_.reset(CreateFakeVideoCapturer()); | 95 video_capturer_.reset(CreateFakeVideoCapturer()); |
104 cricket::VideoFormat format(640, 480, | 96 cricket::VideoFormat format(640, 480, |
105 cricket::VideoFormat::FpsToInterval(30), | 97 cricket::VideoFormat::FpsToInterval(kFramerate), |
106 cricket::FOURCC_I420); | 98 cricket::FOURCC_I420); |
107 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format)); | 99 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format)); |
108 EXPECT_TRUE( | 100 EXPECT_TRUE( |
109 channel_->SetVideoSend(kSsrc, true, nullptr, video_capturer_.get())); | 101 channel_->SetVideoSend(kSsrc, true, nullptr, video_capturer_.get())); |
110 } | 102 } |
111 | 103 |
112 virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() { | 104 virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() { |
113 return new cricket::FakeVideoCapturer(); | 105 return new cricket::FakeVideoCapturer(); |
114 } | 106 } |
115 | 107 |
(...skipping 16 matching lines...) Expand all Loading... |
132 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); | 124 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); |
133 EXPECT_FALSE(channel_->AddSendStream( | 125 EXPECT_FALSE(channel_->AddSendStream( |
134 cricket::StreamParams::CreateLegacy(kSsrc))); | 126 cricket::StreamParams::CreateLegacy(kSsrc))); |
135 EXPECT_TRUE(channel_->AddSendStream( | 127 EXPECT_TRUE(channel_->AddSendStream( |
136 cricket::StreamParams::CreateLegacy(kSsrc + 2))); | 128 cricket::StreamParams::CreateLegacy(kSsrc + 2))); |
137 // We dont add recv for the second stream. | 129 // We dont add recv for the second stream. |
138 | 130 |
139 // Setup the receive and renderer for second stream after send. | 131 // Setup the receive and renderer for second stream after send. |
140 video_capturer_2_.reset(CreateFakeVideoCapturer()); | 132 video_capturer_2_.reset(CreateFakeVideoCapturer()); |
141 cricket::VideoFormat format(640, 480, | 133 cricket::VideoFormat format(640, 480, |
142 cricket::VideoFormat::FpsToInterval(30), | 134 cricket::VideoFormat::FpsToInterval(kFramerate), |
143 cricket::FOURCC_I420); | 135 cricket::FOURCC_I420); |
144 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(format)); | 136 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(format)); |
145 | 137 |
146 EXPECT_TRUE(channel_->SetVideoSend(kSsrc + 2, true, nullptr, | 138 EXPECT_TRUE(channel_->SetVideoSend(kSsrc + 2, true, nullptr, |
147 video_capturer_2_.get())); | 139 video_capturer_2_.get())); |
148 } | 140 } |
149 virtual void TearDown() { | 141 virtual void TearDown() { |
150 channel_.reset(); | 142 channel_.reset(); |
151 } | 143 } |
152 bool SetDefaultCodec() { | 144 bool SetDefaultCodec() { |
153 return SetOneCodec(DefaultCodec()); | 145 return SetOneCodec(DefaultCodec()); |
154 } | 146 } |
155 | 147 |
156 bool SetOneCodec(int pt, const char* name, int w, int h, int fr) { | 148 bool SetOneCodec(int pt, const char* name) { |
157 return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr)); | 149 return SetOneCodec(cricket::VideoCodec(pt, name)); |
158 } | 150 } |
159 bool SetOneCodec(const cricket::VideoCodec& codec) { | 151 bool SetOneCodec(const cricket::VideoCodec& codec) { |
160 cricket::VideoFormat capture_format(codec.width, codec.height, | 152 cricket::VideoFormat capture_format( |
161 cricket::VideoFormat::FpsToInterval(codec.framerate), | 153 kVideoWidth, kVideoHeight, |
162 cricket::FOURCC_I420); | 154 cricket::VideoFormat::FpsToInterval(kFramerate), cricket::FOURCC_I420); |
163 | 155 |
164 if (video_capturer_) { | 156 if (video_capturer_) { |
165 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format)); | 157 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format)); |
166 } | 158 } |
167 if (video_capturer_2_) { | 159 if (video_capturer_2_) { |
168 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format)); | 160 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format)); |
169 } | 161 } |
170 | 162 |
171 bool sending = channel_->sending(); | 163 bool sending = channel_->sending(); |
172 bool success = SetSend(false); | 164 bool success = SetSend(false); |
(...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
389 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); | 381 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); |
390 EXPECT_EQ(codec.id, GetPayloadType(p.get())); | 382 EXPECT_EQ(codec.id, GetPayloadType(p.get())); |
391 } | 383 } |
392 // Tests that we can send and receive frames. | 384 // Tests that we can send and receive frames. |
393 void SendAndReceive(const cricket::VideoCodec& codec) { | 385 void SendAndReceive(const cricket::VideoCodec& codec) { |
394 EXPECT_TRUE(SetOneCodec(codec)); | 386 EXPECT_TRUE(SetOneCodec(codec)); |
395 EXPECT_TRUE(SetSend(true)); | 387 EXPECT_TRUE(SetSend(true)); |
396 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 388 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
397 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 389 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
398 EXPECT_TRUE(SendFrame()); | 390 EXPECT_TRUE(SendFrame()); |
399 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); | 391 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
400 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); | 392 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); |
401 EXPECT_EQ(codec.id, GetPayloadType(p.get())); | 393 EXPECT_EQ(codec.id, GetPayloadType(p.get())); |
402 } | 394 } |
403 void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec, | 395 void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec, |
404 int duration_sec, int fps) { | 396 int duration_sec, int fps) { |
405 EXPECT_TRUE(SetOneCodec(codec)); | 397 EXPECT_TRUE(SetOneCodec(codec)); |
406 EXPECT_TRUE(SetSend(true)); | 398 EXPECT_TRUE(SetSend(true)); |
407 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 399 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
408 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 400 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
409 for (int i = 0; i < duration_sec; ++i) { | 401 for (int i = 0; i < duration_sec; ++i) { |
410 for (int frame = 1; frame <= fps; ++frame) { | 402 for (int frame = 1; frame <= fps; ++frame) { |
411 EXPECT_TRUE(WaitAndSendFrame(1000 / fps)); | 403 EXPECT_TRUE(WaitAndSendFrame(1000 / fps)); |
412 EXPECT_FRAME_WAIT(frame + i * fps, codec.width, codec.height, kTimeout); | 404 EXPECT_FRAME_WAIT(frame + i * fps, kVideoWidth, kVideoHeight, kTimeout); |
413 } | 405 } |
414 } | 406 } |
415 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); | 407 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); |
416 EXPECT_EQ(codec.id, GetPayloadType(p.get())); | 408 EXPECT_EQ(codec.id, GetPayloadType(p.get())); |
417 } | 409 } |
418 | 410 |
419 // Test that stats work properly for a 1-1 call. | 411 // Test that stats work properly for a 1-1 call. |
420 void GetStats() { | 412 void GetStats() { |
421 const int kDurationSec = 3; | 413 const int kDurationSec = 3; |
422 const int kFps = 10; | 414 const int kFps = 10; |
423 SendReceiveManyAndGetStats(DefaultCodec(), kDurationSec, kFps); | 415 SendReceiveManyAndGetStats(DefaultCodec(), kDurationSec, kFps); |
424 | 416 |
425 cricket::VideoMediaInfo info; | 417 cricket::VideoMediaInfo info; |
426 EXPECT_TRUE(channel_->GetStats(&info)); | 418 EXPECT_TRUE(channel_->GetStats(&info)); |
427 | 419 |
428 ASSERT_EQ(1U, info.senders.size()); | 420 ASSERT_EQ(1U, info.senders.size()); |
429 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload? | 421 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload? |
430 // For webrtc, bytes_sent does not include the RTP header length. | 422 // For webrtc, bytes_sent does not include the RTP header length. |
431 EXPECT_GT(info.senders[0].bytes_sent, 0); | 423 EXPECT_GT(info.senders[0].bytes_sent, 0); |
432 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent); | 424 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent); |
433 EXPECT_EQ(0.0, info.senders[0].fraction_lost); | 425 EXPECT_EQ(0.0, info.senders[0].fraction_lost); |
434 EXPECT_EQ(0, info.senders[0].firs_rcvd); | 426 EXPECT_EQ(0, info.senders[0].firs_rcvd); |
435 EXPECT_EQ(0, info.senders[0].plis_rcvd); | 427 EXPECT_EQ(0, info.senders[0].plis_rcvd); |
436 EXPECT_EQ(0, info.senders[0].nacks_rcvd); | 428 EXPECT_EQ(0, info.senders[0].nacks_rcvd); |
437 EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width); | 429 EXPECT_EQ(kVideoWidth, info.senders[0].send_frame_width); |
438 EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height); | 430 EXPECT_EQ(kVideoHeight, info.senders[0].send_frame_height); |
439 EXPECT_GT(info.senders[0].framerate_input, 0); | 431 EXPECT_GT(info.senders[0].framerate_input, 0); |
440 EXPECT_GT(info.senders[0].framerate_sent, 0); | 432 EXPECT_GT(info.senders[0].framerate_sent, 0); |
441 | 433 |
442 ASSERT_EQ(1U, info.receivers.size()); | 434 ASSERT_EQ(1U, info.receivers.size()); |
443 EXPECT_EQ(1U, info.senders[0].ssrcs().size()); | 435 EXPECT_EQ(1U, info.senders[0].ssrcs().size()); |
444 EXPECT_EQ(1U, info.receivers[0].ssrcs().size()); | 436 EXPECT_EQ(1U, info.receivers[0].ssrcs().size()); |
445 EXPECT_EQ(info.senders[0].ssrcs()[0], info.receivers[0].ssrcs()[0]); | 437 EXPECT_EQ(info.senders[0].ssrcs()[0], info.receivers[0].ssrcs()[0]); |
446 EXPECT_EQ(NumRtpBytes(), info.receivers[0].bytes_rcvd); | 438 EXPECT_EQ(NumRtpBytes(), info.receivers[0].bytes_rcvd); |
447 EXPECT_EQ(NumRtpPackets(), info.receivers[0].packets_rcvd); | 439 EXPECT_EQ(NumRtpPackets(), info.receivers[0].packets_rcvd); |
448 EXPECT_EQ(0.0, info.receivers[0].fraction_lost); | 440 EXPECT_EQ(0.0, info.receivers[0].fraction_lost); |
449 EXPECT_EQ(0, info.receivers[0].packets_lost); | 441 EXPECT_EQ(0, info.receivers[0].packets_lost); |
450 // TODO(asapersson): Not set for webrtc. Handle missing stats. | 442 // TODO(asapersson): Not set for webrtc. Handle missing stats. |
451 // EXPECT_EQ(0, info.receivers[0].packets_concealed); | 443 // EXPECT_EQ(0, info.receivers[0].packets_concealed); |
452 EXPECT_EQ(0, info.receivers[0].firs_sent); | 444 EXPECT_EQ(0, info.receivers[0].firs_sent); |
453 EXPECT_EQ(0, info.receivers[0].plis_sent); | 445 EXPECT_EQ(0, info.receivers[0].plis_sent); |
454 EXPECT_EQ(0, info.receivers[0].nacks_sent); | 446 EXPECT_EQ(0, info.receivers[0].nacks_sent); |
455 EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width); | 447 EXPECT_EQ(kVideoWidth, info.receivers[0].frame_width); |
456 EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height); | 448 EXPECT_EQ(kVideoHeight, info.receivers[0].frame_height); |
457 EXPECT_GT(info.receivers[0].framerate_rcvd, 0); | 449 EXPECT_GT(info.receivers[0].framerate_rcvd, 0); |
458 EXPECT_GT(info.receivers[0].framerate_decoded, 0); | 450 EXPECT_GT(info.receivers[0].framerate_decoded, 0); |
459 EXPECT_GT(info.receivers[0].framerate_output, 0); | 451 EXPECT_GT(info.receivers[0].framerate_output, 0); |
460 } | 452 } |
461 | 453 |
462 cricket::VideoSenderInfo GetSenderStats(size_t i) { | 454 cricket::VideoSenderInfo GetSenderStats(size_t i) { |
463 cricket::VideoMediaInfo info; | 455 cricket::VideoMediaInfo info; |
464 EXPECT_TRUE(channel_->GetStats(&info)); | 456 EXPECT_TRUE(channel_->GetStats(&info)); |
465 return info.senders[i]; | 457 return info.senders[i]; |
466 } | 458 } |
(...skipping 19 matching lines...) Expand all Loading... |
486 cricket::StreamParams::CreateLegacy(2))); | 478 cricket::StreamParams::CreateLegacy(2))); |
487 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); | 479 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); |
488 EXPECT_TRUE(channel_->SetSink(2, &renderer2)); | 480 EXPECT_TRUE(channel_->SetSink(2, &renderer2)); |
489 EXPECT_EQ(0, renderer1.num_rendered_frames()); | 481 EXPECT_EQ(0, renderer1.num_rendered_frames()); |
490 EXPECT_EQ(0, renderer2.num_rendered_frames()); | 482 EXPECT_EQ(0, renderer2.num_rendered_frames()); |
491 std::vector<uint32_t> ssrcs; | 483 std::vector<uint32_t> ssrcs; |
492 ssrcs.push_back(1); | 484 ssrcs.push_back(1); |
493 ssrcs.push_back(2); | 485 ssrcs.push_back(2); |
494 network_interface_.SetConferenceMode(true, ssrcs); | 486 network_interface_.SetConferenceMode(true, ssrcs); |
495 EXPECT_TRUE(SendFrame()); | 487 EXPECT_TRUE(SendFrame()); |
496 EXPECT_FRAME_ON_RENDERER_WAIT( | 488 EXPECT_FRAME_ON_RENDERER_WAIT(renderer1, 1, kVideoWidth, kVideoHeight, |
497 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 489 kTimeout); |
498 EXPECT_FRAME_ON_RENDERER_WAIT( | 490 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kVideoWidth, kVideoHeight, |
499 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 491 kTimeout); |
500 | 492 |
501 EXPECT_TRUE(channel_->SetSend(false)); | 493 EXPECT_TRUE(channel_->SetSend(false)); |
502 | 494 |
503 cricket::VideoMediaInfo info; | 495 cricket::VideoMediaInfo info; |
504 EXPECT_TRUE(channel_->GetStats(&info)); | 496 EXPECT_TRUE(channel_->GetStats(&info)); |
505 ASSERT_EQ(1U, info.senders.size()); | 497 ASSERT_EQ(1U, info.senders.size()); |
506 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload? | 498 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload? |
507 // For webrtc, bytes_sent does not include the RTP header length. | 499 // For webrtc, bytes_sent does not include the RTP header length. |
508 EXPECT_GT(GetSenderStats(0).bytes_sent, 0); | 500 EXPECT_GT(GetSenderStats(0).bytes_sent, 0); |
509 EXPECT_EQ_WAIT(NumRtpPackets(), GetSenderStats(0).packets_sent, kTimeout); | 501 EXPECT_EQ_WAIT(NumRtpPackets(), GetSenderStats(0).packets_sent, kTimeout); |
510 EXPECT_EQ(DefaultCodec().width, GetSenderStats(0).send_frame_width); | 502 EXPECT_EQ(kVideoWidth, GetSenderStats(0).send_frame_width); |
511 EXPECT_EQ(DefaultCodec().height, GetSenderStats(0).send_frame_height); | 503 EXPECT_EQ(kVideoHeight, GetSenderStats(0).send_frame_height); |
512 | 504 |
513 ASSERT_EQ(2U, info.receivers.size()); | 505 ASSERT_EQ(2U, info.receivers.size()); |
514 for (size_t i = 0; i < info.receivers.size(); ++i) { | 506 for (size_t i = 0; i < info.receivers.size(); ++i) { |
515 EXPECT_EQ(1U, GetReceiverStats(i).ssrcs().size()); | 507 EXPECT_EQ(1U, GetReceiverStats(i).ssrcs().size()); |
516 EXPECT_EQ(i + 1, GetReceiverStats(i).ssrcs()[0]); | 508 EXPECT_EQ(i + 1, GetReceiverStats(i).ssrcs()[0]); |
517 EXPECT_EQ_WAIT(NumRtpBytes(), GetReceiverStats(i).bytes_rcvd, kTimeout); | 509 EXPECT_EQ_WAIT(NumRtpBytes(), GetReceiverStats(i).bytes_rcvd, kTimeout); |
518 EXPECT_EQ_WAIT(NumRtpPackets(), GetReceiverStats(i).packets_rcvd, | 510 EXPECT_EQ_WAIT(NumRtpPackets(), GetReceiverStats(i).packets_rcvd, |
519 kTimeout); | 511 kTimeout); |
520 EXPECT_EQ_WAIT(DefaultCodec().width, GetReceiverStats(i).frame_width, | 512 EXPECT_EQ_WAIT(kVideoWidth, GetReceiverStats(i).frame_width, kTimeout); |
521 kTimeout); | 513 EXPECT_EQ_WAIT(kVideoHeight, GetReceiverStats(i).frame_height, kTimeout); |
522 EXPECT_EQ_WAIT(DefaultCodec().height, GetReceiverStats(i).frame_height, | |
523 kTimeout); | |
524 } | 514 } |
525 } | 515 } |
526 // Test that stats work properly for a conf call with multiple send streams. | 516 // Test that stats work properly for a conf call with multiple send streams. |
527 void GetStatsMultipleSendStreams() { | 517 void GetStatsMultipleSendStreams() { |
528 // Normal setup; note that we set the SSRC explicitly to ensure that | 518 // Normal setup; note that we set the SSRC explicitly to ensure that |
529 // it will come first in the senders map. | 519 // it will come first in the senders map. |
530 EXPECT_TRUE(SetOneCodec(DefaultCodec())); | 520 EXPECT_TRUE(SetOneCodec(DefaultCodec())); |
531 cricket::VideoSendParameters parameters; | 521 cricket::VideoSendParameters parameters; |
532 parameters.codecs.push_back(DefaultCodec()); | 522 parameters.codecs.push_back(DefaultCodec()); |
533 parameters.conference_mode = true; | 523 parameters.conference_mode = true; |
534 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 524 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
535 EXPECT_TRUE(channel_->AddRecvStream( | 525 EXPECT_TRUE(channel_->AddRecvStream( |
536 cricket::StreamParams::CreateLegacy(kSsrc))); | 526 cricket::StreamParams::CreateLegacy(kSsrc))); |
537 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); | 527 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); |
538 EXPECT_TRUE(SetSend(true)); | 528 EXPECT_TRUE(SetSend(true)); |
539 EXPECT_TRUE(SendFrame()); | 529 EXPECT_TRUE(SendFrame()); |
540 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); | 530 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); |
541 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 531 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
542 | 532 |
543 // Add an additional capturer, and hook up a renderer to receive it. | 533 // Add an additional capturer, and hook up a renderer to receive it. |
544 cricket::FakeVideoRenderer renderer2; | 534 cricket::FakeVideoRenderer renderer2; |
545 std::unique_ptr<cricket::FakeVideoCapturer> capturer( | 535 std::unique_ptr<cricket::FakeVideoCapturer> capturer( |
546 CreateFakeVideoCapturer()); | 536 CreateFakeVideoCapturer()); |
547 const int kTestWidth = 160; | 537 const int kTestWidth = 160; |
548 const int kTestHeight = 120; | 538 const int kTestHeight = 120; |
549 cricket::VideoFormat format(kTestWidth, kTestHeight, | 539 cricket::VideoFormat format(kTestWidth, kTestHeight, |
550 cricket::VideoFormat::FpsToInterval(5), | 540 cricket::VideoFormat::FpsToInterval(5), |
551 cricket::FOURCC_I420); | 541 cricket::FOURCC_I420); |
(...skipping 22 matching lines...) Expand all Loading... |
574 // Stats have been updated for both sent frames, expectations can be | 564 // Stats have been updated for both sent frames, expectations can be |
575 // checked now. | 565 // checked now. |
576 break; | 566 break; |
577 } | 567 } |
578 } | 568 } |
579 EXPECT_EQ(NumRtpPackets(), | 569 EXPECT_EQ(NumRtpPackets(), |
580 info.senders[0].packets_sent + info.senders[1].packets_sent) | 570 info.senders[0].packets_sent + info.senders[1].packets_sent) |
581 << "Timed out while waiting for packet counts for all sent packets."; | 571 << "Timed out while waiting for packet counts for all sent packets."; |
582 EXPECT_EQ(1U, info.senders[0].ssrcs().size()); | 572 EXPECT_EQ(1U, info.senders[0].ssrcs().size()); |
583 EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]); | 573 EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]); |
584 EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width); | 574 EXPECT_EQ(kVideoWidth, info.senders[0].send_frame_width); |
585 EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height); | 575 EXPECT_EQ(kVideoHeight, info.senders[0].send_frame_height); |
586 EXPECT_EQ(1U, info.senders[1].ssrcs().size()); | 576 EXPECT_EQ(1U, info.senders[1].ssrcs().size()); |
587 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]); | 577 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]); |
588 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width); | 578 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width); |
589 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height); | 579 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height); |
590 // The capturer must be unregistered here as it runs out of it's scope next. | 580 // The capturer must be unregistered here as it runs out of it's scope next. |
591 channel_->SetVideoSend(5678, true, nullptr, nullptr); | 581 channel_->SetVideoSend(5678, true, nullptr, nullptr); |
592 } | 582 } |
593 | 583 |
594 // Test that we can set the bandwidth. | 584 // Test that we can set the bandwidth. |
595 void SetSendBandwidth() { | 585 void SetSendBandwidth() { |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
650 | 640 |
651 rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1)); | 641 rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1)); |
652 rtc::SetBE32(packet1.data() + 8, kSsrc); | 642 rtc::SetBE32(packet1.data() + 8, kSsrc); |
653 channel_->SetSink(kDefaultReceiveSsrc, NULL); | 643 channel_->SetSink(kDefaultReceiveSsrc, NULL); |
654 EXPECT_TRUE(SetDefaultCodec()); | 644 EXPECT_TRUE(SetDefaultCodec()); |
655 EXPECT_TRUE(SetSend(true)); | 645 EXPECT_TRUE(SetSend(true)); |
656 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 646 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
657 channel_->OnPacketReceived(&packet1, rtc::PacketTime()); | 647 channel_->OnPacketReceived(&packet1, rtc::PacketTime()); |
658 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 648 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
659 EXPECT_TRUE(SendFrame()); | 649 EXPECT_TRUE(SendFrame()); |
660 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 650 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
661 } | 651 } |
662 | 652 |
663 // Tests empty StreamParams is rejected. | 653 // Tests empty StreamParams is rejected. |
664 void RejectEmptyStreamParams() { | 654 void RejectEmptyStreamParams() { |
665 // Remove the send stream that was added during Setup. | 655 // Remove the send stream that was added during Setup. |
666 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); | 656 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); |
667 | 657 |
668 cricket::StreamParams empty; | 658 cricket::StreamParams empty; |
669 EXPECT_FALSE(channel_->AddSendStream(empty)); | 659 EXPECT_FALSE(channel_->AddSendStream(empty)); |
670 EXPECT_TRUE(channel_->AddSendStream( | 660 EXPECT_TRUE(channel_->AddSendStream( |
671 cricket::StreamParams::CreateLegacy(789u))); | 661 cricket::StreamParams::CreateLegacy(789u))); |
672 } | 662 } |
673 | 663 |
674 // Tests setting up and configuring a send stream. | 664 // Tests setting up and configuring a send stream. |
675 void AddRemoveSendStreams() { | 665 void AddRemoveSendStreams() { |
676 EXPECT_TRUE(SetOneCodec(DefaultCodec())); | 666 EXPECT_TRUE(SetOneCodec(DefaultCodec())); |
677 EXPECT_TRUE(SetSend(true)); | 667 EXPECT_TRUE(SetSend(true)); |
678 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 668 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
679 EXPECT_TRUE(SendFrame()); | 669 EXPECT_TRUE(SendFrame()); |
680 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 670 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
681 EXPECT_GT(NumRtpPackets(), 0); | 671 EXPECT_GT(NumRtpPackets(), 0); |
682 uint32_t ssrc = 0; | 672 uint32_t ssrc = 0; |
683 size_t last_packet = NumRtpPackets() - 1; | 673 size_t last_packet = NumRtpPackets() - 1; |
684 std::unique_ptr<const rtc::CopyOnWriteBuffer> | 674 std::unique_ptr<const rtc::CopyOnWriteBuffer> |
685 p(GetRtpPacket(static_cast<int>(last_packet))); | 675 p(GetRtpPacket(static_cast<int>(last_packet))); |
686 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL); | 676 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL); |
687 EXPECT_EQ(kSsrc, ssrc); | 677 EXPECT_EQ(kSsrc, ssrc); |
688 | 678 |
689 // Remove the send stream that was added during Setup. | 679 // Remove the send stream that was added during Setup. |
690 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); | 680 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); |
(...skipping 29 matching lines...) Expand all Loading... |
720 cricket::StreamParams::CreateLegacy(2))); | 710 cricket::StreamParams::CreateLegacy(2))); |
721 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); | 711 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); |
722 EXPECT_TRUE(channel_->SetSink(2, &renderer2)); | 712 EXPECT_TRUE(channel_->SetSink(2, &renderer2)); |
723 EXPECT_EQ(0, renderer1.num_rendered_frames()); | 713 EXPECT_EQ(0, renderer1.num_rendered_frames()); |
724 EXPECT_EQ(0, renderer2.num_rendered_frames()); | 714 EXPECT_EQ(0, renderer2.num_rendered_frames()); |
725 std::vector<uint32_t> ssrcs; | 715 std::vector<uint32_t> ssrcs; |
726 ssrcs.push_back(1); | 716 ssrcs.push_back(1); |
727 ssrcs.push_back(2); | 717 ssrcs.push_back(2); |
728 network_interface_.SetConferenceMode(true, ssrcs); | 718 network_interface_.SetConferenceMode(true, ssrcs); |
729 EXPECT_TRUE(SendFrame()); | 719 EXPECT_TRUE(SendFrame()); |
730 EXPECT_FRAME_ON_RENDERER_WAIT( | 720 EXPECT_FRAME_ON_RENDERER_WAIT(renderer1, 1, kVideoWidth, kVideoHeight, |
731 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 721 kTimeout); |
732 EXPECT_FRAME_ON_RENDERER_WAIT( | 722 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kVideoWidth, kVideoHeight, |
733 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 723 kTimeout); |
734 | 724 |
735 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); | 725 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); |
736 EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get())); | 726 EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get())); |
737 EXPECT_EQ(DefaultCodec().width, renderer1.width()); | 727 EXPECT_EQ(kVideoWidth, renderer1.width()); |
738 EXPECT_EQ(DefaultCodec().height, renderer1.height()); | 728 EXPECT_EQ(kVideoHeight, renderer1.height()); |
739 EXPECT_EQ(DefaultCodec().width, renderer2.width()); | 729 EXPECT_EQ(kVideoWidth, renderer2.width()); |
740 EXPECT_EQ(DefaultCodec().height, renderer2.height()); | 730 EXPECT_EQ(kVideoHeight, renderer2.height()); |
741 EXPECT_TRUE(channel_->RemoveRecvStream(2)); | 731 EXPECT_TRUE(channel_->RemoveRecvStream(2)); |
742 EXPECT_TRUE(channel_->RemoveRecvStream(1)); | 732 EXPECT_TRUE(channel_->RemoveRecvStream(1)); |
743 } | 733 } |
744 | 734 |
745 // Tests that we can add and remove capturers and frames are sent out properly | 735 // Tests that we can add and remove capturers and frames are sent out properly |
746 void AddRemoveCapturer() { | 736 void AddRemoveCapturer() { |
747 cricket::VideoCodec codec = DefaultCodec(); | 737 cricket::VideoCodec codec = DefaultCodec(); |
748 codec.width = 320; | 738 const int time_between_send_ms = |
749 codec.height = 240; | 739 cricket::VideoFormat::FpsToInterval(kFramerate); |
750 const int time_between_send = TimeBetweenSend(codec); | |
751 EXPECT_TRUE(SetOneCodec(codec)); | 740 EXPECT_TRUE(SetOneCodec(codec)); |
752 EXPECT_TRUE(SetSend(true)); | 741 EXPECT_TRUE(SetSend(true)); |
753 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 742 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
754 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 743 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
755 EXPECT_TRUE(SendFrame()); | 744 EXPECT_TRUE(SendFrame()); |
756 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); | 745 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
757 std::unique_ptr<cricket::FakeVideoCapturer> capturer( | 746 std::unique_ptr<cricket::FakeVideoCapturer> capturer( |
758 CreateFakeVideoCapturer()); | 747 CreateFakeVideoCapturer()); |
759 | 748 |
760 // TODO(nisse): This testcase fails if we don't configure | 749 // TODO(nisse): This testcase fails if we don't configure |
761 // screencast. It's unclear why, I see nothing obvious in this | 750 // screencast. It's unclear why, I see nothing obvious in this |
762 // test which is related to screencast logic. | 751 // test which is related to screencast logic. |
763 cricket::VideoOptions video_options; | 752 cricket::VideoOptions video_options; |
764 video_options.is_screencast = rtc::Optional<bool>(true); | 753 video_options.is_screencast = rtc::Optional<bool>(true); |
765 channel_->SetVideoSend(kSsrc, true, &video_options, nullptr); | 754 channel_->SetVideoSend(kSsrc, true, &video_options, nullptr); |
766 | 755 |
767 cricket::VideoFormat format(480, 360, | 756 cricket::VideoFormat format(480, 360, |
768 cricket::VideoFormat::FpsToInterval(30), | 757 cricket::VideoFormat::FpsToInterval(30), |
769 cricket::FOURCC_I420); | 758 cricket::FOURCC_I420); |
770 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format)); | 759 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format)); |
771 // All capturers start generating frames with the same timestamp. ViE does | 760 // All capturers start generating frames with the same timestamp. ViE does |
772 // not allow the same timestamp to be used. Capture one frame before | 761 // not allow the same timestamp to be used. Capture one frame before |
773 // associating the capturer with the channel. | 762 // associating the capturer with the channel. |
774 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height, | 763 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height, |
775 cricket::FOURCC_I420)); | 764 cricket::FOURCC_I420)); |
776 | 765 |
777 int captured_frames = 1; | 766 int captured_frames = 1; |
778 for (int iterations = 0; iterations < 2; ++iterations) { | 767 for (int iterations = 0; iterations < 2; ++iterations) { |
779 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, capturer.get())); | 768 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, capturer.get())); |
780 rtc::Thread::Current()->ProcessMessages(time_between_send); | 769 rtc::Thread::Current()->ProcessMessages(time_between_send_ms); |
781 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height, | 770 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height, |
782 cricket::FOURCC_I420)); | 771 cricket::FOURCC_I420)); |
783 ++captured_frames; | 772 ++captured_frames; |
784 // Wait until frame of right size is captured. | 773 // Wait until frame of right size is captured. |
785 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames && | 774 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames && |
786 format.width == renderer_.width() && | 775 format.width == renderer_.width() && |
787 format.height == renderer_.height() && | 776 format.height == renderer_.height() && |
788 !renderer_.black_frame(), kTimeout); | 777 !renderer_.black_frame(), kTimeout); |
789 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames); | 778 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames); |
790 EXPECT_EQ(format.width, renderer_.width()); | 779 EXPECT_EQ(format.width, renderer_.width()); |
(...skipping 24 matching lines...) Expand all Loading... |
815 | 804 |
816 // Tests that if SetVideoSend is called with a NULL capturer after the | 805 // Tests that if SetVideoSend is called with a NULL capturer after the |
817 // capturer was already removed, the application doesn't crash (and no black | 806 // capturer was already removed, the application doesn't crash (and no black |
818 // frame is sent). | 807 // frame is sent). |
819 void RemoveCapturerWithoutAdd() { | 808 void RemoveCapturerWithoutAdd() { |
820 EXPECT_TRUE(SetOneCodec(DefaultCodec())); | 809 EXPECT_TRUE(SetOneCodec(DefaultCodec())); |
821 EXPECT_TRUE(SetSend(true)); | 810 EXPECT_TRUE(SetSend(true)); |
822 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | 811 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); |
823 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 812 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
824 EXPECT_TRUE(SendFrame()); | 813 EXPECT_TRUE(SendFrame()); |
825 EXPECT_FRAME_WAIT(1, 640, 400, kTimeout); | 814 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); |
826 // Wait for one frame so they don't get dropped because we send frames too | 815 // Wait for one frame so they don't get dropped because we send frames too |
827 // tightly. | 816 // tightly. |
828 rtc::Thread::Current()->ProcessMessages(30); | 817 rtc::Thread::Current()->ProcessMessages(30); |
829 // Remove the capturer. | 818 // Remove the capturer. |
830 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); | 819 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); |
831 // Wait for one black frame for removing the capturer. | 820 // Wait for one black frame for removing the capturer. |
832 EXPECT_FRAME_WAIT(2, 640, 400, kTimeout); | 821 EXPECT_FRAME_WAIT(2, kVideoWidth, kVideoHeight, kTimeout); |
833 | 822 |
834 // No capturer was added, so this SetVideoSend shouldn't do anything. | 823 // No capturer was added, so this SetVideoSend shouldn't do anything. |
835 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); | 824 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); |
836 rtc::Thread::Current()->ProcessMessages(300); | 825 rtc::Thread::Current()->ProcessMessages(300); |
837 // Verify no more frames were sent. | 826 // Verify no more frames were sent. |
838 EXPECT_EQ(2, renderer_.num_rendered_frames()); | 827 EXPECT_EQ(2, renderer_.num_rendered_frames()); |
839 } | 828 } |
840 | 829 |
841 // Tests that we can add and remove capturer as unique sources. | 830 // Tests that we can add and remove capturer as unique sources. |
842 void AddRemoveCapturerMultipleSources() { | 831 void AddRemoveCapturerMultipleSources() { |
843 // WebRTC implementation will drop frames if pushed to quickly. Wait the | 832 // WebRTC implementation will drop frames if pushed to quickly. Wait the |
844 // interval time to avoid that. | 833 // interval time to avoid that. |
845 // WebRTC implementation will drop frames if pushed to quickly. Wait the | 834 // WebRTC implementation will drop frames if pushed to quickly. Wait the |
846 // interval time to avoid that. | 835 // interval time to avoid that. |
847 // Set up the stream associated with the engine. | 836 // Set up the stream associated with the engine. |
848 EXPECT_TRUE(channel_->AddRecvStream( | 837 EXPECT_TRUE(channel_->AddRecvStream( |
849 cricket::StreamParams::CreateLegacy(kSsrc))); | 838 cricket::StreamParams::CreateLegacy(kSsrc))); |
850 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); | 839 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); |
851 cricket::VideoFormat capture_format; // default format | 840 cricket::VideoFormat capture_format; // default format |
852 capture_format.interval = cricket::VideoFormat::FpsToInterval(30); | 841 capture_format.interval = cricket::VideoFormat::FpsToInterval(kFramerate); |
853 // Set up additional stream 1. | 842 // Set up additional stream 1. |
854 cricket::FakeVideoRenderer renderer1; | 843 cricket::FakeVideoRenderer renderer1; |
855 EXPECT_FALSE(channel_->SetSink(1, &renderer1)); | 844 EXPECT_FALSE(channel_->SetSink(1, &renderer1)); |
856 EXPECT_TRUE(channel_->AddRecvStream( | 845 EXPECT_TRUE(channel_->AddRecvStream( |
857 cricket::StreamParams::CreateLegacy(1))); | 846 cricket::StreamParams::CreateLegacy(1))); |
858 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); | 847 EXPECT_TRUE(channel_->SetSink(1, &renderer1)); |
859 EXPECT_TRUE(channel_->AddSendStream( | 848 EXPECT_TRUE(channel_->AddSendStream( |
860 cricket::StreamParams::CreateLegacy(1))); | 849 cricket::StreamParams::CreateLegacy(1))); |
861 std::unique_ptr<cricket::FakeVideoCapturer> capturer1( | 850 std::unique_ptr<cricket::FakeVideoCapturer> capturer1( |
862 CreateFakeVideoCapturer()); | 851 CreateFakeVideoCapturer()); |
(...skipping 30 matching lines...) Expand all Loading... |
893 EXPECT_FRAME_ON_RENDERER_WAIT( | 882 EXPECT_FRAME_ON_RENDERER_WAIT( |
894 renderer2, 1, kTestWidth, kTestHeight, kTimeout); | 883 renderer2, 1, kTestWidth, kTestHeight, kTimeout); |
895 // Successfully remove the capturer. | 884 // Successfully remove the capturer. |
896 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); | 885 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); |
897 // The capturers must be unregistered here as it runs out of it's scope | 886 // The capturers must be unregistered here as it runs out of it's scope |
898 // next. | 887 // next. |
899 EXPECT_TRUE(channel_->SetVideoSend(1, true, nullptr, nullptr)); | 888 EXPECT_TRUE(channel_->SetVideoSend(1, true, nullptr, nullptr)); |
900 EXPECT_TRUE(channel_->SetVideoSend(2, true, nullptr, nullptr)); | 889 EXPECT_TRUE(channel_->SetVideoSend(2, true, nullptr, nullptr)); |
901 } | 890 } |
902 | 891 |
903 void HighAspectHighHeightCapturer() { | |
904 const int kWidth = 80; | |
905 const int kHeight = 10000; | |
906 const int kScaledWidth = 20; | |
907 const int kScaledHeight = 2500; | |
908 | |
909 cricket::VideoCodec codec(DefaultCodec()); | |
910 EXPECT_TRUE(SetOneCodec(codec)); | |
911 EXPECT_TRUE(SetSend(true)); | |
912 | |
913 cricket::FakeVideoRenderer renderer; | |
914 EXPECT_TRUE(channel_->AddRecvStream( | |
915 cricket::StreamParams::CreateLegacy(kSsrc))); | |
916 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer)); | |
917 EXPECT_EQ(0, renderer.num_rendered_frames()); | |
918 | |
919 EXPECT_TRUE(SendFrame()); | |
920 EXPECT_GT_FRAME_ON_RENDERER_WAIT( | |
921 renderer, 1, codec.width, codec.height, kTimeout); | |
922 | |
923 // Registering an external capturer is currently the same as screen casting | |
924 // (update the test when this changes). | |
925 std::unique_ptr<cricket::FakeVideoCapturer> capturer( | |
926 CreateFakeVideoCapturer()); | |
927 const std::vector<cricket::VideoFormat>* formats = | |
928 capturer->GetSupportedFormats(); | |
929 cricket::VideoFormat capture_format = (*formats)[0]; | |
930 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(capture_format)); | |
931 // Capture frame to not get same frame timestamps as previous capturer. | |
932 capturer->CaptureFrame(); | |
933 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, capturer.get())); | |
934 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30)); | |
935 EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight, | |
936 cricket::FOURCC_ARGB)); | |
937 EXPECT_GT_FRAME_ON_RENDERER_WAIT( | |
938 renderer, 2, kScaledWidth, kScaledHeight, kTimeout); | |
939 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); | |
940 } | |
941 | |
942 // Tests that we can adapt video resolution with 16:10 aspect ratio properly. | |
943 void AdaptResolution16x10() { | |
944 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | |
945 cricket::VideoCodec codec(DefaultCodec()); | |
946 codec.width = 640; | |
947 codec.height = 400; | |
948 SendAndReceive(codec); | |
949 codec.width /= 2; | |
950 codec.height /= 2; | |
951 // Adapt the resolution. | |
952 EXPECT_TRUE(SetOneCodec(codec)); | |
953 EXPECT_TRUE(WaitAndSendFrame(30)); | |
954 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout); | |
955 } | |
956 // Tests that we can adapt video resolution with 4:3 aspect ratio properly. | |
957 void AdaptResolution4x3() { | |
958 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | |
959 cricket::VideoCodec codec(DefaultCodec()); | |
960 codec.width = 640; | |
961 codec.height = 400; | |
962 SendAndReceive(codec); | |
963 codec.width /= 2; | |
964 codec.height /= 2; | |
965 // Adapt the resolution. | |
966 EXPECT_TRUE(SetOneCodec(codec)); | |
967 EXPECT_TRUE(WaitAndSendFrame(30)); | |
968 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout); | |
969 } | |
970 // Tests that we can drop all frames properly. | |
971 void AdaptDropAllFrames() { | |
972 // Set the channel codec's resolution to 0, which will require the adapter | |
973 // to drop all frames. | |
974 cricket::VideoCodec codec(DefaultCodec()); | |
975 codec.width = codec.height = codec.framerate = 0; | |
976 EXPECT_TRUE(SetOneCodec(codec)); | |
977 EXPECT_TRUE(SetSend(true)); | |
978 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | |
979 EXPECT_EQ(0, renderer_.num_rendered_frames()); | |
980 EXPECT_TRUE(SendFrame()); | |
981 EXPECT_TRUE(SendFrame()); | |
982 rtc::Thread::Current()->ProcessMessages(500); | |
983 EXPECT_EQ(0, renderer_.num_rendered_frames()); | |
984 } | |
985 // Tests that we can reduce the frame rate on demand properly. | |
986 // TODO(fbarchard): This test is flakey on pulse. Fix and re-enable | |
987 void AdaptFramerate() { | |
988 cricket::VideoCodec codec(DefaultCodec()); | |
989 int frame_count = 0; | |
990 // The capturer runs at 30 fps. The channel requires 30 fps. | |
991 EXPECT_TRUE(SetOneCodec(codec)); | |
992 EXPECT_TRUE(SetSend(true)); | |
993 EXPECT_EQ(frame_count, renderer_.num_rendered_frames()); | |
994 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered. | |
995 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered. | |
996 frame_count += 2; | |
997 EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout); | |
998 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0)); | |
999 EXPECT_EQ(codec.id, GetPayloadType(p.get())); | |
1000 | |
1001 // The channel requires 15 fps. | |
1002 codec.framerate = 15; | |
1003 EXPECT_TRUE(SetOneCodec(codec)); | |
1004 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered. | |
1005 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped. | |
1006 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered. | |
1007 frame_count += 2; | |
1008 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout); | |
1009 | |
1010 // The channel requires 10 fps. | |
1011 codec.framerate = 10; | |
1012 EXPECT_TRUE(SetOneCodec(codec)); | |
1013 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered. | |
1014 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped. | |
1015 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped. | |
1016 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered. | |
1017 frame_count += 2; | |
1018 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout); | |
1019 | |
1020 // The channel requires 8 fps. The adapter adapts to 10 fps, which is the | |
1021 // closest factor of 30. | |
1022 codec.framerate = 8; | |
1023 EXPECT_TRUE(SetOneCodec(codec)); | |
1024 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered. | |
1025 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped. | |
1026 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped. | |
1027 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered. | |
1028 frame_count += 2; | |
1029 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout); | |
1030 } | |
1031 // Tests that adapted frames won't be upscaled to a higher resolution. | |
1032 void SendsLowerResolutionOnSmallerFrames() { | |
1033 cricket::VideoCodec codec = DefaultCodec(); | |
1034 codec.width = 320; | |
1035 codec.height = 240; | |
1036 EXPECT_TRUE(SetOneCodec(codec)); | |
1037 EXPECT_TRUE(SetSend(true)); | |
1038 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); | |
1039 EXPECT_EQ(0, renderer_.num_rendered_frames()); | |
1040 EXPECT_TRUE(SendFrame()); | |
1041 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); | |
1042 | |
1043 // Check that we send smaller frames at the new resolution. | |
1044 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(33)); | |
1045 EXPECT_TRUE(video_capturer_->CaptureCustomFrame( | |
1046 codec.width / 2, codec.height / 2, cricket::FOURCC_I420)); | |
1047 EXPECT_FRAME_WAIT(2, codec.width / 2, codec.height / 2, kTimeout); | |
1048 } | |
1049 | |
1050 // Test that multiple send streams can be created and deleted properly. | 892 // Test that multiple send streams can be created and deleted properly. |
1051 void MultipleSendStreams() { | 893 void MultipleSendStreams() { |
1052 // Remove stream added in Setup. I.e. remove stream corresponding to default | 894 // Remove stream added in Setup. I.e. remove stream corresponding to default |
1053 // channel. | 895 // channel. |
1054 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); | 896 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); |
1055 const unsigned int kSsrcsSize = sizeof(kSsrcs4)/sizeof(kSsrcs4[0]); | 897 const unsigned int kSsrcsSize = sizeof(kSsrcs4)/sizeof(kSsrcs4[0]); |
1056 for (unsigned int i = 0; i < kSsrcsSize; ++i) { | 898 for (unsigned int i = 0; i < kSsrcsSize; ++i) { |
1057 EXPECT_TRUE(channel_->AddSendStream( | 899 EXPECT_TRUE(channel_->AddSendStream( |
1058 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); | 900 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); |
1059 } | 901 } |
(...skipping 25 matching lines...) Expand all Loading... |
1085 std::unique_ptr<C> channel_; | 927 std::unique_ptr<C> channel_; |
1086 cricket::FakeNetworkInterface network_interface_; | 928 cricket::FakeNetworkInterface network_interface_; |
1087 cricket::FakeVideoRenderer renderer_; | 929 cricket::FakeVideoRenderer renderer_; |
1088 cricket::VideoMediaChannel::Error media_error_; | 930 cricket::VideoMediaChannel::Error media_error_; |
1089 | 931 |
1090 // Used by test cases where 2 streams are run on the same channel. | 932 // Used by test cases where 2 streams are run on the same channel. |
1091 cricket::FakeVideoRenderer renderer2_; | 933 cricket::FakeVideoRenderer renderer2_; |
1092 }; | 934 }; |
1093 | 935 |
1094 #endif // WEBRTC_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT | 936 #endif // WEBRTC_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT |
OLD | NEW |