2 // Copyright 2004 Google Inc. All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
7 // 1. Redistributions of source code must retain the above copyright notice,
8 // this list of conditions and the following disclaimer.
9 // 2. Redistributions in binary form must reproduce the above copyright notice,
10 // this list of conditions and the following disclaimer in the documentation
11 // and/or other materials provided with the distribution.
12 // 3. The name of the author may not be used to endorse or promote products
13 // derived from this software without specific prior written permission.
15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #ifndef TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ // NOLINT
27 #define TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_
32 #include "talk/base/bytebuffer.h"
33 #include "talk/base/gunit.h"
34 #include "talk/base/timeutils.h"
35 #include "talk/media/base/fakenetworkinterface.h"
36 #include "talk/media/base/fakevideocapturer.h"
37 #include "talk/media/base/fakevideorenderer.h"
38 #include "talk/media/base/mediachannel.h"
39 #include "talk/media/base/streamparams.h"
42 #include <objbase.h> // NOLINT
45 #define EXPECT_FRAME_WAIT(c, w, h, t) \
46 EXPECT_EQ_WAIT((c), renderer_.num_rendered_frames(), (t)); \
47 EXPECT_EQ((w), renderer_.width()); \
48 EXPECT_EQ((h), renderer_.height()); \
49 EXPECT_EQ(0, renderer_.errors()); \
51 #define EXPECT_FRAME_ON_RENDERER_WAIT(r, c, w, h, t) \
52 EXPECT_EQ_WAIT((c), (r).num_rendered_frames(), (t)); \
53 EXPECT_EQ((w), (r).width()); \
54 EXPECT_EQ((h), (r).height()); \
55 EXPECT_EQ(0, (r).errors()); \
57 #define EXPECT_GT_FRAME_ON_RENDERER_WAIT(r, c, w, h, t) \
58 EXPECT_TRUE_WAIT((r).num_rendered_frames() >= (c) && \
59 (w) == (r).width() && \
60 (h) == (r).height(), (t)); \
61 EXPECT_EQ(0, (r).errors()); \
63 static const uint32 kTimeout = 5000U;
64 static const uint32 kSsrc = 1234u;
65 static const uint32 kRtxSsrc = 4321u;
66 static const uint32 kSsrcs4[] = {1, 2, 3, 4};
68 inline bool IsEqualRes(const cricket::VideoCodec& a, int w, int h, int fps) {
69 return a.width == w && a.height == h && a.framerate == fps;
72 inline bool IsEqualCodec(const cricket::VideoCodec& a,
73 const cricket::VideoCodec& b) {
74 return a.id == b.id && a.name == b.name &&
75 IsEqualRes(a, b.width, b.height, b.framerate);
79 inline std::ostream& operator<<(std::ostream& s, const cricket::VideoCodec& c) {
80 s << "{" << c.name << "(" << c.id << "), "
81 << c.width << "x" << c.height << "x" << c.framerate << "}";
86 inline int TimeBetweenSend(const cricket::VideoCodec& codec) {
87 return static_cast<int>(
88 cricket::VideoFormat::FpsToInterval(codec.framerate) /
89 talk_base::kNumNanosecsPerMillisec);
92 // Fake video engine that makes it possible to test enabling and disabling
93 // capturer (checking that the engine state is updated and that the capturer
94 // is indeed capturing) without having to create a channel. It also makes it
95 // possible to test that the media processors are indeed being called when
98 class VideoEngineOverride : public T {
100 VideoEngineOverride() {
102 virtual ~VideoEngineOverride() {
104 bool is_camera_on() const { return T::GetVideoCapturer()->IsRunning(); }
105 void set_has_senders(bool has_senders) {
106 cricket::VideoCapturer* video_capturer = T::GetVideoCapturer();
108 video_capturer->SignalVideoFrame.connect(this,
109 &VideoEngineOverride<T>::OnLocalFrame);
111 video_capturer->SignalVideoFrame.disconnect(this);
114 void OnLocalFrame(cricket::VideoCapturer*,
115 const cricket::VideoFrame*) {
117 void OnLocalFrameFormat(cricket::VideoCapturer*,
118 const cricket::VideoFormat*) {
121 void TriggerMediaFrame(
122 uint32 ssrc, cricket::VideoFrame* frame, bool* drop_frame) {
123 T::SignalMediaFrame(ssrc, frame, drop_frame);
127 // Macroes that declare test functions for a given test class, before and after
129 // To use, define a test function called FooBody and pass Foo to the macro.
130 #define TEST_PRE_VIDEOENGINE_INIT(TestClass, func) \
131 TEST_F(TestClass, func##PreInit) { \
134 #define TEST_POST_VIDEOENGINE_INIT(TestClass, func) \
135 TEST_F(TestClass, func##PostInit) { \
136 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current())); \
138 engine_.Terminate(); \
142 class VideoEngineTest : public testing::Test {
144 // Tests starting and stopping the engine, and creating a channel.
145 void StartupShutdown() {
146 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
147 cricket::VideoMediaChannel* channel = engine_.CreateChannel(NULL);
148 EXPECT_TRUE(channel != NULL);
154 // Tests that the COM reference count is not munged by the engine.
155 // Test to make sure LMI does not munge the CoInitialize reference count.
156 void CheckCoInitialize() {
157 // Initial refcount should be 0.
158 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
160 // Engine should start even with COM already inited.
161 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
163 // Refcount after terminate should be 1; this tests if it is nonzero.
164 EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED));
165 // Decrement refcount to (hopefully) 0.
169 // Ensure refcount is 0.
170 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
175 void ConstrainNewCodecBody() {
176 cricket::VideoCodec empty, in, out;
177 cricket::VideoCodec max_settings(engine_.codecs()[0].id,
178 engine_.codecs()[0].name,
181 // set max settings of 1280x960x30
182 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
183 cricket::VideoEncoderConfig(max_settings)));
185 // don't constrain the max resolution
187 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
188 EXPECT_PRED2(IsEqualCodec, out, in);
190 // constrain resolution greater than the max and wider aspect,
191 // picking best aspect (16:10)
194 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
195 EXPECT_PRED4(IsEqualRes, out, 1280, 720, 30);
197 // constrain resolution greater than the max and narrow aspect,
198 // picking best aspect (16:9)
201 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
202 EXPECT_PRED4(IsEqualRes, out, 1280, 720, 30);
204 // constrain resolution greater than the max, picking equal aspect (4:3)
207 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
208 EXPECT_PRED4(IsEqualRes, out, 1280, 800, 30);
210 // constrain resolution greater than the max, picking equal aspect (16:10)
213 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
214 EXPECT_PRED4(IsEqualRes, out, 1280, 800, 30);
216 // reduce max settings to 640x480x30
217 max_settings.width = 640;
218 max_settings.height = 480;
219 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
220 cricket::VideoEncoderConfig(max_settings)));
222 // don't constrain the max resolution
226 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
227 EXPECT_PRED2(IsEqualCodec, out, in);
229 // keep 16:10 if they request it
231 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
232 EXPECT_PRED2(IsEqualCodec, out, in);
234 // don't constrain lesser 4:3 resolutions
237 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
238 EXPECT_PRED2(IsEqualCodec, out, in);
240 // don't constrain lesser 16:10 resolutions
243 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
244 EXPECT_PRED2(IsEqualCodec, out, in);
246 // requested resolution of 0x0 succeeds
249 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
250 EXPECT_PRED2(IsEqualCodec, out, in);
252 // constrain resolution lesser than the max and wider aspect,
253 // picking best aspect (16:9)
256 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
257 EXPECT_PRED4(IsEqualRes, out, 320, 180, 30);
259 // constrain resolution greater than the max and narrow aspect,
260 // picking best aspect (4:3)
263 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
264 EXPECT_PRED4(IsEqualRes, out, 320, 240, 30);
266 // constrain resolution greater than the max and wider aspect,
267 // picking best aspect (16:9)
270 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
271 EXPECT_PRED4(IsEqualRes, out, 640, 360, 30);
273 // constrain resolution greater than the max and narrow aspect,
274 // picking best aspect (4:3)
277 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
278 EXPECT_PRED4(IsEqualRes, out, 640, 480, 30);
280 // constrain resolution greater than the max, picking equal aspect (4:3)
283 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
284 EXPECT_PRED4(IsEqualRes, out, 640, 480, 30);
286 // constrain resolution greater than the max, picking equal aspect (16:10)
289 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
290 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
292 // constrain res & fps greater than the max
294 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
295 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
297 // reduce max settings to 160x100x10
298 max_settings.width = 160;
299 max_settings.height = 100;
300 max_settings.framerate = 10;
301 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
302 cricket::VideoEncoderConfig(max_settings)));
304 // constrain res & fps to new max
305 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
306 EXPECT_PRED4(IsEqualRes, out, 160, 100, 10);
308 // allow 4:3 "comparable" resolutions
312 EXPECT_TRUE(engine_.CanSendCodec(in, empty, &out));
313 EXPECT_PRED4(IsEqualRes, out, 160, 120, 10);
316 void ConstrainRunningCodecBody() {
317 cricket::VideoCodec in, out, current;
318 cricket::VideoCodec max_settings(engine_.codecs()[0].id,
319 engine_.codecs()[0].name,
322 // set max settings of 1280x960x30
323 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
324 cricket::VideoEncoderConfig(max_settings)));
326 // establish current call at 1280x800x30 (16:10)
327 current = max_settings;
328 current.height = 800;
330 // Don't constrain current resolution
332 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
333 EXPECT_PRED2(IsEqualCodec, out, in);
335 // requested resolution of 0x0 succeeds
338 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
339 EXPECT_PRED2(IsEqualCodec, out, in);
341 // Reduce an intermediate resolution down to the next lowest one, preserving
345 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
346 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
348 // Clamping by aspect ratio, but still never return a dimension higher than
352 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
353 EXPECT_PRED4(IsEqualRes, out, 1280, 720, 30);
356 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
357 EXPECT_PRED4(IsEqualRes, out, 960, 600, 30);
360 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
361 EXPECT_PRED4(IsEqualRes, out, 1280, 720, 30);
363 // Clamp large resolutions down, always preserving aspect
366 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
367 EXPECT_PRED4(IsEqualRes, out, 1280, 800, 30);
370 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
371 EXPECT_PRED4(IsEqualRes, out, 1280, 800, 30);
374 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
375 EXPECT_PRED4(IsEqualRes, out, 1280, 800, 30);
377 // reduce max settings to 640x480x30
378 max_settings.width = 640;
379 max_settings.height = 480;
380 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
381 cricket::VideoEncoderConfig(max_settings)));
383 // establish current call at 640x400x30 (16:10)
384 current = max_settings;
385 current.height = 400;
387 // Don't constrain current resolution
389 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
390 EXPECT_PRED2(IsEqualCodec, out, in);
392 // requested resolution of 0x0 succeeds
395 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
396 EXPECT_PRED2(IsEqualCodec, out, in);
398 // Reduce an intermediate resolution down to the next lowest one, preserving
402 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
403 EXPECT_PRED4(IsEqualRes, out, 320, 200, 30);
405 // Clamping by aspect ratio, but still never return a dimension higher than
409 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
410 EXPECT_PRED4(IsEqualRes, out, 640, 360, 30);
413 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
414 EXPECT_PRED4(IsEqualRes, out, 480, 300, 30);
417 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
418 EXPECT_PRED4(IsEqualRes, out, 640, 360, 30);
420 // Clamp large resolutions down, always preserving aspect
423 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
424 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
427 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
428 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
431 EXPECT_TRUE(engine_.CanSendCodec(in, current, &out));
432 EXPECT_PRED4(IsEqualRes, out, 640, 400, 30);
434 // Should fail for any that are smaller than our supported formats
437 EXPECT_FALSE(engine_.CanSendCodec(in, current, &out));
440 EXPECT_FALSE(engine_.CanSendCodec(in, current, &out));
443 VideoEngineOverride<E> engine_;
444 talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
447 template<class E, class C>
448 class VideoMediaChannelTest : public testing::Test,
449 public sigslot::has_slots<> {
451 virtual cricket::VideoCodec DefaultCodec() = 0;
453 virtual cricket::StreamParams DefaultSendStreamParams() {
454 return cricket::StreamParams::CreateLegacy(kSsrc);
457 virtual void SetUp() {
458 cricket::Device device("test", "device");
459 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
460 channel_.reset(engine_.CreateChannel(NULL));
461 EXPECT_TRUE(channel_.get() != NULL);
462 ConnectVideoChannelError();
463 network_interface_.SetDestination(channel_.get());
464 channel_->SetInterface(&network_interface_);
465 SetRendererAsDefault();
466 media_error_ = cricket::VideoMediaChannel::ERROR_NONE;
467 channel_->SetRecvCodecs(engine_.codecs());
468 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
470 video_capturer_.reset(new cricket::FakeVideoCapturer);
471 cricket::VideoFormat format(640, 480,
472 cricket::VideoFormat::FpsToInterval(30),
473 cricket::FOURCC_I420);
474 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format));
475 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
477 void SetUpSecondStream() {
478 EXPECT_TRUE(channel_->AddRecvStream(
479 cricket::StreamParams::CreateLegacy(kSsrc)));
480 EXPECT_TRUE(channel_->AddRecvStream(
481 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
482 // SetUp() already added kSsrc make sure duplicate SSRCs cant be added.
483 EXPECT_FALSE(channel_->AddSendStream(
484 cricket::StreamParams::CreateLegacy(kSsrc)));
485 EXPECT_TRUE(channel_->AddSendStream(
486 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
488 video_capturer_2_.reset(new cricket::FakeVideoCapturer());
489 cricket::VideoFormat format(640, 480,
490 cricket::VideoFormat::FpsToInterval(30),
491 cricket::FOURCC_I420);
492 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(format));
494 EXPECT_TRUE(channel_->SetCapturer(kSsrc + 2, video_capturer_2_.get()));
495 // Make the second renderer available for use by a new stream.
496 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_));
498 virtual void TearDown() {
502 void ConnectVideoChannelError() {
503 channel_->SignalMediaError.connect(this,
504 &VideoMediaChannelTest<E, C>::OnVideoChannelError);
506 bool SetDefaultCodec() {
507 return SetOneCodec(DefaultCodec());
509 void SetRendererAsDefault() {
510 EXPECT_TRUE(channel_->SetRenderer(0, &renderer_));
513 bool SetOneCodec(int pt, const char* name, int w, int h, int fr) {
514 return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr, 0));
516 bool SetOneCodec(const cricket::VideoCodec& codec) {
517 std::vector<cricket::VideoCodec> codecs;
518 codecs.push_back(codec);
520 cricket::VideoFormat capture_format(codec.width, codec.height,
521 cricket::VideoFormat::FpsToInterval(codec.framerate),
522 cricket::FOURCC_I420);
524 if (video_capturer_) {
525 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format));
528 if (video_capturer_2_) {
529 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format));
532 bool sending = channel_->sending();
533 bool success = SetSend(false);
535 success = channel_->SetSendCodecs(codecs);
537 success = SetSend(sending);
540 bool SetSend(bool send) {
541 return channel_->SetSend(send);
543 int DrainOutgoingPackets() {
546 packets = NumRtpPackets();
547 // 100 ms should be long enough.
548 talk_base::Thread::Current()->ProcessMessages(100);
549 } while (NumRtpPackets() > packets);
550 return NumRtpPackets();
553 if (video_capturer_2_) {
554 video_capturer_2_->CaptureFrame();
556 return video_capturer_.get() &&
557 video_capturer_->CaptureFrame();
559 bool WaitAndSendFrame(int wait_ms) {
560 bool ret = talk_base::Thread::Current()->ProcessMessages(wait_ms);
564 // Sends frames and waits for the decoder to be fully initialized.
565 // Returns the number of frames that were sent.
566 int WaitForDecoder() {
567 #if defined(HAVE_OPENMAX)
568 // Send enough frames for the OpenMAX decoder to continue processing, and
569 // return the number of frames sent.
570 // Send frames for a full kTimeout's worth of 15fps video.
572 while (frame_count < static_cast<int>(kTimeout) / 66) {
573 EXPECT_TRUE(WaitAndSendFrame(66));
581 bool SendCustomVideoFrame(int w, int h) {
582 if (!video_capturer_.get()) return false;
583 return video_capturer_->CaptureCustomFrame(w, h, cricket::FOURCC_I420);
586 return network_interface_.NumRtpBytes();
588 int NumRtpBytes(uint32 ssrc) {
589 return network_interface_.NumRtpBytes(ssrc);
591 int NumRtpPackets() {
592 return network_interface_.NumRtpPackets();
594 int NumRtpPackets(uint32 ssrc) {
595 return network_interface_.NumRtpPackets(ssrc);
598 return network_interface_.NumSentSsrcs();
600 const talk_base::Buffer* GetRtpPacket(int index) {
601 return network_interface_.GetRtpPacket(index);
603 int NumRtcpPackets() {
604 return network_interface_.NumRtcpPackets();
606 const talk_base::Buffer* GetRtcpPacket(int index) {
607 return network_interface_.GetRtcpPacket(index);
609 static int GetPayloadType(const talk_base::Buffer* p) {
611 ParseRtpPacket(p, NULL, &pt, NULL, NULL, NULL, NULL);
614 static bool ParseRtpPacket(const talk_base::Buffer* p, bool* x, int* pt,
615 int* seqnum, uint32* tstamp, uint32* ssrc,
616 std::string* payload) {
617 talk_base::ByteBuffer buf(p->data(), p->length());
622 // Read X and CC fields.
623 if (!buf.ReadUInt8(&u08)) return false;
624 bool extension = ((u08 & 0x10) != 0);
625 uint8 cc = (u08 & 0x0F);
626 if (x) *x = extension;
629 if (!buf.ReadUInt8(&u08)) return false;
630 if (pt) *pt = (u08 & 0x7F);
632 // Read Sequence Number field.
633 if (!buf.ReadUInt16(&u16)) return false;
634 if (seqnum) *seqnum = u16;
636 // Read Timestamp field.
637 if (!buf.ReadUInt32(&u32)) return false;
638 if (tstamp) *tstamp = u32;
641 if (!buf.ReadUInt32(&u32)) return false;
642 if (ssrc) *ssrc = u32;
645 for (uint8 i = 0; i < cc; ++i) {
646 if (!buf.ReadUInt32(&u32)) return false;
649 // Skip extension header.
651 // Read Profile-specific extension header ID
652 if (!buf.ReadUInt16(&u16)) return false;
654 // Read Extension header length
655 if (!buf.ReadUInt16(&u16)) return false;
656 uint16 ext_header_len = u16;
658 // Read Extension header
659 for (uint16 i = 0; i < ext_header_len; ++i) {
660 if (!buf.ReadUInt32(&u32)) return false;
665 return buf.ReadString(payload, buf.Length());
670 // Parse all RTCP packet, from start_index to stop_index, and count how many
671 // FIR (PT=206 and FMT=4 according to RFC 5104). If successful, set the count
673 bool CountRtcpFir(int start_index, int stop_index, int* fir_count) {
675 for (int i = start_index; i < stop_index; ++i) {
676 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtcpPacket(i));
677 talk_base::ByteBuffer buf(p->data(), p->length());
678 size_t total_len = 0;
679 // The packet may be a compound RTCP packet.
680 while (total_len < p->length()) {
681 // Read FMT, type and length.
685 if (!buf.ReadUInt8(&fmt)) return false;
687 if (!buf.ReadUInt8(&type)) return false;
688 if (!buf.ReadUInt16(&length)) return false;
689 buf.Consume(length * 4); // Skip RTCP data.
690 total_len += (length + 1) * 4;
691 if ((192 == type) || ((206 == type) && (4 == fmt))) {
703 void OnVideoChannelError(uint32 ssrc,
704 cricket::VideoMediaChannel::Error error) {
705 media_error_ = error;
708 // Test that SetSend works.
710 EXPECT_FALSE(channel_->sending());
711 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
712 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
713 EXPECT_FALSE(channel_->sending());
714 EXPECT_TRUE(SetSend(true));
715 EXPECT_TRUE(channel_->sending());
716 EXPECT_TRUE(SendFrame());
717 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
718 EXPECT_TRUE(SetSend(false));
719 EXPECT_FALSE(channel_->sending());
721 // Test that SetSend fails without codecs being set.
722 void SetSendWithoutCodecs() {
723 EXPECT_FALSE(channel_->sending());
724 EXPECT_FALSE(SetSend(true));
725 EXPECT_FALSE(channel_->sending());
727 // Test that we properly set the send and recv buffer sizes by the time
728 // SetSend is called.
729 void SetSendSetsTransportBufferSizes() {
730 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
731 EXPECT_TRUE(SetSend(true));
732 // TODO(sriniv): Remove or re-enable this.
733 // As part of b/8030474, send-buffer is size now controlled through
734 // portallocator flags. Its not set by channels.
735 // EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
736 EXPECT_EQ(64 * 1024, network_interface_.recvbuf_size());
738 // Tests that we can send frames and the right payload type is used.
739 void Send(const cricket::VideoCodec& codec) {
740 EXPECT_TRUE(SetOneCodec(codec));
741 EXPECT_TRUE(SetSend(true));
742 EXPECT_TRUE(SendFrame());
743 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
744 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
745 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
747 // Tests that we can send and receive frames.
748 void SendAndReceive(const cricket::VideoCodec& codec) {
749 EXPECT_TRUE(SetOneCodec(codec));
750 EXPECT_TRUE(SetSend(true));
751 EXPECT_TRUE(channel_->SetRender(true));
752 EXPECT_EQ(0, renderer_.num_rendered_frames());
753 EXPECT_TRUE(SendFrame());
754 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
755 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
756 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
758 // Tests that we only get a VideoRenderer::SetSize() callback when needed.
759 void SendManyResizeOnce() {
760 cricket::VideoCodec codec(DefaultCodec());
761 EXPECT_TRUE(SetOneCodec(codec));
762 EXPECT_TRUE(SetSend(true));
763 EXPECT_TRUE(channel_->SetRender(true));
764 EXPECT_EQ(0, renderer_.num_rendered_frames());
765 EXPECT_TRUE(WaitAndSendFrame(30));
766 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
767 EXPECT_TRUE(WaitAndSendFrame(30));
768 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
769 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
770 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
771 EXPECT_EQ(1, renderer_.num_set_sizes());
775 EXPECT_TRUE(SetOneCodec(codec));
776 EXPECT_TRUE(WaitAndSendFrame(30));
777 EXPECT_FRAME_WAIT(3, codec.width, codec.height, kTimeout);
778 EXPECT_EQ(2, renderer_.num_set_sizes());
780 // Test that stats work properly for a 1-1 call.
782 SendAndReceive(DefaultCodec());
783 cricket::VideoMediaInfo info;
784 EXPECT_TRUE(channel_->GetStats(&info));
786 ASSERT_EQ(1U, info.senders.size());
787 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
788 EXPECT_GT(info.senders[0].bytes_sent, 0);
789 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent);
790 EXPECT_EQ(0.0, info.senders[0].fraction_lost);
791 EXPECT_EQ(0, info.senders[0].firs_rcvd);
792 EXPECT_EQ(0, info.senders[0].nacks_rcvd);
793 EXPECT_EQ(DefaultCodec().width, info.senders[0].frame_width);
794 EXPECT_EQ(DefaultCodec().height, info.senders[0].frame_height);
795 EXPECT_GT(info.senders[0].framerate_input, 0);
796 EXPECT_GT(info.senders[0].framerate_sent, 0);
798 ASSERT_EQ(1U, info.receivers.size());
799 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
800 EXPECT_EQ(1U, info.receivers[0].ssrcs().size());
801 EXPECT_EQ(info.senders[0].ssrcs()[0], info.receivers[0].ssrcs()[0]);
802 EXPECT_EQ(NumRtpBytes(), info.receivers[0].bytes_rcvd);
803 EXPECT_EQ(NumRtpPackets(), info.receivers[0].packets_rcvd);
804 EXPECT_EQ(0.0, info.receivers[0].fraction_lost);
805 EXPECT_EQ(0, info.receivers[0].packets_lost);
806 EXPECT_EQ(0, info.receivers[0].packets_concealed);
807 EXPECT_EQ(0, info.receivers[0].firs_sent);
808 EXPECT_EQ(0, info.receivers[0].nacks_sent);
809 EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width);
810 EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height);
811 EXPECT_GT(info.receivers[0].framerate_rcvd, 0);
812 EXPECT_GT(info.receivers[0].framerate_decoded, 0);
813 EXPECT_GT(info.receivers[0].framerate_output, 0);
815 // Test that stats work properly for a conf call with multiple recv streams.
816 void GetStatsMultipleRecvStreams() {
817 cricket::FakeVideoRenderer renderer1, renderer2;
818 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
819 cricket::VideoOptions vmo;
820 vmo.conference_mode.Set(true);
821 EXPECT_TRUE(channel_->SetOptions(vmo));
822 EXPECT_TRUE(SetSend(true));
823 EXPECT_TRUE(channel_->AddRecvStream(
824 cricket::StreamParams::CreateLegacy(1)));
825 EXPECT_TRUE(channel_->AddRecvStream(
826 cricket::StreamParams::CreateLegacy(2)));
827 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
828 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
829 EXPECT_TRUE(channel_->SetRender(true));
830 EXPECT_EQ(0, renderer1.num_rendered_frames());
831 EXPECT_EQ(0, renderer2.num_rendered_frames());
832 std::vector<uint32> ssrcs;
835 network_interface_.SetConferenceMode(true, ssrcs);
836 EXPECT_TRUE(SendFrame());
837 EXPECT_FRAME_ON_RENDERER_WAIT(
838 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
839 EXPECT_FRAME_ON_RENDERER_WAIT(
840 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
841 cricket::VideoMediaInfo info;
842 EXPECT_TRUE(channel_->GetStats(&info));
844 ASSERT_EQ(1U, info.senders.size());
845 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
846 EXPECT_GT(info.senders[0].bytes_sent, 0);
847 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent);
848 EXPECT_EQ(0.0, info.senders[0].fraction_lost);
849 EXPECT_EQ(0, info.senders[0].firs_rcvd);
850 EXPECT_EQ(0, info.senders[0].nacks_rcvd);
851 EXPECT_EQ(DefaultCodec().width, info.senders[0].frame_width);
852 EXPECT_EQ(DefaultCodec().height, info.senders[0].frame_height);
853 EXPECT_GT(info.senders[0].framerate_input, 0);
854 EXPECT_GT(info.senders[0].framerate_sent, 0);
856 ASSERT_EQ(2U, info.receivers.size());
857 for (size_t i = 0; i < info.receivers.size(); ++i) {
858 EXPECT_EQ(1U, info.receivers[i].ssrcs().size());
859 EXPECT_EQ(i + 1, info.receivers[i].ssrcs()[0]);
860 EXPECT_EQ(NumRtpBytes(), info.receivers[i].bytes_rcvd);
861 EXPECT_EQ(NumRtpPackets(), info.receivers[i].packets_rcvd);
862 EXPECT_EQ(0.0, info.receivers[i].fraction_lost);
863 EXPECT_EQ(0, info.receivers[i].packets_lost);
864 EXPECT_EQ(0, info.receivers[i].packets_concealed);
865 EXPECT_EQ(0, info.receivers[i].firs_sent);
866 EXPECT_EQ(0, info.receivers[i].nacks_sent);
867 EXPECT_EQ(DefaultCodec().width, info.receivers[i].frame_width);
868 EXPECT_EQ(DefaultCodec().height, info.receivers[i].frame_height);
869 EXPECT_GT(info.receivers[i].framerate_rcvd, 0);
870 EXPECT_GT(info.receivers[i].framerate_decoded, 0);
871 EXPECT_GT(info.receivers[i].framerate_output, 0);
874 // Test that stats work properly for a conf call with multiple send streams.
875 void GetStatsMultipleSendStreams() {
876 // Normal setup; note that we set the SSRC explicitly to ensure that
877 // it will come first in the senders map.
878 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
879 cricket::VideoOptions vmo;
880 vmo.conference_mode.Set(true);
881 EXPECT_TRUE(channel_->SetOptions(vmo));
882 EXPECT_TRUE(channel_->AddRecvStream(
883 cricket::StreamParams::CreateLegacy(1234)));
884 channel_->UpdateAspectRatio(640, 400);
885 EXPECT_TRUE(SetSend(true));
886 EXPECT_TRUE(channel_->SetRender(true));
887 EXPECT_TRUE(SendFrame());
888 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
889 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
891 // Add an additional capturer, and hook up a renderer to receive it.
892 cricket::FakeVideoRenderer renderer1;
893 talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
894 new cricket::FakeVideoCapturer);
895 capturer->SetScreencast(true);
896 const int kTestWidth = 160;
897 const int kTestHeight = 120;
898 cricket::VideoFormat format(kTestWidth, kTestHeight,
899 cricket::VideoFormat::FpsToInterval(5),
900 cricket::FOURCC_I420);
901 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
902 EXPECT_TRUE(channel_->AddSendStream(
903 cricket::StreamParams::CreateLegacy(5678)));
904 EXPECT_TRUE(channel_->SetCapturer(5678, capturer.get()));
905 EXPECT_TRUE(channel_->AddRecvStream(
906 cricket::StreamParams::CreateLegacy(5678)));
907 EXPECT_TRUE(channel_->SetRenderer(5678, &renderer1));
908 EXPECT_TRUE(capturer->CaptureCustomFrame(
909 kTestWidth, kTestHeight, cricket::FOURCC_I420));
910 EXPECT_FRAME_ON_RENDERER_WAIT(
911 renderer1, 1, kTestWidth, kTestHeight, kTimeout);
913 // Get stats, and make sure they are correct for two senders.
914 cricket::VideoMediaInfo info;
915 EXPECT_TRUE(channel_->GetStats(&info));
916 ASSERT_EQ(2U, info.senders.size());
917 EXPECT_EQ(NumRtpPackets(),
918 info.senders[0].packets_sent + info.senders[1].packets_sent);
919 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
920 EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]);
921 EXPECT_EQ(DefaultCodec().width, info.senders[0].frame_width);
922 EXPECT_EQ(DefaultCodec().height, info.senders[0].frame_height);
923 EXPECT_EQ(1U, info.senders[1].ssrcs().size());
924 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]);
925 EXPECT_EQ(kTestWidth, info.senders[1].frame_width);
926 EXPECT_EQ(kTestHeight, info.senders[1].frame_height);
927 // The capturer must be unregistered here as it runs out of it's scope next.
928 EXPECT_TRUE(channel_->SetCapturer(5678, NULL));
931 // Test that we can set the bandwidth.
932 void SetSendBandwidth() {
933 EXPECT_TRUE(channel_->SetStartSendBandwidth(64 * 1024));
934 EXPECT_TRUE(channel_->SetMaxSendBandwidth(-1)); // <= 0 means unlimited.
935 EXPECT_TRUE(channel_->SetMaxSendBandwidth(128 * 1024));
937 // Test that we can set the SSRC for the default send source.
939 EXPECT_TRUE(SetDefaultCodec());
940 EXPECT_TRUE(SetSend(true));
941 EXPECT_TRUE(SendFrame());
942 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
944 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
945 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
946 EXPECT_EQ(kSsrc, ssrc);
947 EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
948 EXPECT_EQ(NumRtpBytes(), NumRtpBytes(ssrc));
949 EXPECT_EQ(1, NumSentSsrcs());
950 EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
951 EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
953 // Test that we can set the SSRC even after codecs are set.
954 void SetSendSsrcAfterSetCodecs() {
955 // Remove stream added in Setup.
956 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
957 EXPECT_TRUE(SetDefaultCodec());
958 EXPECT_TRUE(channel_->AddSendStream(
959 cricket::StreamParams::CreateLegacy(999)));
960 EXPECT_TRUE(channel_->SetCapturer(999u, video_capturer_.get()));
961 EXPECT_TRUE(SetSend(true));
962 EXPECT_TRUE(WaitAndSendFrame(0));
963 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
965 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
966 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
967 EXPECT_EQ(999u, ssrc);
968 EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
969 EXPECT_EQ(NumRtpBytes(), NumRtpBytes(ssrc));
970 EXPECT_EQ(1, NumSentSsrcs());
971 EXPECT_EQ(0, NumRtpPackets(kSsrc));
972 EXPECT_EQ(0, NumRtpBytes(kSsrc));
974 // Test that we can set the default video renderer before and after
975 // media is received.
978 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
981 talk_base::Buffer packet1(data1, sizeof(data1));
982 talk_base::SetBE32(packet1.data() + 8, kSsrc);
983 channel_->SetRenderer(0, NULL);
984 EXPECT_TRUE(SetDefaultCodec());
985 EXPECT_TRUE(SetSend(true));
986 EXPECT_TRUE(channel_->SetRender(true));
987 EXPECT_EQ(0, renderer_.num_rendered_frames());
988 channel_->OnPacketReceived(&packet1, talk_base::PacketTime());
989 SetRendererAsDefault();
990 EXPECT_TRUE(SendFrame());
991 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
994 // Tests empty StreamParams is rejected.
995 void RejectEmptyStreamParams() {
996 // Remove the send stream that was added during Setup.
997 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
999 cricket::StreamParams empty;
1000 EXPECT_FALSE(channel_->AddSendStream(empty));
1001 EXPECT_TRUE(channel_->AddSendStream(
1002 cricket::StreamParams::CreateLegacy(789u)));
1005 // Tests setting up and configuring a send stream.
1006 void AddRemoveSendStreams() {
1007 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1008 EXPECT_TRUE(SetSend(true));
1009 EXPECT_TRUE(channel_->SetRender(true));
1010 EXPECT_TRUE(SendFrame());
1011 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1012 EXPECT_GE(2, NumRtpPackets());
1014 size_t last_packet = NumRtpPackets() - 1;
1015 talk_base::scoped_ptr<const talk_base::Buffer>
1016 p(GetRtpPacket(static_cast<int>(last_packet)));
1017 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
1018 EXPECT_EQ(kSsrc, ssrc);
1020 // Remove the send stream that was added during Setup.
1021 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1022 int rtp_packets = NumRtpPackets();
1024 EXPECT_TRUE(channel_->AddSendStream(
1025 cricket::StreamParams::CreateLegacy(789u)));
1026 EXPECT_TRUE(channel_->SetCapturer(789u, video_capturer_.get()));
1027 EXPECT_EQ(rtp_packets, NumRtpPackets());
1028 // Wait 30ms to guarantee the engine does not drop the frame.
1029 EXPECT_TRUE(WaitAndSendFrame(30));
1030 EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout);
1032 last_packet = NumRtpPackets() - 1;
1033 p.reset(GetRtpPacket(static_cast<int>(last_packet)));
1034 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
1035 EXPECT_EQ(789u, ssrc);
1038 // Tests adding streams already exists returns false.
1039 void AddRecvStreamsAlreadyExist() {
1040 cricket::VideoOptions vmo;
1041 vmo.conference_mode.Set(true);
1042 EXPECT_TRUE(channel_->SetOptions(vmo));
1044 EXPECT_FALSE(channel_->AddRecvStream(
1045 cricket::StreamParams::CreateLegacy(0)));
1047 EXPECT_TRUE(channel_->AddRecvStream(
1048 cricket::StreamParams::CreateLegacy(1)));
1049 EXPECT_FALSE(channel_->AddRecvStream(
1050 cricket::StreamParams::CreateLegacy(1)));
1052 EXPECT_TRUE(channel_->RemoveRecvStream(1));
1053 EXPECT_FALSE(channel_->AddRecvStream(
1054 cricket::StreamParams::CreateLegacy(0)));
1055 EXPECT_TRUE(channel_->AddRecvStream(
1056 cricket::StreamParams::CreateLegacy(1)));
1059 // Tests setting up and configuring multiple incoming streams.
1060 void AddRemoveRecvStreams() {
1061 cricket::FakeVideoRenderer renderer1, renderer2;
1062 cricket::VideoOptions vmo;
1063 vmo.conference_mode.Set(true);
1064 EXPECT_TRUE(channel_->SetOptions(vmo));
1065 // Ensure we can't set the renderer on a non-existent stream.
1066 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
1067 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
1068 cricket::VideoRenderer* renderer;
1069 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
1070 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
1072 // Ensure we can add streams.
1073 EXPECT_TRUE(channel_->AddRecvStream(
1074 cricket::StreamParams::CreateLegacy(1)));
1075 EXPECT_TRUE(channel_->AddRecvStream(
1076 cricket::StreamParams::CreateLegacy(2)));
1077 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1078 // Verify the first AddRecvStream hook up to the default renderer.
1079 EXPECT_EQ(&renderer_, renderer);
1080 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1081 EXPECT_TRUE(NULL == renderer);
1083 // Ensure we can now set the renderers.
1084 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
1085 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
1086 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1087 EXPECT_TRUE(&renderer1 == renderer);
1088 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1089 EXPECT_TRUE(&renderer2 == renderer);
1091 // Ensure we can change the renderers if needed.
1092 EXPECT_TRUE(channel_->SetRenderer(1, &renderer2));
1093 EXPECT_TRUE(channel_->SetRenderer(2, &renderer1));
1094 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1095 EXPECT_TRUE(&renderer2 == renderer);
1096 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1097 EXPECT_TRUE(&renderer1 == renderer);
1099 EXPECT_TRUE(channel_->RemoveRecvStream(2));
1100 EXPECT_TRUE(channel_->RemoveRecvStream(1));
1101 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
1102 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
1105 // Tests setting up and configuring multiple incoming streams in a
1106 // non-conference call.
1107 void AddRemoveRecvStreamsNoConference() {
1108 cricket::FakeVideoRenderer renderer1, renderer2;
1109 // Ensure we can't set the renderer on a non-existent stream.
1110 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
1111 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
1112 cricket::VideoRenderer* renderer;
1113 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
1114 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
1116 // Ensure we can add streams.
1117 EXPECT_TRUE(channel_->AddRecvStream(
1118 cricket::StreamParams::CreateLegacy(1)));
1119 EXPECT_TRUE(channel_->AddRecvStream(
1120 cricket::StreamParams::CreateLegacy(2)));
1121 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1122 // Verify the first AddRecvStream hook up to the default renderer.
1123 EXPECT_EQ(&renderer_, renderer);
1124 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1125 EXPECT_TRUE(NULL == renderer);
1127 // Ensure we can now set the renderers.
1128 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
1129 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
1130 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1131 EXPECT_TRUE(&renderer1 == renderer);
1132 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1133 EXPECT_TRUE(&renderer2 == renderer);
1135 // Ensure we can change the renderers if needed.
1136 EXPECT_TRUE(channel_->SetRenderer(1, &renderer2));
1137 EXPECT_TRUE(channel_->SetRenderer(2, &renderer1));
1138 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
1139 EXPECT_TRUE(&renderer2 == renderer);
1140 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
1141 EXPECT_TRUE(&renderer1 == renderer);
1143 EXPECT_TRUE(channel_->RemoveRecvStream(2));
1144 EXPECT_TRUE(channel_->RemoveRecvStream(1));
1145 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
1146 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
1149 // Test that no frames are rendered after the receive stream have been
1151 void AddRemoveRecvStreamAndRender() {
1152 cricket::FakeVideoRenderer renderer1;
1153 EXPECT_TRUE(SetDefaultCodec());
1154 EXPECT_TRUE(SetSend(true));
1155 EXPECT_TRUE(channel_->SetRender(true));
1156 EXPECT_TRUE(channel_->AddRecvStream(
1157 cricket::StreamParams::CreateLegacy(kSsrc)));
1158 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer1));
1160 EXPECT_TRUE(SendFrame());
1161 EXPECT_FRAME_ON_RENDERER_WAIT(
1162 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1163 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
1164 // Send three more frames. This is to avoid that the test might be flaky
1165 // due to frame dropping.
1166 for (size_t i = 0; i < 3; ++i)
1167 EXPECT_TRUE(WaitAndSendFrame(100));
1169 // Test that no more frames have been rendered.
1170 EXPECT_EQ(1, renderer1.num_rendered_frames());
1172 // Re-add the stream again and make sure it renders.
1173 EXPECT_TRUE(channel_->AddRecvStream(
1174 cricket::StreamParams::CreateLegacy(kSsrc)));
1175 // Force the next frame to be a key frame to make the receiving
1177 EXPECT_TRUE(channel_->SendIntraFrame());
1179 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer1));
1180 EXPECT_TRUE(SendFrame());
1181 // Because the default channel is used, RemoveRecvStream above is not going
1182 // to delete the channel. As a result the engine will continue to receive
1183 // and decode the 3 frames sent above. So it is possible we will receive
1184 // some (e.g. 1) of these 3 frames after the renderer is set again.
1185 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
1186 renderer1, 2, DefaultCodec().width, DefaultCodec().height, kTimeout);
1189 // Tests the behavior of incoming streams in a conference scenario.
1190 void SimulateConference() {
1191 cricket::FakeVideoRenderer renderer1, renderer2;
1192 EXPECT_TRUE(SetDefaultCodec());
1193 cricket::VideoOptions vmo;
1194 vmo.conference_mode.Set(true);
1195 EXPECT_TRUE(channel_->SetOptions(vmo));
1196 EXPECT_TRUE(SetSend(true));
1197 EXPECT_TRUE(channel_->SetRender(true));
1198 EXPECT_TRUE(channel_->AddRecvStream(
1199 cricket::StreamParams::CreateLegacy(1)));
1200 EXPECT_TRUE(channel_->AddRecvStream(
1201 cricket::StreamParams::CreateLegacy(2)));
1202 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
1203 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
1204 EXPECT_EQ(0, renderer1.num_rendered_frames());
1205 EXPECT_EQ(0, renderer2.num_rendered_frames());
1206 std::vector<uint32> ssrcs;
1209 network_interface_.SetConferenceMode(true, ssrcs);
1210 EXPECT_TRUE(SendFrame());
1211 EXPECT_FRAME_ON_RENDERER_WAIT(
1212 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1213 EXPECT_FRAME_ON_RENDERER_WAIT(
1214 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1216 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
1217 EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get()));
1218 EXPECT_EQ(DefaultCodec().width, renderer1.width());
1219 EXPECT_EQ(DefaultCodec().height, renderer1.height());
1220 EXPECT_EQ(DefaultCodec().width, renderer2.width());
1221 EXPECT_EQ(DefaultCodec().height, renderer2.height());
1222 EXPECT_TRUE(channel_->RemoveRecvStream(2));
1223 EXPECT_TRUE(channel_->RemoveRecvStream(1));
1226 // Tests that we can add and remove capturers and frames are sent out properly
1227 void AddRemoveCapturer() {
1228 cricket::VideoCodec codec = DefaultCodec();
1231 const int time_between_send = TimeBetweenSend(codec);
1232 EXPECT_TRUE(SetOneCodec(codec));
1233 EXPECT_TRUE(SetSend(true));
1234 EXPECT_TRUE(channel_->SetRender(true));
1235 EXPECT_EQ(0, renderer_.num_rendered_frames());
1236 EXPECT_TRUE(SendFrame());
1237 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
1238 talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
1239 new cricket::FakeVideoCapturer);
1240 capturer->SetScreencast(true);
1241 cricket::VideoFormat format(480, 360,
1242 cricket::VideoFormat::FpsToInterval(30),
1243 cricket::FOURCC_I420);
1244 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
1245 // All capturers start generating frames with the same timestamp. ViE does
1246 // not allow the same timestamp to be used. Capture one frame before
1247 // associating the capturer with the channel.
1248 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
1249 cricket::FOURCC_I420));
1251 int captured_frames = 1;
1252 for (int iterations = 0; iterations < 2; ++iterations) {
1253 EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
1254 talk_base::Thread::Current()->ProcessMessages(time_between_send);
1255 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
1256 cricket::FOURCC_I420));
1258 // Wait until frame of right size is captured.
1259 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
1260 format.width == renderer_.width() &&
1261 format.height == renderer_.height() &&
1262 !renderer_.black_frame(), kTimeout);
1263 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
1264 EXPECT_EQ(format.width, renderer_.width());
1265 EXPECT_EQ(format.height, renderer_.height());
1266 captured_frames = renderer_.num_rendered_frames() + 1;
1267 EXPECT_FALSE(renderer_.black_frame());
1268 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1269 // Make sure a black frame is generated within the specified timeout.
1270 // The black frame should be the resolution of the send codec.
1271 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
1272 codec.width == renderer_.width() &&
1273 codec.height == renderer_.height() &&
1274 renderer_.black_frame(), kTimeout);
1275 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
1276 EXPECT_EQ(codec.width, renderer_.width());
1277 EXPECT_EQ(codec.height, renderer_.height());
1278 EXPECT_TRUE(renderer_.black_frame());
1280 // The black frame has the same timestamp as the next frame since it's
1281 // timestamp is set to the last frame's timestamp + interval. WebRTC will
1282 // not render a frame with the same timestamp so capture another frame
1283 // with the frame capturer to increment the next frame's timestamp.
1284 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
1285 cricket::FOURCC_I420));
1289 // Tests that if RemoveCapturer is called without a capturer ever being
1290 // added, the plugin shouldn't crash (and no black frame should be sent).
1291 void RemoveCapturerWithoutAdd() {
1292 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1293 EXPECT_TRUE(SetSend(true));
1294 EXPECT_TRUE(channel_->SetRender(true));
1295 EXPECT_EQ(0, renderer_.num_rendered_frames());
1296 EXPECT_TRUE(SendFrame());
1297 EXPECT_FRAME_WAIT(1, 640, 400, kTimeout);
1298 // Remove the capturer.
1299 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1300 // Wait for one black frame for removing the capturer.
1301 EXPECT_FRAME_WAIT(2, 640, 400, kTimeout);
1303 // No capturer was added, so this RemoveCapturer should
1305 EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
1306 talk_base::Thread::Current()->ProcessMessages(300);
1307 // Verify no more frames were sent.
1308 EXPECT_EQ(2, renderer_.num_rendered_frames());
1311 // Tests that we can add and remove capturer as unique sources.
1312 void AddRemoveCapturerMultipleSources() {
1313 // WebRTC implementation will drop frames if pushed to quickly. Wait the
1314 // interval time to avoid that.
1315 // WebRTC implementation will drop frames if pushed to quickly. Wait the
1316 // interval time to avoid that.
1317 // Set up the stream associated with the engine.
1318 EXPECT_TRUE(channel_->AddRecvStream(
1319 cricket::StreamParams::CreateLegacy(kSsrc)));
1320 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
1321 cricket::VideoFormat capture_format; // default format
1322 capture_format.interval = cricket::VideoFormat::FpsToInterval(30);
1323 // Set up additional stream 1.
1324 cricket::FakeVideoRenderer renderer1;
1325 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
1326 EXPECT_TRUE(channel_->AddRecvStream(
1327 cricket::StreamParams::CreateLegacy(1)));
1328 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
1329 EXPECT_TRUE(channel_->AddSendStream(
1330 cricket::StreamParams::CreateLegacy(1)));
1331 talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer1(
1332 new cricket::FakeVideoCapturer);
1333 capturer1->SetScreencast(true);
1334 EXPECT_EQ(cricket::CS_RUNNING, capturer1->Start(capture_format));
1335 // Set up additional stream 2.
1336 cricket::FakeVideoRenderer renderer2;
1337 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
1338 EXPECT_TRUE(channel_->AddRecvStream(
1339 cricket::StreamParams::CreateLegacy(2)));
1340 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
1341 EXPECT_TRUE(channel_->AddSendStream(
1342 cricket::StreamParams::CreateLegacy(2)));
1343 talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer2(
1344 new cricket::FakeVideoCapturer);
1345 capturer2->SetScreencast(true);
1346 EXPECT_EQ(cricket::CS_RUNNING, capturer2->Start(capture_format));
1347 // State for all the streams.
1348 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1349 // A limitation in the lmi implementation requires that SetCapturer() is
1350 // called after SetOneCodec().
1351 // TODO(hellner): this seems like an unnecessary constraint, fix it.
1352 EXPECT_TRUE(channel_->SetCapturer(1, capturer1.get()));
1353 EXPECT_TRUE(channel_->SetCapturer(2, capturer2.get()));
1354 EXPECT_TRUE(SetSend(true));
1355 EXPECT_TRUE(channel_->SetRender(true));
1356 // Test capturer associated with engine.
1357 const int kTestWidth = 160;
1358 const int kTestHeight = 120;
1359 EXPECT_TRUE(capturer1->CaptureCustomFrame(
1360 kTestWidth, kTestHeight, cricket::FOURCC_I420));
1361 EXPECT_FRAME_ON_RENDERER_WAIT(
1362 renderer1, 1, kTestWidth, kTestHeight, kTimeout);
1363 // Capture a frame with additional capturer2, frames should be received
1364 EXPECT_TRUE(capturer2->CaptureCustomFrame(
1365 kTestWidth, kTestHeight, cricket::FOURCC_I420));
1366 EXPECT_FRAME_ON_RENDERER_WAIT(
1367 renderer2, 1, kTestWidth, kTestHeight, kTimeout);
1368 // Successfully remove the capturer.
1369 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1370 // Fail to re-remove the capturer.
1371 EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
1372 // The capturers must be unregistered here as it runs out of it's scope
1374 EXPECT_TRUE(channel_->SetCapturer(1, NULL));
1375 EXPECT_TRUE(channel_->SetCapturer(2, NULL));
1378 void HighAspectHighHeightCapturer() {
1379 const int kWidth = 80;
1380 const int kHeight = 10000;
1381 const int kScaledWidth = 20;
1382 const int kScaledHeight = 2500;
1384 cricket::VideoCodec codec(DefaultCodec());
1385 EXPECT_TRUE(SetOneCodec(codec));
1386 EXPECT_TRUE(SetSend(true));
1388 cricket::FakeVideoRenderer renderer;
1389 EXPECT_TRUE(channel_->AddRecvStream(
1390 cricket::StreamParams::CreateLegacy(kSsrc)));
1391 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer));
1392 EXPECT_TRUE(channel_->SetRender(true));
1393 EXPECT_EQ(0, renderer.num_rendered_frames());
1395 EXPECT_TRUE(SendFrame());
1396 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
1397 renderer, 1, codec.width, codec.height, kTimeout);
1399 // Registering an external capturer is currently the same as screen casting
1400 // (update the test when this changes).
1401 talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
1402 new cricket::FakeVideoCapturer);
1403 capturer->SetScreencast(true);
1404 const std::vector<cricket::VideoFormat>* formats =
1405 capturer->GetSupportedFormats();
1406 cricket::VideoFormat capture_format = (*formats)[0];
1407 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(capture_format));
1408 // Capture frame to not get same frame timestamps as previous capturer.
1409 capturer->CaptureFrame();
1410 EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
1411 EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
1412 EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight,
1413 cricket::FOURCC_ARGB));
1414 EXPECT_TRUE(capturer->CaptureFrame());
1415 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
1416 renderer, 2, kScaledWidth, kScaledHeight, kTimeout);
1417 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1420 // Tests that we can adapt video resolution with 16:10 aspect ratio properly.
1421 void AdaptResolution16x10() {
1422 cricket::VideoCodec codec(DefaultCodec());
1425 SendAndReceive(codec);
1428 // Adapt the resolution.
1429 EXPECT_TRUE(SetOneCodec(codec));
1430 EXPECT_TRUE(WaitAndSendFrame(30));
1431 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
1433 // Tests that we can adapt video resolution with 4:3 aspect ratio properly.
1434 void AdaptResolution4x3() {
1435 cricket::VideoCodec codec(DefaultCodec());
1438 SendAndReceive(codec);
1441 // Adapt the resolution.
1442 EXPECT_TRUE(SetOneCodec(codec));
1443 EXPECT_TRUE(WaitAndSendFrame(30));
1444 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
1446 // Tests that we can drop all frames properly.
1447 void AdaptDropAllFrames() {
1448 // Set the channel codec's resolution to 0, which will require the adapter
1449 // to drop all frames.
1450 cricket::VideoCodec codec(DefaultCodec());
1451 codec.width = codec.height = codec.framerate = 0;
1452 EXPECT_TRUE(SetOneCodec(codec));
1453 EXPECT_TRUE(SetSend(true));
1454 EXPECT_TRUE(channel_->SetRender(true));
1455 EXPECT_EQ(0, renderer_.num_rendered_frames());
1456 EXPECT_TRUE(SendFrame());
1457 EXPECT_TRUE(SendFrame());
1458 talk_base::Thread::Current()->ProcessMessages(500);
1459 EXPECT_EQ(0, renderer_.num_rendered_frames());
1461 // Tests that we can reduce the frame rate on demand properly.
1462 // TODO(fbarchard): This test is flakey on pulse. Fix and re-enable
1463 void AdaptFramerate() {
1464 cricket::VideoCodec codec(DefaultCodec());
1465 int frame_count = 0;
1466 // The capturer runs at 30 fps. The channel requires 30 fps.
1467 EXPECT_TRUE(SetOneCodec(codec));
1468 EXPECT_TRUE(SetSend(true));
1469 EXPECT_TRUE(channel_->SetRender(true));
1470 EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
1471 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1472 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1474 EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
1475 talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
1476 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
1478 // The channel requires 15 fps.
1479 codec.framerate = 15;
1480 EXPECT_TRUE(SetOneCodec(codec));
1481 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1482 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1483 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1485 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1487 // The channel requires 10 fps.
1488 codec.framerate = 10;
1489 EXPECT_TRUE(SetOneCodec(codec));
1490 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1491 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1492 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1493 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1495 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1497 // The channel requires 8 fps. The adapter adapts to 10 fps, which is the
1498 // closest factor of 30.
1499 codec.framerate = 8;
1500 EXPECT_TRUE(SetOneCodec(codec));
1501 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1502 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1503 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1504 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1506 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1508 // Tests that we can set the send stream format properly.
1509 void SetSendStreamFormat() {
1510 cricket::VideoCodec codec(DefaultCodec());
1511 SendAndReceive(codec);
1512 int frame_count = 1;
1513 EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
1515 // Adapt the resolution and frame rate to half.
1516 cricket::VideoFormat format(
1519 cricket::VideoFormat::FpsToInterval(codec.framerate / 2),
1520 cricket::FOURCC_I420);
1521 // The SSRC differs from the send SSRC.
1522 EXPECT_FALSE(channel_->SetSendStreamFormat(kSsrc - 1, format));
1523 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1525 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1526 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1527 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1529 EXPECT_FRAME_WAIT(frame_count, format.width, format.height, kTimeout);
1531 // Adapt the resolution to 0x0, which should drop all frames.
1534 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1535 EXPECT_TRUE(SendFrame());
1536 EXPECT_TRUE(SendFrame());
1537 talk_base::Thread::Current()->ProcessMessages(500);
1538 EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
1540 // Test that setting send stream format to 0x0 resolution will result in
1541 // frames being dropped.
1542 void SetSendStreamFormat0x0() {
1543 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1544 EXPECT_TRUE(SetSend(true));
1545 EXPECT_TRUE(channel_->SetRender(true));
1546 EXPECT_EQ(0, renderer_.num_rendered_frames());
1547 // This frame should be received.
1548 EXPECT_TRUE(SendFrame());
1549 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1550 const int64 interval = cricket::VideoFormat::FpsToInterval(
1551 DefaultCodec().framerate);
1552 cricket::VideoFormat format(
1556 cricket::FOURCC_I420);
1557 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1558 // This frame should not be received.
1559 EXPECT_TRUE(WaitAndSendFrame(
1560 static_cast<int>(interval/talk_base::kNumNanosecsPerMillisec)));
1561 talk_base::Thread::Current()->ProcessMessages(500);
1562 EXPECT_EQ(1, renderer_.num_rendered_frames());
1565 // Tests that we can mute and unmute the channel properly.
1567 int frame_count = 0;
1568 EXPECT_TRUE(SetDefaultCodec());
1569 cricket::FakeVideoCapturer video_capturer;
1570 video_capturer.Start(
1571 cricket::VideoFormat(
1573 cricket::VideoFormat::FpsToInterval(30),
1574 cricket::FOURCC_I420));
1575 EXPECT_TRUE(channel_->SetCapturer(kSsrc, &video_capturer));
1576 EXPECT_TRUE(SetSend(true));
1577 EXPECT_TRUE(channel_->SetRender(true));
1578 EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
1580 // Mute the channel and expect black output frame.
1581 EXPECT_TRUE(channel_->MuteStream(kSsrc, true));
1582 EXPECT_TRUE(video_capturer.CaptureFrame());
1584 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1585 EXPECT_TRUE(renderer_.black_frame());
1587 // Unmute the channel and expect non-black output frame.
1588 EXPECT_TRUE(channel_->MuteStream(kSsrc, false));
1589 EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
1590 EXPECT_TRUE(video_capturer.CaptureFrame());
1592 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1593 EXPECT_FALSE(renderer_.black_frame());
1595 // Test that we can also Mute using the correct send stream SSRC.
1596 EXPECT_TRUE(channel_->MuteStream(kSsrc, true));
1597 EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
1598 EXPECT_TRUE(video_capturer.CaptureFrame());
1600 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1601 EXPECT_TRUE(renderer_.black_frame());
1603 EXPECT_TRUE(channel_->MuteStream(kSsrc, false));
1604 EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
1605 EXPECT_TRUE(video_capturer.CaptureFrame());
1607 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1608 EXPECT_FALSE(renderer_.black_frame());
1610 // Test that muting an invalid stream fails.
1611 EXPECT_FALSE(channel_->MuteStream(kSsrc+1, true));
1612 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1615 // Test that multiple send streams can be created and deleted properly.
1616 void MultipleSendStreams() {
1617 // Remove stream added in Setup. I.e. remove stream corresponding to default
1619 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1620 const unsigned int kSsrcsSize = sizeof(kSsrcs4)/sizeof(kSsrcs4[0]);
1621 for (unsigned int i = 0; i < kSsrcsSize; ++i) {
1622 EXPECT_TRUE(channel_->AddSendStream(
1623 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1625 // Delete one of the non default channel streams, let the destructor delete
1626 // the remaining ones.
1627 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
1628 // Stream should already be deleted.
1629 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
1633 // Two streams one channel tests.
1635 // Tests that we can send and receive frames.
1636 void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
1637 SetUpSecondStream();
1638 // Test sending and receiving on first stream.
1639 SendAndReceive(codec);
1640 // Test sending and receiving on second stream.
1641 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout);
1642 EXPECT_EQ(2, NumRtpPackets());
1643 EXPECT_EQ(1, renderer2_.num_rendered_frames());
1646 // Disconnect the first stream and re-use it with another SSRC
1647 void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) {
1648 SetUpSecondStream();
1649 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
1650 EXPECT_FALSE(channel_->RemoveRecvStream(kSsrc));
1651 // SSRC 0 should map to the "default" stream. I.e. the first added stream.
1652 EXPECT_TRUE(channel_->RemoveSendStream(0));
1653 // Make sure that the first added stream was indeed the "default" stream.
1654 EXPECT_FALSE(channel_->RemoveSendStream(kSsrc));
1655 // Make sure that the "default" stream is indeed removed and that removing
1656 // the default stream has an effect.
1657 EXPECT_FALSE(channel_->RemoveSendStream(0));
1659 SetRendererAsDefault();
1660 EXPECT_TRUE(channel_->AddSendStream(
1661 cricket::StreamParams::CreateLegacy(kSsrc)));
1662 EXPECT_FALSE(channel_->AddSendStream(
1663 cricket::StreamParams::CreateLegacy(kSsrc)));
1664 EXPECT_TRUE(channel_->AddRecvStream(
1665 cricket::StreamParams::CreateLegacy(kSsrc)));
1666 EXPECT_FALSE(channel_->AddRecvStream(
1667 cricket::StreamParams::CreateLegacy(kSsrc)));
1669 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
1671 SendAndReceive(codec);
1672 EXPECT_TRUE(channel_->RemoveSendStream(0));
1675 VideoEngineOverride<E> engine_;
1676 talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
1677 talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_2_;
1678 talk_base::scoped_ptr<C> channel_;
1679 cricket::FakeNetworkInterface network_interface_;
1680 cricket::FakeVideoRenderer renderer_;
1681 cricket::VideoMediaChannel::Error media_error_;
1683 // Used by test cases where 2 streams are run on the same channel.
1684 cricket::FakeVideoRenderer renderer2_;
1687 #endif // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT