Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(93)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: talk/media/base/videoengine_unittest.h

Issue 1587193006: Move talk/media to webrtc/media (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Rename back test to libjingle_media_unittest Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« talk/build/common.gypi ('K') | « talk/media/base/videocommon_unittest.cc ('k') | talk/media/base/videoframe.h » ('j') | webrtc/api/api.gyp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * libjingle
3 * Copyright 2014 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifndef TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ // NOLINT
29 #define TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_
30
31 #include <string>
32 #include <vector>
33
34 #include "talk/media/base/fakenetworkinterface.h"
35 #include "talk/media/base/fakevideocapturer.h"
36 #include "talk/media/base/fakevideorenderer.h"
37 #include "talk/media/base/mediachannel.h"
38 #include "talk/media/base/streamparams.h"
39 #include "talk/media/webrtc/fakewebrtccall.h"
40 #include "webrtc/base/bytebuffer.h"
41 #include "webrtc/base/gunit.h"
42 #include "webrtc/base/timeutils.h"
43 #include "webrtc/call.h"
44
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()); \
50
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()); \
56
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());
62
63 static const uint32_t kTimeout = 5000U;
64 static const uint32_t kDefaultReceiveSsrc = 0;
65 static const uint32_t kSsrc = 1234u;
66 static const uint32_t kRtxSsrc = 4321u;
67 static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
68
69 inline bool IsEqualRes(const cricket::VideoCodec& a, int w, int h, int fps) {
70 return a.width == w && a.height == h && a.framerate == fps;
71 }
72
73 inline bool IsEqualCodec(const cricket::VideoCodec& a,
74 const cricket::VideoCodec& b) {
75 return a.id == b.id && a.name == b.name &&
76 IsEqualRes(a, b.width, b.height, b.framerate);
77 }
78
79 namespace std {
80 inline std::ostream& operator<<(std::ostream& s, const cricket::VideoCodec& c) {
81 s << "{" << c.name << "(" << c.id << "), "
82 << c.width << "x" << c.height << "x" << c.framerate << "}";
83 return s;
84 }
85 } // namespace std
86
87 inline int TimeBetweenSend(const cricket::VideoCodec& codec) {
88 return static_cast<int>(
89 cricket::VideoFormat::FpsToInterval(codec.framerate) /
90 rtc::kNumNanosecsPerMillisec);
91 }
92
93 // Fake video engine that makes it possible to test enabling and disabling
94 // capturer (checking that the engine state is updated and that the capturer
95 // is indeed capturing) without having to create a channel. It also makes it
96 // possible to test that the media processors are indeed being called when
97 // registered.
98 template<class T>
99 class VideoEngineOverride : public T {
100 public:
101 VideoEngineOverride() : T() {
102 }
103 virtual ~VideoEngineOverride() {
104 }
105 bool is_camera_on() const { return T::GetVideoCapturer()->IsRunning(); }
106 void set_has_senders(bool has_senders) {
107 cricket::VideoCapturer* video_capturer = T::GetVideoCapturer();
108 if (has_senders) {
109 video_capturer->SignalVideoFrame.connect(this,
110 &VideoEngineOverride<T>::OnLocalFrame);
111 } else {
112 video_capturer->SignalVideoFrame.disconnect(this);
113 }
114 }
115 void OnLocalFrame(cricket::VideoCapturer*,
116 const cricket::VideoFrame*) {
117 }
118 void OnLocalFrameFormat(cricket::VideoCapturer*,
119 const cricket::VideoFormat*) {
120 }
121
122 void TriggerMediaFrame(uint32_t ssrc,
123 cricket::VideoFrame* frame,
124 bool* drop_frame) {
125 T::SignalMediaFrame(ssrc, frame, drop_frame);
126 }
127 };
128
129 template<class E, class C>
130 class VideoMediaChannelTest : public testing::Test,
131 public sigslot::has_slots<> {
132 protected:
133 VideoMediaChannelTest<E, C>()
134 : call_(webrtc::Call::Create(webrtc::Call::Config())) {}
135
136 virtual cricket::VideoCodec DefaultCodec() = 0;
137
138 virtual cricket::StreamParams DefaultSendStreamParams() {
139 return cricket::StreamParams::CreateLegacy(kSsrc);
140 }
141
142 virtual void SetUp() {
143 cricket::Device device("test", "device");
144 engine_.Init();
145 channel_.reset(
146 engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
147 EXPECT_TRUE(channel_.get() != NULL);
148 network_interface_.SetDestination(channel_.get());
149 channel_->SetInterface(&network_interface_);
150 media_error_ = cricket::VideoMediaChannel::ERROR_NONE;
151 cricket::VideoRecvParameters parameters;
152 parameters.codecs = engine_.codecs();
153 channel_->SetRecvParameters(parameters);
154 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
155 video_capturer_.reset(CreateFakeVideoCapturer());
156 cricket::VideoFormat format(640, 480,
157 cricket::VideoFormat::FpsToInterval(30),
158 cricket::FOURCC_I420);
159 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format));
160 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
161 }
162
163 virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() {
164 return new cricket::FakeVideoCapturer();
165 }
166
167 // Utility method to setup an additional stream to send and receive video.
168 // Used to test send and recv between two streams.
169 void SetUpSecondStream() {
170 SetUpSecondStreamWithNoRecv();
171 // Setup recv for second stream.
172 EXPECT_TRUE(channel_->AddRecvStream(
173 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
174 // Make the second renderer available for use by a new stream.
175 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_));
176 }
177 // Setup an additional stream just to send video. Defer add recv stream.
178 // This is required if you want to test unsignalled recv of video rtp packets.
179 void SetUpSecondStreamWithNoRecv() {
180 // SetUp() already added kSsrc make sure duplicate SSRCs cant be added.
181 EXPECT_TRUE(channel_->AddRecvStream(
182 cricket::StreamParams::CreateLegacy(kSsrc)));
183 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
184 EXPECT_FALSE(channel_->AddSendStream(
185 cricket::StreamParams::CreateLegacy(kSsrc)));
186 EXPECT_TRUE(channel_->AddSendStream(
187 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
188 // We dont add recv for the second stream.
189
190 // Setup the receive and renderer for second stream after send.
191 video_capturer_2_.reset(CreateFakeVideoCapturer());
192 cricket::VideoFormat format(640, 480,
193 cricket::VideoFormat::FpsToInterval(30),
194 cricket::FOURCC_I420);
195 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(format));
196
197 EXPECT_TRUE(channel_->SetCapturer(kSsrc + 2, video_capturer_2_.get()));
198 }
199 virtual void TearDown() {
200 channel_.reset();
201 }
202 bool SetDefaultCodec() {
203 return SetOneCodec(DefaultCodec());
204 }
205
206 bool SetOneCodec(int pt, const char* name, int w, int h, int fr) {
207 return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr, 0));
208 }
209 bool SetOneCodec(const cricket::VideoCodec& codec) {
210 cricket::VideoFormat capture_format(codec.width, codec.height,
211 cricket::VideoFormat::FpsToInterval(codec.framerate),
212 cricket::FOURCC_I420);
213
214 if (video_capturer_) {
215 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format));
216 }
217 if (video_capturer_2_) {
218 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format));
219 }
220
221 bool sending = channel_->sending();
222 bool success = SetSend(false);
223 if (success) {
224 cricket::VideoSendParameters parameters;
225 parameters.codecs.push_back(codec);
226 success = channel_->SetSendParameters(parameters);
227 }
228 if (success) {
229 success = SetSend(sending);
230 }
231 return success;
232 }
233 bool SetSend(bool send) {
234 return channel_->SetSend(send);
235 }
236 bool SetSendStreamFormat(uint32_t ssrc, const cricket::VideoCodec& codec) {
237 return channel_->SetSendStreamFormat(ssrc, cricket::VideoFormat(
238 codec.width, codec.height,
239 cricket::VideoFormat::FpsToInterval(codec.framerate),
240 cricket::FOURCC_ANY));
241 }
242 int DrainOutgoingPackets() {
243 int packets = 0;
244 do {
245 packets = NumRtpPackets();
246 // 100 ms should be long enough.
247 rtc::Thread::Current()->ProcessMessages(100);
248 } while (NumRtpPackets() > packets);
249 return NumRtpPackets();
250 }
251 bool SendFrame() {
252 if (video_capturer_2_) {
253 video_capturer_2_->CaptureFrame();
254 }
255 return video_capturer_.get() &&
256 video_capturer_->CaptureFrame();
257 }
258 bool WaitAndSendFrame(int wait_ms) {
259 bool ret = rtc::Thread::Current()->ProcessMessages(wait_ms);
260 ret &= SendFrame();
261 return ret;
262 }
263 // Sends frames and waits for the decoder to be fully initialized.
264 // Returns the number of frames that were sent.
265 int WaitForDecoder() {
266 #if defined(HAVE_OPENMAX)
267 // Send enough frames for the OpenMAX decoder to continue processing, and
268 // return the number of frames sent.
269 // Send frames for a full kTimeout's worth of 15fps video.
270 int frame_count = 0;
271 while (frame_count < static_cast<int>(kTimeout) / 66) {
272 EXPECT_TRUE(WaitAndSendFrame(66));
273 ++frame_count;
274 }
275 return frame_count;
276 #else
277 return 0;
278 #endif
279 }
280 bool SendCustomVideoFrame(int w, int h) {
281 if (!video_capturer_.get()) return false;
282 return video_capturer_->CaptureCustomFrame(w, h, cricket::FOURCC_I420);
283 }
284 int NumRtpBytes() {
285 return network_interface_.NumRtpBytes();
286 }
287 int NumRtpBytes(uint32_t ssrc) {
288 return network_interface_.NumRtpBytes(ssrc);
289 }
290 int NumRtpPackets() {
291 return network_interface_.NumRtpPackets();
292 }
293 int NumRtpPackets(uint32_t ssrc) {
294 return network_interface_.NumRtpPackets(ssrc);
295 }
296 int NumSentSsrcs() {
297 return network_interface_.NumSentSsrcs();
298 }
299 const rtc::Buffer* GetRtpPacket(int index) {
300 return network_interface_.GetRtpPacket(index);
301 }
302 int NumRtcpPackets() {
303 return network_interface_.NumRtcpPackets();
304 }
305 const rtc::Buffer* GetRtcpPacket(int index) {
306 return network_interface_.GetRtcpPacket(index);
307 }
308 static int GetPayloadType(const rtc::Buffer* p) {
309 int pt = -1;
310 ParseRtpPacket(p, NULL, &pt, NULL, NULL, NULL, NULL);
311 return pt;
312 }
313 static bool ParseRtpPacket(const rtc::Buffer* p,
314 bool* x,
315 int* pt,
316 int* seqnum,
317 uint32_t* tstamp,
318 uint32_t* ssrc,
319 std::string* payload) {
320 rtc::ByteBuffer buf(*p);
321 uint8_t u08 = 0;
322 uint16_t u16 = 0;
323 uint32_t u32 = 0;
324
325 // Read X and CC fields.
326 if (!buf.ReadUInt8(&u08)) return false;
327 bool extension = ((u08 & 0x10) != 0);
328 uint8_t cc = (u08 & 0x0F);
329 if (x) *x = extension;
330
331 // Read PT field.
332 if (!buf.ReadUInt8(&u08)) return false;
333 if (pt) *pt = (u08 & 0x7F);
334
335 // Read Sequence Number field.
336 if (!buf.ReadUInt16(&u16)) return false;
337 if (seqnum) *seqnum = u16;
338
339 // Read Timestamp field.
340 if (!buf.ReadUInt32(&u32)) return false;
341 if (tstamp) *tstamp = u32;
342
343 // Read SSRC field.
344 if (!buf.ReadUInt32(&u32)) return false;
345 if (ssrc) *ssrc = u32;
346
347 // Skip CSRCs.
348 for (uint8_t i = 0; i < cc; ++i) {
349 if (!buf.ReadUInt32(&u32)) return false;
350 }
351
352 // Skip extension header.
353 if (extension) {
354 // Read Profile-specific extension header ID
355 if (!buf.ReadUInt16(&u16)) return false;
356
357 // Read Extension header length
358 if (!buf.ReadUInt16(&u16)) return false;
359 uint16_t ext_header_len = u16;
360
361 // Read Extension header
362 for (uint16_t i = 0; i < ext_header_len; ++i) {
363 if (!buf.ReadUInt32(&u32)) return false;
364 }
365 }
366
367 if (payload) {
368 return buf.ReadString(payload, buf.Length());
369 }
370 return true;
371 }
372
373 // Parse all RTCP packet, from start_index to stop_index, and count how many
374 // FIR (PT=206 and FMT=4 according to RFC 5104). If successful, set the count
375 // and return true.
376 bool CountRtcpFir(int start_index, int stop_index, int* fir_count) {
377 int count = 0;
378 for (int i = start_index; i < stop_index; ++i) {
379 rtc::scoped_ptr<const rtc::Buffer> p(GetRtcpPacket(i));
380 rtc::ByteBuffer buf(*p);
381 size_t total_len = 0;
382 // The packet may be a compound RTCP packet.
383 while (total_len < p->size()) {
384 // Read FMT, type and length.
385 uint8_t fmt = 0;
386 uint8_t type = 0;
387 uint16_t length = 0;
388 if (!buf.ReadUInt8(&fmt)) return false;
389 fmt &= 0x1F;
390 if (!buf.ReadUInt8(&type)) return false;
391 if (!buf.ReadUInt16(&length)) return false;
392 buf.Consume(length * 4); // Skip RTCP data.
393 total_len += (length + 1) * 4;
394 if ((192 == type) || ((206 == type) && (4 == fmt))) {
395 ++count;
396 }
397 }
398 }
399
400 if (fir_count) {
401 *fir_count = count;
402 }
403 return true;
404 }
405
406 void OnVideoChannelError(uint32_t ssrc,
407 cricket::VideoMediaChannel::Error error) {
408 media_error_ = error;
409 }
410
411 // Test that SetSend works.
412 void SetSend() {
413 EXPECT_FALSE(channel_->sending());
414 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
415 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
416 EXPECT_FALSE(channel_->sending());
417 EXPECT_TRUE(SetSend(true));
418 EXPECT_TRUE(channel_->sending());
419 EXPECT_TRUE(SendFrame());
420 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
421 EXPECT_TRUE(SetSend(false));
422 EXPECT_FALSE(channel_->sending());
423 }
424 // Test that SetSend fails without codecs being set.
425 void SetSendWithoutCodecs() {
426 EXPECT_FALSE(channel_->sending());
427 EXPECT_FALSE(SetSend(true));
428 EXPECT_FALSE(channel_->sending());
429 }
430 // Test that we properly set the send and recv buffer sizes by the time
431 // SetSend is called.
432 void SetSendSetsTransportBufferSizes() {
433 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
434 EXPECT_TRUE(SetSend(true));
435 EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
436 EXPECT_EQ(64 * 1024, network_interface_.recvbuf_size());
437 }
438 // Tests that we can send frames and the right payload type is used.
439 void Send(const cricket::VideoCodec& codec) {
440 EXPECT_TRUE(SetOneCodec(codec));
441 EXPECT_TRUE(SetSend(true));
442 EXPECT_TRUE(SendFrame());
443 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
444 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
445 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
446 }
447 // Tests that we can send and receive frames.
448 void SendAndReceive(const cricket::VideoCodec& codec) {
449 EXPECT_TRUE(SetOneCodec(codec));
450 EXPECT_TRUE(SetSend(true));
451 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
452 EXPECT_EQ(0, renderer_.num_rendered_frames());
453 EXPECT_TRUE(SendFrame());
454 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
455 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
456 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
457 }
458 // Tests that we only get a VideoRenderer::SetSize() callback when needed.
459 void SendManyResizeOnce() {
460 cricket::VideoCodec codec(DefaultCodec());
461 EXPECT_TRUE(SetOneCodec(codec));
462 EXPECT_TRUE(SetSend(true));
463 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
464 EXPECT_EQ(0, renderer_.num_rendered_frames());
465 EXPECT_TRUE(WaitAndSendFrame(30));
466 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
467 EXPECT_TRUE(WaitAndSendFrame(30));
468 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
469 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
470 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
471 EXPECT_EQ(1, renderer_.num_set_sizes());
472
473 codec.width /= 2;
474 codec.height /= 2;
475 EXPECT_TRUE(SetOneCodec(codec));
476 EXPECT_TRUE(WaitAndSendFrame(30));
477 EXPECT_FRAME_WAIT(3, codec.width, codec.height, kTimeout);
478 EXPECT_EQ(2, renderer_.num_set_sizes());
479 }
480 void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec,
481 int duration_sec, int fps) {
482 EXPECT_TRUE(SetOneCodec(codec));
483 EXPECT_TRUE(SetSend(true));
484 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
485 EXPECT_EQ(0, renderer_.num_rendered_frames());
486 for (int i = 0; i < duration_sec; ++i) {
487 for (int frame = 1; frame <= fps; ++frame) {
488 EXPECT_TRUE(WaitAndSendFrame(1000 / fps));
489 EXPECT_FRAME_WAIT(frame + i * fps, codec.width, codec.height, kTimeout);
490 }
491 }
492 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
493 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
494 }
495
496 // Test that stats work properly for a 1-1 call.
497 void GetStats() {
498 const int kDurationSec = 3;
499 const int kFps = 10;
500 SendReceiveManyAndGetStats(DefaultCodec(), kDurationSec, kFps);
501
502 cricket::VideoMediaInfo info;
503 EXPECT_TRUE(channel_->GetStats(&info));
504
505 ASSERT_EQ(1U, info.senders.size());
506 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
507 // For webrtc, bytes_sent does not include the RTP header length.
508 EXPECT_GT(info.senders[0].bytes_sent, 0);
509 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent);
510 EXPECT_EQ(0.0, info.senders[0].fraction_lost);
511 EXPECT_EQ(0, info.senders[0].firs_rcvd);
512 EXPECT_EQ(0, info.senders[0].plis_rcvd);
513 EXPECT_EQ(0, info.senders[0].nacks_rcvd);
514 EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width);
515 EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height);
516 EXPECT_GT(info.senders[0].framerate_input, 0);
517 EXPECT_GT(info.senders[0].framerate_sent, 0);
518
519 ASSERT_EQ(1U, info.receivers.size());
520 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
521 EXPECT_EQ(1U, info.receivers[0].ssrcs().size());
522 EXPECT_EQ(info.senders[0].ssrcs()[0], info.receivers[0].ssrcs()[0]);
523 EXPECT_EQ(NumRtpBytes(), info.receivers[0].bytes_rcvd);
524 EXPECT_EQ(NumRtpPackets(), info.receivers[0].packets_rcvd);
525 EXPECT_EQ(0.0, info.receivers[0].fraction_lost);
526 EXPECT_EQ(0, info.receivers[0].packets_lost);
527 // TODO(asapersson): Not set for webrtc. Handle missing stats.
528 // EXPECT_EQ(0, info.receivers[0].packets_concealed);
529 EXPECT_EQ(0, info.receivers[0].firs_sent);
530 EXPECT_EQ(0, info.receivers[0].plis_sent);
531 EXPECT_EQ(0, info.receivers[0].nacks_sent);
532 EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width);
533 EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height);
534 EXPECT_GT(info.receivers[0].framerate_rcvd, 0);
535 EXPECT_GT(info.receivers[0].framerate_decoded, 0);
536 EXPECT_GT(info.receivers[0].framerate_output, 0);
537 }
538
539 cricket::VideoSenderInfo GetSenderStats(size_t i) {
540 cricket::VideoMediaInfo info;
541 EXPECT_TRUE(channel_->GetStats(&info));
542 return info.senders[i];
543 }
544
545 cricket::VideoReceiverInfo GetReceiverStats(size_t i) {
546 cricket::VideoMediaInfo info;
547 EXPECT_TRUE(channel_->GetStats(&info));
548 return info.receivers[i];
549 }
550
551 // Test that stats work properly for a conf call with multiple recv streams.
552 void GetStatsMultipleRecvStreams() {
553 cricket::FakeVideoRenderer renderer1, renderer2;
554 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
555 cricket::VideoSendParameters parameters;
556 parameters.codecs.push_back(DefaultCodec());
557 parameters.options.conference_mode = rtc::Optional<bool>(true);
558 EXPECT_TRUE(channel_->SetSendParameters(parameters));
559 EXPECT_TRUE(SetSend(true));
560 EXPECT_TRUE(channel_->AddRecvStream(
561 cricket::StreamParams::CreateLegacy(1)));
562 EXPECT_TRUE(channel_->AddRecvStream(
563 cricket::StreamParams::CreateLegacy(2)));
564 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
565 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
566 EXPECT_EQ(0, renderer1.num_rendered_frames());
567 EXPECT_EQ(0, renderer2.num_rendered_frames());
568 std::vector<uint32_t> ssrcs;
569 ssrcs.push_back(1);
570 ssrcs.push_back(2);
571 network_interface_.SetConferenceMode(true, ssrcs);
572 EXPECT_TRUE(SendFrame());
573 EXPECT_FRAME_ON_RENDERER_WAIT(
574 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
575 EXPECT_FRAME_ON_RENDERER_WAIT(
576 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
577
578 EXPECT_TRUE(channel_->SetSend(false));
579
580 cricket::VideoMediaInfo info;
581 EXPECT_TRUE(channel_->GetStats(&info));
582 ASSERT_EQ(1U, info.senders.size());
583 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
584 // For webrtc, bytes_sent does not include the RTP header length.
585 EXPECT_GT(GetSenderStats(0).bytes_sent, 0);
586 EXPECT_EQ_WAIT(NumRtpPackets(), GetSenderStats(0).packets_sent, kTimeout);
587 EXPECT_EQ(DefaultCodec().width, GetSenderStats(0).send_frame_width);
588 EXPECT_EQ(DefaultCodec().height, GetSenderStats(0).send_frame_height);
589
590 ASSERT_EQ(2U, info.receivers.size());
591 for (size_t i = 0; i < info.receivers.size(); ++i) {
592 EXPECT_EQ(1U, GetReceiverStats(i).ssrcs().size());
593 EXPECT_EQ(i + 1, GetReceiverStats(i).ssrcs()[0]);
594 EXPECT_EQ_WAIT(NumRtpBytes(), GetReceiverStats(i).bytes_rcvd, kTimeout);
595 EXPECT_EQ_WAIT(NumRtpPackets(), GetReceiverStats(i).packets_rcvd,
596 kTimeout);
597 EXPECT_EQ(DefaultCodec().width, GetReceiverStats(i).frame_width);
598 EXPECT_EQ(DefaultCodec().height, GetReceiverStats(i).frame_height);
599 }
600 }
601 // Test that stats work properly for a conf call with multiple send streams.
602 void GetStatsMultipleSendStreams() {
603 // Normal setup; note that we set the SSRC explicitly to ensure that
604 // it will come first in the senders map.
605 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
606 cricket::VideoSendParameters parameters;
607 parameters.codecs.push_back(DefaultCodec());
608 parameters.options.conference_mode = rtc::Optional<bool>(true);
609 EXPECT_TRUE(channel_->SetSendParameters(parameters));
610 EXPECT_TRUE(channel_->AddRecvStream(
611 cricket::StreamParams::CreateLegacy(kSsrc)));
612 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
613 channel_->UpdateAspectRatio(640, 400);
614 EXPECT_TRUE(SetSend(true));
615 EXPECT_TRUE(SendFrame());
616 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
617 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
618
619 // Add an additional capturer, and hook up a renderer to receive it.
620 cricket::FakeVideoRenderer renderer2;
621 rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
622 CreateFakeVideoCapturer());
623 capturer->SetScreencast(true);
624 const int kTestWidth = 160;
625 const int kTestHeight = 120;
626 cricket::VideoFormat format(kTestWidth, kTestHeight,
627 cricket::VideoFormat::FpsToInterval(5),
628 cricket::FOURCC_I420);
629 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
630 EXPECT_TRUE(channel_->AddSendStream(
631 cricket::StreamParams::CreateLegacy(5678)));
632 EXPECT_TRUE(channel_->SetCapturer(5678, capturer.get()));
633 EXPECT_TRUE(channel_->AddRecvStream(
634 cricket::StreamParams::CreateLegacy(5678)));
635 EXPECT_TRUE(channel_->SetRenderer(5678, &renderer2));
636 EXPECT_TRUE(capturer->CaptureCustomFrame(
637 kTestWidth, kTestHeight, cricket::FOURCC_I420));
638 EXPECT_FRAME_ON_RENDERER_WAIT(
639 renderer2, 1, kTestWidth, kTestHeight, kTimeout);
640
641 // Get stats, and make sure they are correct for two senders. We wait until
642 // the number of expected packets have been sent to avoid races where we
643 // check stats before it has been updated.
644 cricket::VideoMediaInfo info;
645 for (uint32_t i = 0; i < kTimeout; ++i) {
646 rtc::Thread::Current()->ProcessMessages(1);
647 EXPECT_TRUE(channel_->GetStats(&info));
648 ASSERT_EQ(2U, info.senders.size());
649 if (info.senders[0].packets_sent + info.senders[1].packets_sent ==
650 NumRtpPackets()) {
651 // Stats have been updated for both sent frames, expectations can be
652 // checked now.
653 break;
654 }
655 }
656 EXPECT_EQ(NumRtpPackets(),
657 info.senders[0].packets_sent + info.senders[1].packets_sent)
658 << "Timed out while waiting for packet counts for all sent packets.";
659 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
660 EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]);
661 EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width);
662 EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height);
663 EXPECT_EQ(1U, info.senders[1].ssrcs().size());
664 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]);
665 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width);
666 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height);
667 // The capturer must be unregistered here as it runs out of it's scope next.
668 EXPECT_TRUE(channel_->SetCapturer(5678, NULL));
669 }
670
671 // Test that we can set the bandwidth.
672 void SetSendBandwidth() {
673 cricket::VideoSendParameters parameters;
674 parameters.codecs.push_back(DefaultCodec());
675 parameters.max_bandwidth_bps = -1; // <= 0 means unlimited.
676 EXPECT_TRUE(channel_->SetSendParameters(parameters));
677 parameters.max_bandwidth_bps = 128 * 1024;
678 EXPECT_TRUE(channel_->SetSendParameters(parameters));
679 }
680 // Test that we can set the SSRC for the default send source.
681 void SetSendSsrc() {
682 EXPECT_TRUE(SetDefaultCodec());
683 EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
684 EXPECT_TRUE(SetSend(true));
685 EXPECT_TRUE(SendFrame());
686 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
687 uint32_t ssrc = 0;
688 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
689 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
690 EXPECT_EQ(kSsrc, ssrc);
691 // Packets are being paced out, so these can mismatch between the first and
692 // second call to NumRtpPackets until pending packets are paced out.
693 EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(ssrc), kTimeout);
694 EXPECT_EQ_WAIT(NumRtpBytes(), NumRtpBytes(ssrc), kTimeout);
695 EXPECT_EQ(1, NumSentSsrcs());
696 EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
697 EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
698 }
699 // Test that we can set the SSRC even after codecs are set.
700 void SetSendSsrcAfterSetCodecs() {
701 // Remove stream added in Setup.
702 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
703 EXPECT_TRUE(SetDefaultCodec());
704 EXPECT_TRUE(channel_->AddSendStream(
705 cricket::StreamParams::CreateLegacy(999)));
706 EXPECT_TRUE(channel_->SetCapturer(999u, video_capturer_.get()));
707 EXPECT_TRUE(SetSendStreamFormat(999u, DefaultCodec()));
708 EXPECT_TRUE(SetSend(true));
709 EXPECT_TRUE(WaitAndSendFrame(0));
710 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
711 uint32_t ssrc = 0;
712 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
713 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
714 EXPECT_EQ(999u, ssrc);
715 // Packets are being paced out, so these can mismatch between the first and
716 // second call to NumRtpPackets until pending packets are paced out.
717 EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(ssrc), kTimeout);
718 EXPECT_EQ_WAIT(NumRtpBytes(), NumRtpBytes(ssrc), kTimeout);
719 EXPECT_EQ(1, NumSentSsrcs());
720 EXPECT_EQ(0, NumRtpPackets(kSsrc));
721 EXPECT_EQ(0, NumRtpBytes(kSsrc));
722 }
723 // Test that we can set the default video renderer before and after
724 // media is received.
725 void SetRenderer() {
726 uint8_t data1[] = {
727 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
728
729 rtc::Buffer packet1(data1, sizeof(data1));
730 rtc::SetBE32(packet1.data() + 8, kSsrc);
731 channel_->SetRenderer(kDefaultReceiveSsrc, NULL);
732 EXPECT_TRUE(SetDefaultCodec());
733 EXPECT_TRUE(SetSend(true));
734 EXPECT_EQ(0, renderer_.num_rendered_frames());
735 channel_->OnPacketReceived(&packet1, rtc::PacketTime());
736 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
737 EXPECT_TRUE(SendFrame());
738 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
739 }
740
741 // Tests empty StreamParams is rejected.
742 void RejectEmptyStreamParams() {
743 // Remove the send stream that was added during Setup.
744 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
745
746 cricket::StreamParams empty;
747 EXPECT_FALSE(channel_->AddSendStream(empty));
748 EXPECT_TRUE(channel_->AddSendStream(
749 cricket::StreamParams::CreateLegacy(789u)));
750 }
751
752 // Tests setting up and configuring a send stream.
753 void AddRemoveSendStreams() {
754 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
755 EXPECT_TRUE(SetSend(true));
756 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
757 EXPECT_TRUE(SendFrame());
758 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
759 EXPECT_GT(NumRtpPackets(), 0);
760 uint32_t ssrc = 0;
761 size_t last_packet = NumRtpPackets() - 1;
762 rtc::scoped_ptr<const rtc::Buffer>
763 p(GetRtpPacket(static_cast<int>(last_packet)));
764 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
765 EXPECT_EQ(kSsrc, ssrc);
766
767 // Remove the send stream that was added during Setup.
768 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
769 int rtp_packets = NumRtpPackets();
770
771 EXPECT_TRUE(channel_->AddSendStream(
772 cricket::StreamParams::CreateLegacy(789u)));
773 EXPECT_TRUE(channel_->SetCapturer(789u, video_capturer_.get()));
774 EXPECT_EQ(rtp_packets, NumRtpPackets());
775 // Wait 30ms to guarantee the engine does not drop the frame.
776 EXPECT_TRUE(WaitAndSendFrame(30));
777 EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout);
778
779 last_packet = NumRtpPackets() - 1;
780 p.reset(GetRtpPacket(static_cast<int>(last_packet)));
781 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
782 EXPECT_EQ(789u, ssrc);
783 }
784
785 // Tests setting up and configuring multiple incoming streams.
786 void AddRemoveRecvStreams() {
787 cricket::FakeVideoRenderer renderer1, renderer2;
788 cricket::VideoSendParameters parameters;
789 parameters.codecs.push_back(DefaultCodec());
790 EXPECT_TRUE(channel_->SetSendParameters(parameters));
791
792 // Ensure we can't set the renderer on a non-existent stream.
793 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
794 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
795 cricket::VideoRenderer* renderer;
796 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
797 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
798
799 // Ensure we can add streams.
800 EXPECT_TRUE(channel_->AddRecvStream(
801 cricket::StreamParams::CreateLegacy(1)));
802 EXPECT_TRUE(channel_->AddRecvStream(
803 cricket::StreamParams::CreateLegacy(2)));
804 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
805 EXPECT_TRUE(renderer == NULL);
806 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
807 EXPECT_TRUE(NULL == renderer);
808
809 // Ensure we can now set the renderers.
810 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
811 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
812 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
813 EXPECT_TRUE(&renderer1 == renderer);
814 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
815 EXPECT_TRUE(&renderer2 == renderer);
816
817 // Ensure we can change the renderers if needed.
818 EXPECT_TRUE(channel_->SetRenderer(1, &renderer2));
819 EXPECT_TRUE(channel_->SetRenderer(2, &renderer1));
820 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
821 EXPECT_TRUE(&renderer2 == renderer);
822 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
823 EXPECT_TRUE(&renderer1 == renderer);
824
825 EXPECT_TRUE(channel_->RemoveRecvStream(2));
826 EXPECT_TRUE(channel_->RemoveRecvStream(1));
827 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
828 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
829 }
830
831 // Tests setting up and configuring multiple incoming streams in a
832 // non-conference call.
833 void AddRemoveRecvStreamsNoConference() {
834 cricket::FakeVideoRenderer renderer1, renderer2;
835 // Ensure we can't set the renderer on a non-existent stream.
836 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
837 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
838 cricket::VideoRenderer* renderer;
839 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
840 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
841
842 // Ensure we can add streams.
843 EXPECT_TRUE(channel_->AddRecvStream(
844 cricket::StreamParams::CreateLegacy(1)));
845 EXPECT_TRUE(channel_->AddRecvStream(
846 cricket::StreamParams::CreateLegacy(2)));
847 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
848 // Verify the first AddRecvStream hook up to the default renderer.
849 EXPECT_TRUE(renderer == NULL);
850 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
851 EXPECT_TRUE(NULL == renderer);
852
853 // Ensure we can now set the renderers.
854 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
855 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
856 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
857 EXPECT_TRUE(&renderer1 == renderer);
858 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
859 EXPECT_TRUE(&renderer2 == renderer);
860
861 // Ensure we can change the renderers if needed.
862 EXPECT_TRUE(channel_->SetRenderer(1, &renderer2));
863 EXPECT_TRUE(channel_->SetRenderer(2, &renderer1));
864 EXPECT_TRUE(channel_->GetRenderer(1, &renderer));
865 EXPECT_TRUE(&renderer2 == renderer);
866 EXPECT_TRUE(channel_->GetRenderer(2, &renderer));
867 EXPECT_TRUE(&renderer1 == renderer);
868
869 EXPECT_TRUE(channel_->RemoveRecvStream(2));
870 EXPECT_TRUE(channel_->RemoveRecvStream(1));
871 EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
872 EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
873 }
874
875 // Test that no frames are rendered after the receive stream have been
876 // removed.
877 void AddRemoveRecvStreamAndRender() {
878 cricket::FakeVideoRenderer renderer1;
879 EXPECT_TRUE(SetDefaultCodec());
880 EXPECT_TRUE(SetSend(true));
881 EXPECT_TRUE(channel_->AddRecvStream(
882 cricket::StreamParams::CreateLegacy(kSsrc)));
883 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer1));
884
885 EXPECT_TRUE(SendFrame());
886 EXPECT_FRAME_ON_RENDERER_WAIT(
887 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
888 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
889 // Send three more frames. This is to avoid that the test might be flaky
890 // due to frame dropping.
891 for (size_t i = 0; i < 3; ++i)
892 EXPECT_TRUE(WaitAndSendFrame(100));
893
894 // Test that no more frames have been rendered.
895 EXPECT_EQ(1, renderer1.num_rendered_frames());
896
897 // Re-add the stream again and make sure it renders.
898 EXPECT_TRUE(channel_->AddRecvStream(
899 cricket::StreamParams::CreateLegacy(kSsrc)));
900 // Force the next frame to be a key frame to make the receiving
901 // decoder happy.
902 EXPECT_TRUE(channel_->SendIntraFrame());
903
904 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer1));
905 EXPECT_TRUE(SendFrame());
906 // Because the default channel is used, RemoveRecvStream above is not going
907 // to delete the channel. As a result the engine will continue to receive
908 // and decode the 3 frames sent above. So it is possible we will receive
909 // some (e.g. 1) of these 3 frames after the renderer is set again.
910 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
911 renderer1, 2, DefaultCodec().width, DefaultCodec().height, kTimeout);
912 // Detach |renderer1| before exit as there might be frames come late.
913 EXPECT_TRUE(channel_->SetRenderer(kSsrc, NULL));
914 }
915
916 // Tests the behavior of incoming streams in a conference scenario.
917 void SimulateConference() {
918 cricket::FakeVideoRenderer renderer1, renderer2;
919 EXPECT_TRUE(SetDefaultCodec());
920 cricket::VideoSendParameters parameters;
921 parameters.codecs.push_back(DefaultCodec());
922 parameters.options.conference_mode = rtc::Optional<bool>(true);
923 EXPECT_TRUE(channel_->SetSendParameters(parameters));
924 EXPECT_TRUE(SetSend(true));
925 EXPECT_TRUE(channel_->AddRecvStream(
926 cricket::StreamParams::CreateLegacy(1)));
927 EXPECT_TRUE(channel_->AddRecvStream(
928 cricket::StreamParams::CreateLegacy(2)));
929 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
930 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
931 EXPECT_EQ(0, renderer1.num_rendered_frames());
932 EXPECT_EQ(0, renderer2.num_rendered_frames());
933 std::vector<uint32_t> ssrcs;
934 ssrcs.push_back(1);
935 ssrcs.push_back(2);
936 network_interface_.SetConferenceMode(true, ssrcs);
937 EXPECT_TRUE(SendFrame());
938 EXPECT_FRAME_ON_RENDERER_WAIT(
939 renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
940 EXPECT_FRAME_ON_RENDERER_WAIT(
941 renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
942
943 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
944 EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get()));
945 EXPECT_EQ(DefaultCodec().width, renderer1.width());
946 EXPECT_EQ(DefaultCodec().height, renderer1.height());
947 EXPECT_EQ(DefaultCodec().width, renderer2.width());
948 EXPECT_EQ(DefaultCodec().height, renderer2.height());
949 EXPECT_TRUE(channel_->RemoveRecvStream(2));
950 EXPECT_TRUE(channel_->RemoveRecvStream(1));
951 }
952
953 // Tests that we can add and remove capturers and frames are sent out properly
954 void AddRemoveCapturer() {
955 cricket::VideoCodec codec = DefaultCodec();
956 codec.width = 320;
957 codec.height = 240;
958 const int time_between_send = TimeBetweenSend(codec);
959 EXPECT_TRUE(SetOneCodec(codec));
960 EXPECT_TRUE(SetSend(true));
961 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
962 EXPECT_EQ(0, renderer_.num_rendered_frames());
963 EXPECT_TRUE(SendFrame());
964 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
965 rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
966 CreateFakeVideoCapturer());
967 capturer->SetScreencast(true);
968 cricket::VideoFormat format(480, 360,
969 cricket::VideoFormat::FpsToInterval(30),
970 cricket::FOURCC_I420);
971 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
972 // All capturers start generating frames with the same timestamp. ViE does
973 // not allow the same timestamp to be used. Capture one frame before
974 // associating the capturer with the channel.
975 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
976 cricket::FOURCC_I420));
977
978 int captured_frames = 1;
979 for (int iterations = 0; iterations < 2; ++iterations) {
980 EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
981 rtc::Thread::Current()->ProcessMessages(time_between_send);
982 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
983 cricket::FOURCC_I420));
984 ++captured_frames;
985 // Wait until frame of right size is captured.
986 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
987 format.width == renderer_.width() &&
988 format.height == renderer_.height() &&
989 !renderer_.black_frame(), kTimeout);
990 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
991 EXPECT_EQ(format.width, renderer_.width());
992 EXPECT_EQ(format.height, renderer_.height());
993 captured_frames = renderer_.num_rendered_frames() + 1;
994 EXPECT_FALSE(renderer_.black_frame());
995 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
996 // Make sure a black frame is generated within the specified timeout.
997 // The black frame should be the resolution of the previous frame to
998 // prevent expensive encoder reconfigurations.
999 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
1000 format.width == renderer_.width() &&
1001 format.height == renderer_.height() &&
1002 renderer_.black_frame(), kTimeout);
1003 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
1004 EXPECT_EQ(format.width, renderer_.width());
1005 EXPECT_EQ(format.height, renderer_.height());
1006 EXPECT_TRUE(renderer_.black_frame());
1007
1008 // The black frame has the same timestamp as the next frame since it's
1009 // timestamp is set to the last frame's timestamp + interval. WebRTC will
1010 // not render a frame with the same timestamp so capture another frame
1011 // with the frame capturer to increment the next frame's timestamp.
1012 EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
1013 cricket::FOURCC_I420));
1014 }
1015 }
1016
1017 // Tests that if RemoveCapturer is called without a capturer ever being
1018 // added, the plugin shouldn't crash (and no black frame should be sent).
1019 void RemoveCapturerWithoutAdd() {
1020 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1021 EXPECT_TRUE(SetSend(true));
1022 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1023 EXPECT_EQ(0, renderer_.num_rendered_frames());
1024 EXPECT_TRUE(SendFrame());
1025 EXPECT_FRAME_WAIT(1, 640, 400, kTimeout);
1026 // Wait for one frame so they don't get dropped because we send frames too
1027 // tightly.
1028 rtc::Thread::Current()->ProcessMessages(30);
1029 // Remove the capturer.
1030 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1031 // Wait for one black frame for removing the capturer.
1032 EXPECT_FRAME_WAIT(2, 640, 400, kTimeout);
1033
1034 // No capturer was added, so this RemoveCapturer should
1035 // fail.
1036 EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
1037 rtc::Thread::Current()->ProcessMessages(300);
1038 // Verify no more frames were sent.
1039 EXPECT_EQ(2, renderer_.num_rendered_frames());
1040 }
1041
1042 // Tests that we can add and remove capturer as unique sources.
1043 void AddRemoveCapturerMultipleSources() {
1044 // WebRTC implementation will drop frames if pushed to quickly. Wait the
1045 // interval time to avoid that.
1046 // WebRTC implementation will drop frames if pushed to quickly. Wait the
1047 // interval time to avoid that.
1048 // Set up the stream associated with the engine.
1049 EXPECT_TRUE(channel_->AddRecvStream(
1050 cricket::StreamParams::CreateLegacy(kSsrc)));
1051 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
1052 cricket::VideoFormat capture_format; // default format
1053 capture_format.interval = cricket::VideoFormat::FpsToInterval(30);
1054 // Set up additional stream 1.
1055 cricket::FakeVideoRenderer renderer1;
1056 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
1057 EXPECT_TRUE(channel_->AddRecvStream(
1058 cricket::StreamParams::CreateLegacy(1)));
1059 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
1060 EXPECT_TRUE(channel_->AddSendStream(
1061 cricket::StreamParams::CreateLegacy(1)));
1062 rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer1(
1063 CreateFakeVideoCapturer());
1064 capturer1->SetScreencast(true);
1065 EXPECT_EQ(cricket::CS_RUNNING, capturer1->Start(capture_format));
1066 // Set up additional stream 2.
1067 cricket::FakeVideoRenderer renderer2;
1068 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
1069 EXPECT_TRUE(channel_->AddRecvStream(
1070 cricket::StreamParams::CreateLegacy(2)));
1071 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
1072 EXPECT_TRUE(channel_->AddSendStream(
1073 cricket::StreamParams::CreateLegacy(2)));
1074 rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer2(
1075 CreateFakeVideoCapturer());
1076 capturer2->SetScreencast(true);
1077 EXPECT_EQ(cricket::CS_RUNNING, capturer2->Start(capture_format));
1078 // State for all the streams.
1079 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1080 // A limitation in the lmi implementation requires that SetCapturer() is
1081 // called after SetOneCodec().
1082 // TODO(hellner): this seems like an unnecessary constraint, fix it.
1083 EXPECT_TRUE(channel_->SetCapturer(1, capturer1.get()));
1084 EXPECT_TRUE(channel_->SetCapturer(2, capturer2.get()));
1085 EXPECT_TRUE(SetSend(true));
1086 // Test capturer associated with engine.
1087 const int kTestWidth = 160;
1088 const int kTestHeight = 120;
1089 EXPECT_TRUE(capturer1->CaptureCustomFrame(
1090 kTestWidth, kTestHeight, cricket::FOURCC_I420));
1091 EXPECT_FRAME_ON_RENDERER_WAIT(
1092 renderer1, 1, kTestWidth, kTestHeight, kTimeout);
1093 // Capture a frame with additional capturer2, frames should be received
1094 EXPECT_TRUE(capturer2->CaptureCustomFrame(
1095 kTestWidth, kTestHeight, cricket::FOURCC_I420));
1096 EXPECT_FRAME_ON_RENDERER_WAIT(
1097 renderer2, 1, kTestWidth, kTestHeight, kTimeout);
1098 // Successfully remove the capturer.
1099 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1100 // Fail to re-remove the capturer.
1101 EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
1102 // The capturers must be unregistered here as it runs out of it's scope
1103 // next.
1104 EXPECT_TRUE(channel_->SetCapturer(1, NULL));
1105 EXPECT_TRUE(channel_->SetCapturer(2, NULL));
1106 }
1107
1108 void HighAspectHighHeightCapturer() {
1109 const int kWidth = 80;
1110 const int kHeight = 10000;
1111 const int kScaledWidth = 20;
1112 const int kScaledHeight = 2500;
1113
1114 cricket::VideoCodec codec(DefaultCodec());
1115 EXPECT_TRUE(SetOneCodec(codec));
1116 EXPECT_TRUE(SetSend(true));
1117
1118 cricket::FakeVideoRenderer renderer;
1119 EXPECT_TRUE(channel_->AddRecvStream(
1120 cricket::StreamParams::CreateLegacy(kSsrc)));
1121 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer));
1122 EXPECT_EQ(0, renderer.num_rendered_frames());
1123
1124 EXPECT_TRUE(SendFrame());
1125 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
1126 renderer, 1, codec.width, codec.height, kTimeout);
1127
1128 // Registering an external capturer is currently the same as screen casting
1129 // (update the test when this changes).
1130 rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
1131 CreateFakeVideoCapturer());
1132 capturer->SetScreencast(true);
1133 const std::vector<cricket::VideoFormat>* formats =
1134 capturer->GetSupportedFormats();
1135 cricket::VideoFormat capture_format = (*formats)[0];
1136 EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(capture_format));
1137 // Capture frame to not get same frame timestamps as previous capturer.
1138 capturer->CaptureFrame();
1139 EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
1140 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
1141 EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight,
1142 cricket::FOURCC_ARGB));
1143 EXPECT_GT_FRAME_ON_RENDERER_WAIT(
1144 renderer, 2, kScaledWidth, kScaledHeight, kTimeout);
1145 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1146 }
1147
1148 // Tests that we can adapt video resolution with 16:10 aspect ratio properly.
1149 void AdaptResolution16x10() {
1150 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1151 cricket::VideoCodec codec(DefaultCodec());
1152 codec.width = 640;
1153 codec.height = 400;
1154 SendAndReceive(codec);
1155 codec.width /= 2;
1156 codec.height /= 2;
1157 // Adapt the resolution.
1158 EXPECT_TRUE(SetOneCodec(codec));
1159 EXPECT_TRUE(WaitAndSendFrame(30));
1160 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
1161 }
1162 // Tests that we can adapt video resolution with 4:3 aspect ratio properly.
1163 void AdaptResolution4x3() {
1164 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1165 cricket::VideoCodec codec(DefaultCodec());
1166 codec.width = 640;
1167 codec.height = 400;
1168 SendAndReceive(codec);
1169 codec.width /= 2;
1170 codec.height /= 2;
1171 // Adapt the resolution.
1172 EXPECT_TRUE(SetOneCodec(codec));
1173 EXPECT_TRUE(WaitAndSendFrame(30));
1174 EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
1175 }
1176 // Tests that we can drop all frames properly.
1177 void AdaptDropAllFrames() {
1178 // Set the channel codec's resolution to 0, which will require the adapter
1179 // to drop all frames.
1180 cricket::VideoCodec codec(DefaultCodec());
1181 codec.width = codec.height = codec.framerate = 0;
1182 EXPECT_TRUE(SetOneCodec(codec));
1183 EXPECT_TRUE(SetSend(true));
1184 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1185 EXPECT_EQ(0, renderer_.num_rendered_frames());
1186 EXPECT_TRUE(SendFrame());
1187 EXPECT_TRUE(SendFrame());
1188 rtc::Thread::Current()->ProcessMessages(500);
1189 EXPECT_EQ(0, renderer_.num_rendered_frames());
1190 }
1191 // Tests that we can reduce the frame rate on demand properly.
1192 // TODO(fbarchard): This test is flakey on pulse. Fix and re-enable
1193 void AdaptFramerate() {
1194 cricket::VideoCodec codec(DefaultCodec());
1195 int frame_count = 0;
1196 // The capturer runs at 30 fps. The channel requires 30 fps.
1197 EXPECT_TRUE(SetOneCodec(codec));
1198 EXPECT_TRUE(SetSend(true));
1199 EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
1200 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1201 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1202 frame_count += 2;
1203 EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
1204 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
1205 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
1206
1207 // The channel requires 15 fps.
1208 codec.framerate = 15;
1209 EXPECT_TRUE(SetOneCodec(codec));
1210 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1211 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1212 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1213 frame_count += 2;
1214 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1215
1216 // The channel requires 10 fps.
1217 codec.framerate = 10;
1218 EXPECT_TRUE(SetOneCodec(codec));
1219 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1220 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1221 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1222 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1223 frame_count += 2;
1224 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1225
1226 // The channel requires 8 fps. The adapter adapts to 10 fps, which is the
1227 // closest factor of 30.
1228 codec.framerate = 8;
1229 EXPECT_TRUE(SetOneCodec(codec));
1230 EXPECT_TRUE(WaitAndSendFrame(0)); // Should be rendered.
1231 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1232 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1233 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1234 frame_count += 2;
1235 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1236 }
1237 // Tests that adapted frames won't be upscaled to a higher resolution.
1238 void SendsLowerResolutionOnSmallerFrames() {
1239 cricket::VideoCodec codec = DefaultCodec();
1240 codec.width = 320;
1241 codec.height = 240;
1242 EXPECT_TRUE(SetOneCodec(codec));
1243 EXPECT_TRUE(SetSend(true));
1244 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1245 EXPECT_EQ(0, renderer_.num_rendered_frames());
1246 EXPECT_TRUE(SendFrame());
1247 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
1248
1249 // Check that we send smaller frames at the new resolution.
1250 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(33));
1251 EXPECT_TRUE(video_capturer_->CaptureCustomFrame(
1252 codec.width / 2, codec.height / 2, cricket::FOURCC_I420));
1253 EXPECT_FRAME_WAIT(2, codec.width / 2, codec.height / 2, kTimeout);
1254 }
1255 // Tests that we can set the send stream format properly.
1256 void SetSendStreamFormat() {
1257 cricket::VideoCodec codec(DefaultCodec());
1258 SendAndReceive(codec);
1259 int frame_count = 1;
1260 EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
1261
1262 // Adapt the resolution and frame rate to half.
1263 cricket::VideoFormat format(
1264 codec.width / 2,
1265 codec.height / 2,
1266 cricket::VideoFormat::FpsToInterval(codec.framerate / 2),
1267 cricket::FOURCC_I420);
1268 // The SSRC differs from the send SSRC.
1269 EXPECT_FALSE(channel_->SetSendStreamFormat(kSsrc - 1, format));
1270 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1271
1272 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1273 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be rendered.
1274 EXPECT_TRUE(WaitAndSendFrame(30)); // Should be dropped.
1275 frame_count += 1;
1276 EXPECT_FRAME_WAIT(frame_count, format.width, format.height, kTimeout);
1277
1278 // Adapt the resolution to 0x0, which should drop all frames.
1279 format.width = 0;
1280 format.height = 0;
1281 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1282 EXPECT_TRUE(SendFrame());
1283 EXPECT_TRUE(SendFrame());
1284 rtc::Thread::Current()->ProcessMessages(500);
1285 EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
1286 }
1287 // Test that setting send stream format to 0x0 resolution will result in
1288 // frames being dropped.
1289 void SetSendStreamFormat0x0() {
1290 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1291 EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
1292 EXPECT_TRUE(SetSend(true));
1293 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1294 EXPECT_EQ(0, renderer_.num_rendered_frames());
1295 // This frame should be received.
1296 EXPECT_TRUE(SendFrame());
1297 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
1298 const int64_t interval =
1299 cricket::VideoFormat::FpsToInterval(DefaultCodec().framerate);
1300 cricket::VideoFormat format(
1301 0,
1302 0,
1303 interval,
1304 cricket::FOURCC_I420);
1305 EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
1306 // This frame should not be received.
1307 EXPECT_TRUE(WaitAndSendFrame(
1308 static_cast<int>(interval/rtc::kNumNanosecsPerMillisec)));
1309 rtc::Thread::Current()->ProcessMessages(500);
1310 EXPECT_EQ(1, renderer_.num_rendered_frames());
1311 }
1312
1313 // Tests that we can mute and unmute the channel properly.
1314 void MuteStream() {
1315 EXPECT_TRUE(SetDefaultCodec());
1316 cricket::FakeVideoCapturer video_capturer;
1317 video_capturer.Start(
1318 cricket::VideoFormat(
1319 640, 480,
1320 cricket::VideoFormat::FpsToInterval(30),
1321 cricket::FOURCC_I420));
1322 EXPECT_TRUE(channel_->SetCapturer(kSsrc, &video_capturer));
1323 EXPECT_TRUE(SetSend(true));
1324 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1325 EXPECT_EQ(0, renderer_.num_rendered_frames());
1326 // Mute the channel and expect black output frame.
1327 int frame_count = 0;
1328 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
1329 EXPECT_TRUE(video_capturer.CaptureFrame());
1330 ++frame_count;
1331 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1332 EXPECT_TRUE(renderer_.black_frame());
1333 // Unmute the channel and expect non-black output frame.
1334 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
1335 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
1336 EXPECT_TRUE(video_capturer.CaptureFrame());
1337 ++frame_count;
1338 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1339 EXPECT_FALSE(renderer_.black_frame());
1340 // Test that we can also Mute using the correct send stream SSRC.
1341 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
1342 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
1343 EXPECT_TRUE(video_capturer.CaptureFrame());
1344 ++frame_count;
1345 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1346 EXPECT_TRUE(renderer_.black_frame());
1347 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
1348 EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
1349 EXPECT_TRUE(video_capturer.CaptureFrame());
1350 ++frame_count;
1351 EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
1352 EXPECT_FALSE(renderer_.black_frame());
1353 // Test that muting an existing stream succeeds even if it's muted.
1354 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
1355 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
1356 // Test that unmuting an existing stream succeeds even if it's not muted.
1357 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
1358 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
1359 // Test that muting an invalid stream fails.
1360 EXPECT_FALSE(channel_->SetVideoSend(kSsrc+1, false, nullptr));
1361 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1362 }
1363
1364 // Test that multiple send streams can be created and deleted properly.
1365 void MultipleSendStreams() {
1366 // Remove stream added in Setup. I.e. remove stream corresponding to default
1367 // channel.
1368 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1369 const unsigned int kSsrcsSize = sizeof(kSsrcs4)/sizeof(kSsrcs4[0]);
1370 for (unsigned int i = 0; i < kSsrcsSize; ++i) {
1371 EXPECT_TRUE(channel_->AddSendStream(
1372 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1373 }
1374 // Delete one of the non default channel streams, let the destructor delete
1375 // the remaining ones.
1376 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
1377 // Stream should already be deleted.
1378 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
1379 }
1380
1381 // Two streams one channel tests.
1382
1383 // Tests that we can send and receive frames.
1384 void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
1385 SetUpSecondStream();
1386 // Test sending and receiving on first stream.
1387 SendAndReceive(codec);
1388 // Test sending and receiving on second stream.
1389 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout);
1390 EXPECT_GT(NumRtpPackets(), 0);
1391 EXPECT_EQ(1, renderer2_.num_rendered_frames());
1392 }
1393
1394 // Set up 2 streams where the first stream uses the default channel.
1395 // Then disconnect the first stream and verify default channel becomes
1396 // available.
1397 // Then add a new stream with |new_ssrc|. The new stream should re-use the
1398 // default channel.
1399 void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) {
1400 SetUpSecondStream();
1401 // Default channel used by the first stream.
1402 EXPECT_EQ(kSsrc, channel_->GetDefaultSendChannelSsrc());
1403 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
1404 EXPECT_FALSE(channel_->RemoveRecvStream(kSsrc));
1405 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1406 EXPECT_FALSE(channel_->RemoveSendStream(kSsrc));
1407 // Default channel is no longer used by a stream.
1408 EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc());
1409 uint32_t new_ssrc = kSsrc + 100;
1410 EXPECT_TRUE(channel_->AddSendStream(
1411 cricket::StreamParams::CreateLegacy(new_ssrc)));
1412 // Re-use default channel.
1413 EXPECT_EQ(new_ssrc, channel_->GetDefaultSendChannelSsrc());
1414 EXPECT_FALSE(channel_->AddSendStream(
1415 cricket::StreamParams::CreateLegacy(new_ssrc)));
1416 EXPECT_TRUE(channel_->AddRecvStream(
1417 cricket::StreamParams::CreateLegacy(new_ssrc)));
1418 EXPECT_TRUE(channel_->SetRenderer(new_ssrc, &renderer_));
1419 EXPECT_FALSE(channel_->AddRecvStream(
1420 cricket::StreamParams::CreateLegacy(new_ssrc)));
1421
1422 EXPECT_TRUE(channel_->SetCapturer(new_ssrc, video_capturer_.get()));
1423
1424 SendAndReceive(codec);
1425 EXPECT_TRUE(channel_->RemoveSendStream(new_ssrc));
1426 EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc());
1427 }
1428
1429 // Tests that we can send and receive frames with early receive.
1430 void TwoStreamsSendAndUnsignalledRecv(const cricket::VideoCodec& codec) {
1431 cricket::VideoSendParameters parameters;
1432 parameters.options.conference_mode = rtc::Optional<bool>(true);
1433 parameters.options.unsignalled_recv_stream_limit = rtc::Optional<int>(1);
1434 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1435 SetUpSecondStreamWithNoRecv();
1436 // Test sending and receiving on first stream.
1437 Send(codec);
1438 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
1439 EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
1440 // The first send is not expected to yield frames, because the ssrc
1441 // is not signalled yet. With unsignalled recv enabled, we will drop frames
1442 // instead of packets.
1443 EXPECT_EQ(0, renderer2_.num_rendered_frames());
1444 // Give a chance for the decoder to process before adding the receiver.
1445 rtc::Thread::Current()->ProcessMessages(100);
1446 // Test sending and receiving on second stream.
1447 EXPECT_TRUE(channel_->AddRecvStream(
1448 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
1449 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_));
1450 SendFrame();
1451 EXPECT_EQ_WAIT(2, renderer_.num_rendered_frames(), kTimeout);
1452 EXPECT_EQ(4, NumRtpPackets());
1453 // The second send is expected to yield frame as the ssrc is signalled now.
1454 // Decode should succeed here, though we received the key frame earlier.
1455 // Without early recv, we would have dropped it and decoding would have
1456 // failed.
1457 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout);
1458 }
1459
1460 // Tests that we drop key frames when conference mode is enabled and we
1461 // receive rtp packets on unsignalled streams. Removal of a unsignalled recv
1462 // stream is successful.
1463 void TwoStreamsAddAndRemoveUnsignalledRecv(
1464 const cricket::VideoCodec& codec) {
1465 cricket::VideoOptions vmo;
1466 vmo.conference_mode = rtc::Optional<bool>(true);
1467 vmo.unsignalled_recv_stream_limit = rtc::Optional<int>(1);
1468 EXPECT_TRUE(channel_->SetOptions(vmo));
1469 SetUpSecondStreamWithNoRecv();
1470 // Sending and receiving on first stream.
1471 Send(codec);
1472 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
1473 EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
1474 // The first send is not expected to yield frames, because the ssrc
1475 // is no signalled yet. With unsignalled recv enabled, we will drop frames
1476 // instead of packets.
1477 EXPECT_EQ(0, renderer2_.num_rendered_frames());
1478 // Give a chance for the decoder to process before adding the receiver.
1479 rtc::Thread::Current()->ProcessMessages(100);
1480 // Ensure that we can remove the unsignalled recv stream that was created
1481 // when the first video packet with unsignalled recv ssrc is received.
1482 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc + 2));
1483 }
1484
1485 const rtc::scoped_ptr<webrtc::Call> call_;
1486 VideoEngineOverride<E> engine_;
1487 rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
1488 rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_2_;
1489 rtc::scoped_ptr<C> channel_;
1490 cricket::FakeNetworkInterface network_interface_;
1491 cricket::FakeVideoRenderer renderer_;
1492 cricket::VideoMediaChannel::Error media_error_;
1493
1494 // Used by test cases where 2 streams are run on the same channel.
1495 cricket::FakeVideoRenderer renderer2_;
1496 };
1497
1498 #endif // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT
OLDNEW
« talk/build/common.gypi ('K') | « talk/media/base/videocommon_unittest.cc ('k') | talk/media/base/videoframe.h » ('j') | webrtc/api/api.gyp » ('J')

Powered by Google App Engine
This is Rietveld 408576698