pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1 | /* |
| 2 | * libjingle |
| 3 | * Copyright 2004 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 | |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 28 | #include <algorithm> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 29 | #include <map> |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 30 | #include <vector> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 31 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 32 | #include "talk/media/base/testutils.h" |
| 33 | #include "talk/media/base/videoengine_unittest.h" |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 34 | #include "talk/media/webrtc/fakewebrtcvideoengine.h" |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 35 | #include "talk/media/webrtc/simulcast.h" |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 +0000 | [diff] [blame] | 36 | #include "talk/media/webrtc/webrtcvideochannelfactory.h" |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 37 | #include "talk/media/webrtc/webrtcvideoengine.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 38 | #include "talk/media/webrtc/webrtcvideoengine2.h" |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 39 | #include "talk/media/webrtc/webrtcvideoengine2_unittest.h" |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 40 | #include "talk/media/webrtc/webrtcvoiceengine.h" |
pkasting@chromium.org | e7a4a12 | 2015-01-28 21:36:55 +0000 | [diff] [blame] | 41 | #include "webrtc/base/arraysize.h" |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 +0000 | [diff] [blame] | 42 | #include "webrtc/base/gunit.h" |
| 43 | #include "webrtc/base/stringutils.h" |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 44 | #include "webrtc/video_encoder.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 45 | |
| 46 | namespace { |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 47 | static const int kDefaultQpMax = 56; |
| 48 | static const int kDefaultFramerate = 30; |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 49 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 50 | static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0); |
| 51 | static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0); |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 52 | static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 53 | |
| 54 | static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0); |
| 55 | static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 56 | static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0); |
| 57 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 58 | static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0); |
| 59 | static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0); |
| 60 | |
| 61 | static const uint32 kSsrcs1[] = {1}; |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 62 | static const uint32 kSsrcs3[] = {1, 2, 3}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 63 | static const uint32 kRtxSsrcs1[] = {4}; |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 64 | static const char kUnsupportedExtensionName[] = |
| 65 | "urn:ietf:params:rtp-hdrext:unsupported"; |
pbos@webrtc.org | f99c2f2 | 2014-06-13 12:27:38 +0000 | [diff] [blame] | 66 | |
| 67 | void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { |
| 68 | EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
| 69 | cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); |
| 70 | EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
| 71 | cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli))); |
| 72 | EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
| 73 | cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty))); |
| 74 | EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
| 75 | cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir))); |
| 76 | } |
| 77 | |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 78 | static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame, |
| 79 | int width, |
| 80 | int height) { |
| 81 | video_frame->CreateEmptyFrame( |
| 82 | width, height, width, (width + 1) / 2, (width + 1) / 2); |
| 83 | memset(video_frame->buffer(webrtc::kYPlane), 16, |
| 84 | video_frame->allocated_size(webrtc::kYPlane)); |
| 85 | memset(video_frame->buffer(webrtc::kUPlane), 128, |
| 86 | video_frame->allocated_size(webrtc::kUPlane)); |
| 87 | memset(video_frame->buffer(webrtc::kVPlane), 128, |
| 88 | video_frame->allocated_size(webrtc::kVPlane)); |
| 89 | } |
| 90 | |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 91 | void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config, |
| 92 | const std::map<int, int>& rtx_types) { |
| 93 | std::map<int, int>::const_iterator it; |
| 94 | it = rtx_types.find(config.encoder_settings.payload_type); |
| 95 | EXPECT_TRUE(it != rtx_types.end() && |
| 96 | it->second == config.rtp.rtx.payload_type); |
| 97 | |
| 98 | if (config.rtp.fec.red_rtx_payload_type != -1) { |
| 99 | it = rtx_types.find(config.rtp.fec.red_payload_type); |
| 100 | EXPECT_TRUE(it != rtx_types.end() && |
| 101 | it->second == config.rtp.fec.red_rtx_payload_type); |
| 102 | } |
| 103 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 104 | } // namespace |
| 105 | |
| 106 | namespace cricket { |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 107 | FakeVideoSendStream::FakeVideoSendStream( |
| 108 | const webrtc::VideoSendStream::Config& config, |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 109 | const webrtc::VideoEncoderConfig& encoder_config) |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 110 | : sending_(false), |
| 111 | config_(config), |
| 112 | codec_settings_set_(false), |
| 113 | num_swapped_frames_(0) { |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 114 | assert(config.encoder_settings.encoder != NULL); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 115 | ReconfigureVideoEncoder(encoder_config); |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 116 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 117 | |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 118 | webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() const { |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 119 | return config_; |
| 120 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 121 | |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 122 | webrtc::VideoEncoderConfig FakeVideoSendStream::GetEncoderConfig() const { |
| 123 | return encoder_config_; |
| 124 | } |
| 125 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 126 | std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() { |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 127 | return encoder_config_.streams; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 128 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 129 | |
pbos@webrtc.org | 85f4294 | 2014-07-22 09:14:58 +0000 | [diff] [blame] | 130 | bool FakeVideoSendStream::IsSending() const { |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 131 | return sending_; |
| 132 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 133 | |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 134 | bool FakeVideoSendStream::GetVp8Settings( |
| 135 | webrtc::VideoCodecVP8* settings) const { |
| 136 | if (!codec_settings_set_) { |
| 137 | return false; |
| 138 | } |
| 139 | |
| 140 | *settings = vp8_settings_; |
| 141 | return true; |
| 142 | } |
| 143 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 144 | int FakeVideoSendStream::GetNumberOfSwappedFrames() const { |
| 145 | return num_swapped_frames_; |
| 146 | } |
| 147 | |
| 148 | int FakeVideoSendStream::GetLastWidth() const { |
| 149 | return last_frame_.width(); |
| 150 | } |
| 151 | |
| 152 | int FakeVideoSendStream::GetLastHeight() const { |
| 153 | return last_frame_.height(); |
| 154 | } |
| 155 | |
perkj@webrtc.org | af612d5 | 2015-03-18 09:51:05 +0000 | [diff] [blame] | 156 | void FakeVideoSendStream::IncomingCapturedFrame( |
| 157 | const webrtc::I420VideoFrame& frame) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 158 | ++num_swapped_frames_; |
perkj@webrtc.org | af612d5 | 2015-03-18 09:51:05 +0000 | [diff] [blame] | 159 | last_frame_.ShallowCopy(frame); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 160 | } |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 161 | |
| 162 | void FakeVideoSendStream::SetStats( |
| 163 | const webrtc::VideoSendStream::Stats& stats) { |
| 164 | stats_ = stats; |
| 165 | } |
| 166 | |
| 167 | webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() { |
| 168 | return stats_; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 169 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 170 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 171 | bool FakeVideoSendStream::ReconfigureVideoEncoder( |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 172 | const webrtc::VideoEncoderConfig& config) { |
| 173 | encoder_config_ = config; |
| 174 | if (config.encoder_specific_settings != NULL) { |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 175 | assert(config_.encoder_settings.payload_name == "VP8"); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 176 | vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>( |
| 177 | config.encoder_specific_settings); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 178 | } |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 179 | codec_settings_set_ = config.encoder_specific_settings != NULL; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 180 | return true; |
| 181 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 182 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 183 | webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 184 | return this; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 185 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 186 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 187 | void FakeVideoSendStream::Start() { |
| 188 | sending_ = true; |
| 189 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 190 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 191 | void FakeVideoSendStream::Stop() { |
| 192 | sending_ = false; |
| 193 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 194 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 195 | FakeVideoReceiveStream::FakeVideoReceiveStream( |
| 196 | const webrtc::VideoReceiveStream::Config& config) |
| 197 | : config_(config), receiving_(false) { |
| 198 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 199 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 200 | webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() { |
| 201 | return config_; |
| 202 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 203 | |
pbos@webrtc.org | 85f4294 | 2014-07-22 09:14:58 +0000 | [diff] [blame] | 204 | bool FakeVideoReceiveStream::IsReceiving() const { |
| 205 | return receiving_; |
| 206 | } |
| 207 | |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 208 | void FakeVideoReceiveStream::InjectFrame(const webrtc::I420VideoFrame& frame, |
| 209 | int time_to_render_ms) { |
| 210 | config_.renderer->RenderFrame(frame, time_to_render_ms); |
| 211 | } |
| 212 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 213 | webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const { |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 214 | return stats_; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 215 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 216 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 217 | void FakeVideoReceiveStream::Start() { |
| 218 | receiving_ = true; |
| 219 | } |
pbos@webrtc.org | 85f4294 | 2014-07-22 09:14:58 +0000 | [diff] [blame] | 220 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 221 | void FakeVideoReceiveStream::Stop() { |
| 222 | receiving_ = false; |
| 223 | } |
pbos@webrtc.org | 85f4294 | 2014-07-22 09:14:58 +0000 | [diff] [blame] | 224 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 225 | void FakeVideoReceiveStream::SetStats( |
| 226 | const webrtc::VideoReceiveStream::Stats& stats) { |
| 227 | stats_ = stats; |
| 228 | } |
| 229 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 230 | FakeCall::FakeCall(const webrtc::Call::Config& config) |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 231 | : config_(config), |
| 232 | network_state_(kNetworkUp), |
| 233 | num_created_send_streams_(0), |
| 234 | num_created_receive_streams_(0) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 235 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 236 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 237 | FakeCall::~FakeCall() { |
| 238 | EXPECT_EQ(0u, video_send_streams_.size()); |
| 239 | EXPECT_EQ(0u, video_receive_streams_.size()); |
| 240 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 241 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 242 | webrtc::Call::Config FakeCall::GetConfig() const { |
| 243 | return config_; |
| 244 | } |
| 245 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 246 | std::vector<FakeVideoSendStream*> FakeCall::GetVideoSendStreams() { |
| 247 | return video_send_streams_; |
| 248 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 249 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 250 | std::vector<FakeVideoReceiveStream*> FakeCall::GetVideoReceiveStreams() { |
| 251 | return video_receive_streams_; |
| 252 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 253 | |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 254 | webrtc::Call::NetworkState FakeCall::GetNetworkState() const { |
| 255 | return network_state_; |
| 256 | } |
| 257 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 258 | webrtc::VideoSendStream* FakeCall::CreateVideoSendStream( |
| 259 | const webrtc::VideoSendStream::Config& config, |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 260 | const webrtc::VideoEncoderConfig& encoder_config) { |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 261 | FakeVideoSendStream* fake_stream = |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 262 | new FakeVideoSendStream(config, encoder_config); |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 263 | video_send_streams_.push_back(fake_stream); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 264 | ++num_created_send_streams_; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 265 | return fake_stream; |
| 266 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 267 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 268 | void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { |
| 269 | FakeVideoSendStream* fake_stream = |
| 270 | static_cast<FakeVideoSendStream*>(send_stream); |
| 271 | for (size_t i = 0; i < video_send_streams_.size(); ++i) { |
| 272 | if (video_send_streams_[i] == fake_stream) { |
| 273 | delete video_send_streams_[i]; |
| 274 | video_send_streams_.erase(video_send_streams_.begin() + i); |
| 275 | return; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 276 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 277 | } |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 278 | ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter."; |
| 279 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 280 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 281 | webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream( |
| 282 | const webrtc::VideoReceiveStream::Config& config) { |
| 283 | video_receive_streams_.push_back(new FakeVideoReceiveStream(config)); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 284 | ++num_created_receive_streams_; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 285 | return video_receive_streams_[video_receive_streams_.size() - 1]; |
| 286 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 287 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 288 | void FakeCall::DestroyVideoReceiveStream( |
| 289 | webrtc::VideoReceiveStream* receive_stream) { |
| 290 | FakeVideoReceiveStream* fake_stream = |
| 291 | static_cast<FakeVideoReceiveStream*>(receive_stream); |
| 292 | for (size_t i = 0; i < video_receive_streams_.size(); ++i) { |
| 293 | if (video_receive_streams_[i] == fake_stream) { |
| 294 | delete video_receive_streams_[i]; |
| 295 | video_receive_streams_.erase(video_receive_streams_.begin() + i); |
| 296 | return; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 297 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 298 | } |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 299 | ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter."; |
| 300 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 301 | |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 302 | webrtc::PacketReceiver* FakeCall::Receiver() { |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 303 | return this; |
| 304 | } |
| 305 | |
| 306 | FakeCall::DeliveryStatus FakeCall::DeliverPacket(const uint8_t* packet, |
| 307 | size_t length) { |
| 308 | CHECK(length >= 12); |
| 309 | uint32_t ssrc; |
| 310 | if (!GetRtpSsrc(packet, length, &ssrc)) |
| 311 | return DELIVERY_PACKET_ERROR; |
| 312 | |
| 313 | for (auto& receiver: video_receive_streams_) { |
| 314 | if (receiver->GetConfig().rtp.remote_ssrc == ssrc) |
| 315 | return DELIVERY_OK; |
| 316 | } |
| 317 | return DELIVERY_UNKNOWN_SSRC; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 318 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 319 | |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 320 | void FakeCall::SetStats(const webrtc::Call::Stats& stats) { |
| 321 | stats_ = stats; |
| 322 | } |
| 323 | |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 324 | int FakeCall::GetNumCreatedSendStreams() const { |
| 325 | return num_created_send_streams_; |
| 326 | } |
| 327 | |
| 328 | int FakeCall::GetNumCreatedReceiveStreams() const { |
| 329 | return num_created_receive_streams_; |
| 330 | } |
| 331 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 332 | webrtc::Call::Stats FakeCall::GetStats() const { |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 333 | return stats_; |
pbos@webrtc.org | 86f613d | 2014-06-10 08:53:05 +0000 | [diff] [blame] | 334 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 335 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 336 | void FakeCall::SetBitrateConfig( |
| 337 | const webrtc::Call::Config::BitrateConfig& bitrate_config) { |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 338 | config_.bitrate_config = bitrate_config; |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 339 | } |
| 340 | |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 341 | void FakeCall::SignalNetworkState(webrtc::Call::NetworkState state) { |
| 342 | network_state_ = state; |
| 343 | } |
| 344 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 345 | class WebRtcVideoEngine2Test : public ::testing::Test { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 346 | public: |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 347 | WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {} |
| 348 | WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine) |
| 349 | : engine_(voice_engine) { |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 350 | std::vector<VideoCodec> engine_codecs = engine_.codecs(); |
| 351 | assert(!engine_codecs.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 352 | bool codec_set = false; |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 353 | for (size_t i = 0; i < engine_codecs.size(); ++i) { |
| 354 | if (engine_codecs[i].name == "red") { |
| 355 | default_red_codec_ = engine_codecs[i]; |
| 356 | } else if (engine_codecs[i].name == "ulpfec") { |
| 357 | default_ulpfec_codec_ = engine_codecs[i]; |
| 358 | } else if (engine_codecs[i].name == "rtx") { |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 359 | int associated_payload_type; |
| 360 | if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, |
| 361 | &associated_payload_type)) { |
| 362 | default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; |
| 363 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 364 | } else if (!codec_set) { |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 365 | default_codec_ = engine_codecs[i]; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 366 | codec_set = true; |
| 367 | } |
| 368 | } |
| 369 | |
| 370 | assert(codec_set); |
| 371 | } |
| 372 | |
| 373 | protected: |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 374 | class FakeCallFactory : public WebRtcCallFactory { |
| 375 | public: |
| 376 | FakeCallFactory() : fake_call_(NULL) {} |
| 377 | FakeCall* GetCall() { return fake_call_; } |
| 378 | |
| 379 | private: |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 380 | webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 381 | assert(fake_call_ == NULL); |
| 382 | fake_call_ = new FakeCall(config); |
| 383 | return fake_call_; |
| 384 | } |
| 385 | |
| 386 | FakeCall* fake_call_; |
| 387 | }; |
| 388 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 389 | VideoMediaChannel* SetUpForExternalEncoderFactory( |
| 390 | cricket::WebRtcVideoEncoderFactory* encoder_factory, |
| 391 | const std::vector<VideoCodec>& codecs); |
pbos@webrtc.org | fa553ef | 2014-10-20 11:07:07 +0000 | [diff] [blame] | 392 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 393 | VideoMediaChannel* SetUpForExternalDecoderFactory( |
| 394 | cricket::WebRtcVideoDecoderFactory* decoder_factory, |
| 395 | const std::vector<VideoCodec>& codecs); |
| 396 | |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 397 | // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly |
| 398 | // initialized when the constructor is called. |
| 399 | WebRtcVoiceEngine voice_engine_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 400 | WebRtcVideoEngine2 engine_; |
| 401 | VideoCodec default_codec_; |
| 402 | VideoCodec default_red_codec_; |
| 403 | VideoCodec default_ulpfec_codec_; |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 404 | std::map<int, int> default_apt_rtx_types_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 405 | }; |
| 406 | |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 407 | class WebRtcVideoEngine2VoiceTest : public WebRtcVideoEngine2Test { |
| 408 | public: |
| 409 | WebRtcVideoEngine2VoiceTest() : WebRtcVideoEngine2Test(&voice_engine_) {} |
| 410 | }; |
| 411 | |
| 412 | TEST_F(WebRtcVideoEngine2VoiceTest, ConfiguresAvSyncForFirstReceiveChannel) { |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 413 | FakeCallFactory call_factory; |
| 414 | engine_.SetCallFactory(&call_factory); |
| 415 | |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 416 | voice_engine_.Init(rtc::Thread::Current()); |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 417 | engine_.Init(rtc::Thread::Current()); |
| 418 | |
| 419 | rtc::scoped_ptr<VoiceMediaChannel> voice_channel( |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 420 | voice_engine_.CreateChannel()); |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 421 | ASSERT_TRUE(voice_channel.get() != NULL); |
| 422 | WebRtcVoiceMediaChannel* webrtc_voice_channel = |
| 423 | static_cast<WebRtcVoiceMediaChannel*>(voice_channel.get()); |
| 424 | ASSERT_NE(webrtc_voice_channel->voe_channel(), -1); |
| 425 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 426 | engine_.CreateChannel(cricket::VideoOptions(), voice_channel.get())); |
| 427 | |
| 428 | FakeCall* fake_call = call_factory.GetCall(); |
| 429 | ASSERT_TRUE(fake_call != NULL); |
| 430 | |
| 431 | webrtc::Call::Config call_config = fake_call->GetConfig(); |
| 432 | |
pbos@webrtc.org | f1f0d9a | 2015-03-02 13:30:15 +0000 | [diff] [blame] | 433 | ASSERT_TRUE(voice_engine_.voe()->engine() != NULL); |
| 434 | ASSERT_EQ(voice_engine_.voe()->engine(), call_config.voice_engine); |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 435 | |
| 436 | EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc))); |
| 437 | EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc + 1))); |
| 438 | std::vector<FakeVideoReceiveStream*> receive_streams = |
| 439 | fake_call->GetVideoReceiveStreams(); |
| 440 | |
| 441 | ASSERT_EQ(2u, receive_streams.size()); |
| 442 | EXPECT_EQ(webrtc_voice_channel->voe_channel(), |
| 443 | receive_streams[0]->GetConfig().audio_channel_id); |
| 444 | EXPECT_EQ(-1, receive_streams[1]->GetConfig().audio_channel_id) |
| 445 | << "AV sync should only be set up for the first receive channel."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 446 | } |
| 447 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 448 | TEST_F(WebRtcVideoEngine2Test, FindCodec) { |
| 449 | const std::vector<cricket::VideoCodec>& c = engine_.codecs(); |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 450 | EXPECT_EQ(cricket::DefaultVideoCodecList().size(), c.size()); |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 451 | |
| 452 | cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0); |
| 453 | EXPECT_TRUE(engine_.FindCodec(vp8)); |
| 454 | |
| 455 | cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0); |
| 456 | EXPECT_TRUE(engine_.FindCodec(vp8)); |
| 457 | |
| 458 | cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50); |
| 459 | EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref)); |
| 460 | |
| 461 | cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0); |
| 462 | EXPECT_FALSE(engine_.FindCodec(vp8_diff_id)); |
| 463 | vp8_diff_id.id = 97; |
| 464 | EXPECT_TRUE(engine_.FindCodec(vp8_diff_id)); |
| 465 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 466 | // FindCodec ignores the codec size. |
| 467 | // Test that FindCodec can accept uncommon codec size. |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 468 | cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0); |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 469 | EXPECT_TRUE(engine_.FindCodec(vp8_diff_res)); |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 470 | |
| 471 | // PeerConnection doesn't negotiate the resolution at this point. |
| 472 | // Test that FindCodec can handle the case when width/height is 0. |
| 473 | cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0); |
| 474 | EXPECT_TRUE(engine_.FindCodec(vp8_zero_res)); |
| 475 | |
| 476 | cricket::VideoCodec red(101, "RED", 0, 0, 30, 0); |
| 477 | EXPECT_TRUE(engine_.FindCodec(red)); |
| 478 | |
| 479 | cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0); |
| 480 | EXPECT_TRUE(engine_.FindCodec(red)); |
| 481 | |
| 482 | cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0); |
| 483 | EXPECT_TRUE(engine_.FindCodec(fec)); |
| 484 | |
| 485 | cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0); |
| 486 | EXPECT_TRUE(engine_.FindCodec(fec)); |
| 487 | |
| 488 | cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0); |
| 489 | EXPECT_TRUE(engine_.FindCodec(rtx)); |
| 490 | } |
| 491 | |
pbos@webrtc.org | 2a72c65 | 2015-02-26 16:01:24 +0000 | [diff] [blame] | 492 | TEST_F(WebRtcVideoEngine2Test, SetDefaultEncoderConfigPreservesFeedbackParams) { |
| 493 | cricket::VideoCodec max_settings( |
| 494 | engine_.codecs()[0].id, engine_.codecs()[0].name, |
| 495 | engine_.codecs()[0].width / 2, engine_.codecs()[0].height / 2, 30, 0); |
| 496 | // This codec shouldn't have NACK by default or the test is pointless. |
| 497 | EXPECT_FALSE(max_settings.HasFeedbackParam( |
| 498 | FeedbackParam(kRtcpFbParamNack, kParamValueEmpty))); |
| 499 | // The engine should by default have it however. |
| 500 | EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam( |
| 501 | FeedbackParam(kRtcpFbParamNack, kParamValueEmpty))); |
| 502 | |
| 503 | // Set constrained max codec settings. |
| 504 | EXPECT_TRUE(engine_.SetDefaultEncoderConfig( |
| 505 | cricket::VideoEncoderConfig(max_settings))); |
| 506 | |
| 507 | // Verify that feedback parameters are retained. |
| 508 | EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam( |
| 509 | FeedbackParam(kRtcpFbParamNack, kParamValueEmpty))); |
| 510 | } |
| 511 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 512 | TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) { |
| 513 | std::vector<VideoCodec> engine_codecs = engine_.codecs(); |
| 514 | for (size_t i = 0; i < engine_codecs.size(); ++i) { |
| 515 | if (engine_codecs[i].name != kRtxCodecName) |
| 516 | continue; |
| 517 | int associated_payload_type; |
| 518 | EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 519 | &associated_payload_type)); |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 520 | EXPECT_EQ(default_codec_.id, associated_payload_type); |
| 521 | return; |
| 522 | } |
| 523 | FAIL() << "No RTX codec found among default codecs."; |
| 524 | } |
| 525 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 526 | TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) { |
| 527 | std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions(); |
| 528 | ASSERT_FALSE(extensions.empty()); |
| 529 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 530 | if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) { |
| 531 | EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id); |
| 532 | return; |
| 533 | } |
| 534 | } |
| 535 | FAIL() << "Timestamp offset extension not in header-extension list."; |
| 536 | } |
| 537 | |
| 538 | TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) { |
| 539 | std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions(); |
| 540 | ASSERT_FALSE(extensions.empty()); |
| 541 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 542 | if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) { |
| 543 | EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId, |
| 544 | extensions[i].id); |
| 545 | return; |
| 546 | } |
| 547 | } |
| 548 | FAIL() << "Absolute Sender Time extension not in header-extension list."; |
| 549 | } |
| 550 | |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 551 | TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) { |
| 552 | std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions(); |
| 553 | ASSERT_FALSE(extensions.empty()); |
| 554 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 555 | if (extensions[i].uri == kRtpVideoRotationHeaderExtension) { |
| 556 | EXPECT_EQ(kRtpVideoRotationHeaderExtensionDefaultId, extensions[i].id); |
| 557 | return; |
| 558 | } |
| 559 | } |
| 560 | FAIL() << "Video Rotation extension not in header-extension list."; |
| 561 | } |
| 562 | |
| 563 | TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) { |
| 564 | // Allocate the capturer first to prevent early destruction before channel's |
| 565 | // dtor is called. |
| 566 | cricket::FakeVideoCapturer capturer; |
| 567 | |
| 568 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 569 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 570 | std::vector<cricket::VideoCodec> codecs; |
| 571 | codecs.push_back(kVp8Codec); |
| 572 | |
| 573 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 574 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 575 | EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); |
| 576 | |
| 577 | // Add CVO extension. |
| 578 | const int id = 1; |
| 579 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 580 | extensions.push_back( |
| 581 | cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id)); |
| 582 | EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); |
| 583 | |
| 584 | // Set capturer. |
| 585 | EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer)); |
| 586 | |
| 587 | // Verify capturer has turned off applying rotation. |
| 588 | EXPECT_FALSE(capturer.GetApplyRotation()); |
| 589 | |
| 590 | // Verify removing header extension turns on applying rotation. |
| 591 | extensions.clear(); |
| 592 | EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); |
| 593 | EXPECT_TRUE(capturer.GetApplyRotation()); |
| 594 | } |
| 595 | |
| 596 | TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { |
| 597 | cricket::FakeVideoCapturer capturer; |
| 598 | |
| 599 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 600 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 601 | std::vector<cricket::VideoCodec> codecs; |
| 602 | codecs.push_back(kVp8Codec); |
| 603 | |
| 604 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 605 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 606 | EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); |
| 607 | |
| 608 | // Set capturer. |
| 609 | EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer)); |
| 610 | |
| 611 | // Add CVO extension. |
| 612 | const int id = 1; |
| 613 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 614 | extensions.push_back( |
| 615 | cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id)); |
| 616 | EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); |
| 617 | |
| 618 | // Verify capturer has turned off applying rotation. |
| 619 | EXPECT_FALSE(capturer.GetApplyRotation()); |
| 620 | |
| 621 | // Verify removing header extension turns on applying rotation. |
| 622 | extensions.clear(); |
| 623 | EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); |
| 624 | EXPECT_TRUE(capturer.GetApplyRotation()); |
| 625 | } |
| 626 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 627 | TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) { |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 628 | engine_.Init(rtc::Thread::Current()); |
buildbot@webrtc.org | 1ecbe45 | 2014-10-14 20:29:28 +0000 | [diff] [blame] | 629 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 630 | engine_.CreateChannel(cricket::VideoOptions(), NULL)); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 631 | |
| 632 | EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); |
| 633 | |
| 634 | EXPECT_FALSE(channel->SetSend(true)) |
| 635 | << "Channel should not start without codecs."; |
| 636 | EXPECT_TRUE(channel->SetSend(false)) |
| 637 | << "Channel should be stoppable even without set codecs."; |
| 638 | } |
| 639 | |
pbos@webrtc.org | c3d2bd2 | 2014-08-12 20:55:10 +0000 | [diff] [blame] | 640 | TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) { |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 641 | engine_.Init(rtc::Thread::Current()); |
buildbot@webrtc.org | 1ecbe45 | 2014-10-14 20:29:28 +0000 | [diff] [blame] | 642 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 643 | engine_.CreateChannel(cricket::VideoOptions(), NULL)); |
pbos@webrtc.org | c3d2bd2 | 2014-08-12 20:55:10 +0000 | [diff] [blame] | 644 | EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); |
| 645 | VideoMediaInfo info; |
| 646 | channel->GetStats(&info); |
| 647 | } |
| 648 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 649 | TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { |
| 650 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 651 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 652 | std::vector<cricket::VideoCodec> codecs; |
| 653 | codecs.push_back(kVp8Codec); |
| 654 | |
| 655 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 656 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 657 | |
| 658 | EXPECT_TRUE( |
| 659 | channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 660 | ASSERT_EQ(1u, encoder_factory.encoders().size()); |
| 661 | EXPECT_TRUE(channel->SetSend(true)); |
| 662 | |
| 663 | cricket::FakeVideoCapturer capturer; |
| 664 | EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer)); |
| 665 | EXPECT_EQ(cricket::CS_RUNNING, |
| 666 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 667 | EXPECT_TRUE(capturer.CaptureFrame()); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 668 | EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0, |
| 669 | kTimeout); |
| 670 | |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 671 | // Sending one frame will have reallocated the encoder since input size |
| 672 | // changes from a small default to the actual frame width/height. |
| 673 | int num_created_encoders = encoder_factory.GetNumCreatedEncoders(); |
| 674 | EXPECT_EQ(num_created_encoders, 2); |
| 675 | |
| 676 | // Setting codecs of the same type should not reallocate any encoders |
| 677 | // (expecting a no-op). |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 678 | EXPECT_TRUE(channel->SetSendCodecs(codecs)); |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 679 | EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders()); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 680 | |
| 681 | // Remove stream previously added to free the external encoder instance. |
| 682 | EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); |
| 683 | EXPECT_EQ(0u, encoder_factory.encoders().size()); |
| 684 | } |
| 685 | |
Peter Boström | 53eda3d | 2015-03-27 15:53:18 +0100 | [diff] [blame] | 686 | TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { |
| 687 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 688 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9"); |
| 689 | std::vector<cricket::VideoCodec> codecs; |
| 690 | codecs.push_back(kVp9Codec); |
| 691 | |
| 692 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 693 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 694 | |
| 695 | EXPECT_TRUE( |
| 696 | channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 697 | } |
| 698 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 699 | VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( |
| 700 | cricket::WebRtcVideoEncoderFactory* encoder_factory, |
| 701 | const std::vector<VideoCodec>& codecs) { |
| 702 | engine_.SetExternalEncoderFactory(encoder_factory); |
| 703 | engine_.Init(rtc::Thread::Current()); |
| 704 | |
buildbot@webrtc.org | 1ecbe45 | 2014-10-14 20:29:28 +0000 | [diff] [blame] | 705 | VideoMediaChannel* channel = |
| 706 | engine_.CreateChannel(cricket::VideoOptions(), NULL); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 707 | EXPECT_TRUE(channel->SetSendCodecs(codecs)); |
| 708 | |
| 709 | return channel; |
| 710 | } |
| 711 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 712 | VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( |
| 713 | cricket::WebRtcVideoDecoderFactory* decoder_factory, |
| 714 | const std::vector<VideoCodec>& codecs) { |
| 715 | engine_.SetExternalDecoderFactory(decoder_factory); |
| 716 | engine_.Init(rtc::Thread::Current()); |
| 717 | |
| 718 | VideoMediaChannel* channel = |
| 719 | engine_.CreateChannel(cricket::VideoOptions(), NULL); |
| 720 | EXPECT_TRUE(channel->SetRecvCodecs(codecs)); |
| 721 | |
| 722 | return channel; |
| 723 | } |
| 724 | |
pbos@webrtc.org | f18fba2 | 2015-01-14 16:26:23 +0000 | [diff] [blame] | 725 | TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { |
| 726 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 727 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 728 | std::vector<cricket::VideoCodec> codecs; |
| 729 | codecs.push_back(kVp8Codec); |
| 730 | |
| 731 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 732 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 733 | |
| 734 | std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); |
| 735 | |
| 736 | EXPECT_TRUE( |
| 737 | channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
| 738 | EXPECT_TRUE(channel->SetSend(true)); |
| 739 | |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 740 | cricket::FakeVideoCapturer capturer; |
| 741 | EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); |
| 742 | EXPECT_EQ(cricket::CS_RUNNING, |
| 743 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 744 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 745 | |
pbos@webrtc.org | f18fba2 | 2015-01-14 16:26:23 +0000 | [diff] [blame] | 746 | EXPECT_GT(encoder_factory.encoders().size(), 1u); |
| 747 | |
| 748 | // Verify that encoders are configured for simulcast through adapter |
| 749 | // (increasing resolution and only configured to send one stream each). |
| 750 | int prev_width = -1; |
| 751 | for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) { |
| 752 | webrtc::VideoCodec codec_settings = |
| 753 | encoder_factory.encoders()[i]->GetCodecSettings(); |
| 754 | EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams); |
| 755 | EXPECT_GT(codec_settings.width, prev_width); |
| 756 | prev_width = codec_settings.width; |
| 757 | } |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 758 | |
| 759 | EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), NULL)); |
pthatcher@webrtc.org | 818c498 | 2015-03-06 02:20:58 +0000 | [diff] [blame] | 760 | |
| 761 | channel.reset(); |
| 762 | ASSERT_EQ(0u, encoder_factory.encoders().size()); |
pbos@webrtc.org | f18fba2 | 2015-01-14 16:26:23 +0000 | [diff] [blame] | 763 | } |
| 764 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 765 | TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) { |
| 766 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 767 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 768 | std::vector<cricket::VideoCodec> codecs; |
| 769 | codecs.push_back(kH264Codec); |
| 770 | |
| 771 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 772 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 773 | |
| 774 | EXPECT_TRUE( |
| 775 | channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 776 | ASSERT_EQ(1u, encoder_factory.encoders().size()); |
| 777 | |
| 778 | codecs.clear(); |
| 779 | codecs.push_back(kVp8Codec); |
| 780 | EXPECT_TRUE(channel->SetSendCodecs(codecs)); |
| 781 | |
| 782 | ASSERT_EQ(0u, encoder_factory.encoders().size()); |
| 783 | } |
| 784 | |
| 785 | TEST_F(WebRtcVideoEngine2Test, |
| 786 | DontUseExternalEncoderFactoryForUnsupportedCodecs) { |
| 787 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 788 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 789 | std::vector<cricket::VideoCodec> codecs; |
| 790 | codecs.push_back(kVp8Codec); |
| 791 | |
| 792 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 793 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 794 | |
| 795 | EXPECT_TRUE( |
| 796 | channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
pthatcher@webrtc.org | 818c498 | 2015-03-06 02:20:58 +0000 | [diff] [blame] | 797 | // Make sure DestroyVideoEncoder was called on the factory. |
| 798 | ASSERT_EQ(0u, encoder_factory.encoders().size()); |
| 799 | } |
| 800 | |
| 801 | TEST_F(WebRtcVideoEngine2Test, |
| 802 | UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) { |
| 803 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 804 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 805 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 806 | |
| 807 | std::vector<cricket::VideoCodec> codecs; |
| 808 | codecs.push_back(kVp8Codec); |
| 809 | |
| 810 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 811 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 812 | |
| 813 | std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); |
| 814 | |
| 815 | EXPECT_TRUE( |
| 816 | channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
| 817 | EXPECT_TRUE(channel->SetSend(true)); |
| 818 | |
| 819 | // Send a fake frame, or else the media engine will configure the simulcast |
| 820 | // encoder adapter at a low-enough size that it'll only create a single |
| 821 | // encoder layer. |
| 822 | cricket::FakeVideoCapturer capturer; |
| 823 | EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); |
| 824 | EXPECT_EQ(cricket::CS_RUNNING, |
| 825 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 826 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 827 | |
| 828 | ASSERT_GT(encoder_factory.encoders().size(), 1u); |
| 829 | EXPECT_EQ(webrtc::kVideoCodecVP8, |
| 830 | encoder_factory.encoders()[0]->GetCodecSettings().codecType); |
| 831 | |
| 832 | channel.reset(); |
| 833 | // Make sure DestroyVideoEncoder was called on the factory. |
| 834 | EXPECT_EQ(0u, encoder_factory.encoders().size()); |
| 835 | } |
| 836 | |
| 837 | TEST_F(WebRtcVideoEngine2Test, |
| 838 | DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) { |
| 839 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 840 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
| 841 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 842 | |
| 843 | std::vector<cricket::VideoCodec> codecs; |
| 844 | codecs.push_back(kH264Codec); |
| 845 | |
| 846 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 847 | SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
| 848 | |
| 849 | EXPECT_TRUE( |
| 850 | channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 851 | ASSERT_EQ(1u, encoder_factory.encoders().size()); |
| 852 | EXPECT_EQ(webrtc::kVideoCodecH264, |
| 853 | encoder_factory.encoders()[0]->GetCodecSettings().codecType); |
| 854 | |
| 855 | channel.reset(); |
| 856 | // Make sure DestroyVideoEncoder was called on the factory. |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 857 | ASSERT_EQ(0u, encoder_factory.encoders().size()); |
| 858 | } |
| 859 | |
| 860 | // Test external codec with be added to the end of the supported codec list. |
| 861 | TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) { |
| 862 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 863 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 864 | engine_.SetExternalEncoderFactory(&encoder_factory); |
| 865 | |
| 866 | engine_.Init(rtc::Thread::Current()); |
| 867 | |
| 868 | std::vector<cricket::VideoCodec> codecs(engine_.codecs()); |
| 869 | ASSERT_GE(codecs.size(), 2u); |
| 870 | cricket::VideoCodec internal_codec = codecs.front(); |
| 871 | cricket::VideoCodec external_codec = codecs.back(); |
| 872 | |
| 873 | // The external codec will appear at last. |
| 874 | EXPECT_EQ("VP8", internal_codec.name); |
| 875 | EXPECT_EQ("H264", external_codec.name); |
| 876 | } |
| 877 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 878 | TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) { |
| 879 | cricket::FakeWebRtcVideoDecoderFactory decoder_factory; |
| 880 | decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); |
| 881 | std::vector<cricket::VideoCodec> codecs; |
| 882 | codecs.push_back(kVp8Codec); |
| 883 | |
| 884 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 885 | SetUpForExternalDecoderFactory(&decoder_factory, codecs)); |
| 886 | |
| 887 | EXPECT_TRUE( |
| 888 | channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 889 | ASSERT_EQ(1u, decoder_factory.decoders().size()); |
| 890 | |
| 891 | // Setting codecs of the same type should not reallocate the decoder. |
| 892 | EXPECT_TRUE(channel->SetRecvCodecs(codecs)); |
| 893 | EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders()); |
| 894 | |
| 895 | // Remove stream previously added to free the external decoder instance. |
| 896 | EXPECT_TRUE(channel->RemoveRecvStream(kSsrc)); |
| 897 | EXPECT_EQ(0u, decoder_factory.decoders().size()); |
| 898 | } |
| 899 | |
| 900 | // Verifies that we can set up decoders that are not internally supported. |
| 901 | TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) { |
| 902 | // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We |
| 903 | // can't even query the WebRtcVideoDecoderFactory for supported codecs. |
| 904 | // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported |
| 905 | // codecs. |
| 906 | cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
| 907 | encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
| 908 | engine_.SetExternalEncoderFactory(&encoder_factory); |
| 909 | cricket::FakeWebRtcVideoDecoderFactory decoder_factory; |
| 910 | decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264); |
| 911 | std::vector<cricket::VideoCodec> codecs; |
| 912 | codecs.push_back(kH264Codec); |
| 913 | |
| 914 | rtc::scoped_ptr<VideoMediaChannel> channel( |
| 915 | SetUpForExternalDecoderFactory(&decoder_factory, codecs)); |
| 916 | |
| 917 | EXPECT_TRUE( |
| 918 | channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 919 | ASSERT_EQ(1u, decoder_factory.decoders().size()); |
| 920 | } |
| 921 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 922 | class WebRtcVideoEngine2BaseTest |
| 923 | : public VideoEngineTest<cricket::WebRtcVideoEngine2> { |
| 924 | protected: |
| 925 | typedef VideoEngineTest<cricket::WebRtcVideoEngine2> Base; |
| 926 | }; |
| 927 | |
| 928 | #define WEBRTC_ENGINE_BASE_TEST(test) \ |
| 929 | TEST_F(WebRtcVideoEngine2BaseTest, test) { Base::test##Body(); } |
| 930 | |
| 931 | WEBRTC_ENGINE_BASE_TEST(ConstrainNewCodec2); |
| 932 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 933 | class WebRtcVideoChannel2BaseTest |
| 934 | : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> { |
| 935 | protected: |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 936 | typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 937 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 938 | cricket::VideoCodec DefaultCodec() override { return kVp8Codec; } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 939 | }; |
| 940 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 941 | #define WEBRTC_BASE_TEST(test) \ |
| 942 | TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); } |
| 943 | |
| 944 | #define WEBRTC_DISABLED_BASE_TEST(test) \ |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 945 | TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); } |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 946 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 947 | // TODO(pbos): Fix WebRtcVideoEngine2BaseTest, where we want CheckCoInitialize. |
| 948 | #if 0 |
| 949 | // TODO(juberti): Figure out why ViE is munging the COM refcount. |
| 950 | #ifdef WIN32 |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 951 | WEBRTC_DISABLED_BASE_TEST(CheckCoInitialize) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 952 | Base::CheckCoInitialize(); |
| 953 | } |
| 954 | #endif |
| 955 | #endif |
| 956 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 957 | WEBRTC_BASE_TEST(SetSend); |
| 958 | WEBRTC_BASE_TEST(SetSendWithoutCodecs); |
| 959 | WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 960 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 961 | WEBRTC_BASE_TEST(GetStats); |
| 962 | WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams); |
| 963 | WEBRTC_BASE_TEST(GetStatsMultipleSendStreams); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 964 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 965 | WEBRTC_BASE_TEST(SetSendBandwidth); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 966 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 967 | WEBRTC_BASE_TEST(SetSendSsrc); |
| 968 | WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 969 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 970 | WEBRTC_BASE_TEST(SetRenderer); |
| 971 | WEBRTC_BASE_TEST(AddRemoveRecvStreams); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 972 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 973 | WEBRTC_DISABLED_BASE_TEST(AddRemoveRecvStreamAndRender); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 974 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 975 | WEBRTC_BASE_TEST(AddRemoveRecvStreamsNoConference); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 976 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 977 | WEBRTC_BASE_TEST(AddRemoveSendStreams); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 978 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 979 | WEBRTC_BASE_TEST(SimulateConference); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 980 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 981 | WEBRTC_BASE_TEST(AddRemoveCapturer); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 982 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 983 | WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 984 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 985 | WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 986 | |
| 987 | // TODO(pbos): Figure out why this fails so often. |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 988 | WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 989 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 990 | WEBRTC_BASE_TEST(RejectEmptyStreamParams); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 991 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 992 | WEBRTC_BASE_TEST(AdaptResolution16x10); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 993 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 994 | WEBRTC_BASE_TEST(AdaptResolution4x3); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 995 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 996 | // TODO(juberti): Restore this test once we support sending 0 fps. |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 997 | WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 998 | // TODO(juberti): Understand why we get decode errors on this test. |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 999 | WEBRTC_DISABLED_BASE_TEST(AdaptFramerate); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1000 | |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1001 | WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames); |
| 1002 | |
| 1003 | WEBRTC_BASE_TEST(MuteStream); |
| 1004 | |
| 1005 | WEBRTC_BASE_TEST(MultipleSendStreams); |
| 1006 | |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 1007 | WEBRTC_BASE_TEST(SetSendStreamFormat0x0); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1008 | |
| 1009 | // TODO(zhurunz): Fix the flakey test. |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 1010 | WEBRTC_DISABLED_BASE_TEST(SetSendStreamFormat); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1011 | |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1012 | TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) { |
| 1013 | SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0)); |
| 1014 | } |
| 1015 | |
| 1016 | TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) { |
| 1017 | SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0)); |
| 1018 | } |
| 1019 | |
| 1020 | TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) { |
| 1021 | SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0)); |
| 1022 | } |
| 1023 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1024 | TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { |
| 1025 | Base::TwoStreamsSendAndReceive(kVp8Codec); |
| 1026 | } |
| 1027 | |
| 1028 | TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) { |
| 1029 | Base::TwoStreamsReUseFirstStream(kVp8Codec); |
| 1030 | } |
| 1031 | |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1032 | WEBRTC_BASE_TEST(SendManyResizeOnce); |
| 1033 | |
| 1034 | // TODO(pbos): Enable and figure out why this fails (or should work). |
| 1035 | TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) { |
| 1036 | EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL)); |
| 1037 | EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_)); |
| 1038 | channel_->UpdateAspectRatio(1280, 720); |
| 1039 | video_capturer_.reset(new cricket::FakeVideoCapturer); |
| 1040 | const std::vector<cricket::VideoFormat>* formats = |
| 1041 | video_capturer_->GetSupportedFormats(); |
| 1042 | cricket::VideoFormat capture_format_hd = (*formats)[0]; |
| 1043 | EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format_hd)); |
| 1044 | EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get())); |
| 1045 | |
| 1046 | // Capture format HD -> adapt (OnOutputFormatRequest VGA) -> VGA. |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1047 | cricket::VideoCodec codec = kVp8Codec720p; |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1048 | EXPECT_TRUE(SetOneCodec(codec)); |
| 1049 | codec.width /= 2; |
| 1050 | codec.height /= 2; |
| 1051 | EXPECT_TRUE(SetSend(true)); |
| 1052 | EXPECT_TRUE(channel_->SetRender(true)); |
| 1053 | EXPECT_EQ(0, renderer_.num_rendered_frames()); |
| 1054 | EXPECT_TRUE(SendFrame()); |
| 1055 | EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); |
| 1056 | } |
| 1057 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1058 | class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, |
| 1059 | public WebRtcCallFactory { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1060 | public: |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1061 | WebRtcVideoChannel2Test() : fake_call_(NULL) {} |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 1062 | void SetUp() override { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1063 | engine_.SetCallFactory(this); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1064 | engine_.Init(rtc::Thread::Current()); |
buildbot@webrtc.org | 1ecbe45 | 2014-10-14 20:29:28 +0000 | [diff] [blame] | 1065 | channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL)); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1066 | ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1067 | last_ssrc_ = 123; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1068 | ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1069 | } |
| 1070 | |
| 1071 | protected: |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 1072 | webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1073 | assert(fake_call_ == NULL); |
| 1074 | fake_call_ = new FakeCall(config); |
| 1075 | return fake_call_; |
| 1076 | } |
| 1077 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1078 | FakeVideoSendStream* AddSendStream() { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1079 | return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1080 | } |
| 1081 | |
| 1082 | FakeVideoSendStream* AddSendStream(const StreamParams& sp) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1083 | size_t num_streams = fake_call_->GetVideoSendStreams().size(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1084 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 1085 | std::vector<FakeVideoSendStream*> streams = |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1086 | fake_call_->GetVideoSendStreams(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1087 | EXPECT_EQ(num_streams + 1, streams.size()); |
| 1088 | return streams[streams.size() - 1]; |
| 1089 | } |
| 1090 | |
| 1091 | std::vector<FakeVideoSendStream*> GetFakeSendStreams() { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1092 | return fake_call_->GetVideoSendStreams(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1093 | } |
| 1094 | |
| 1095 | FakeVideoReceiveStream* AddRecvStream() { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1096 | return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1097 | } |
| 1098 | |
| 1099 | FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1100 | size_t num_streams = fake_call_->GetVideoReceiveStreams().size(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1101 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 1102 | std::vector<FakeVideoReceiveStream*> streams = |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1103 | fake_call_->GetVideoReceiveStreams(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1104 | EXPECT_EQ(num_streams + 1, streams.size()); |
| 1105 | return streams[streams.size() - 1]; |
| 1106 | } |
| 1107 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1108 | void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps, |
| 1109 | int expected_min_bitrate_bps, |
| 1110 | const char* start_bitrate_kbps, |
| 1111 | int expected_start_bitrate_bps, |
| 1112 | const char* max_bitrate_kbps, |
| 1113 | int expected_max_bitrate_bps) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1114 | std::vector<VideoCodec> codecs; |
| 1115 | codecs.push_back(kVp8Codec); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1116 | codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; |
| 1117 | codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; |
| 1118 | codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1119 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1120 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1121 | EXPECT_EQ(expected_min_bitrate_bps, |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1122 | fake_call_->GetConfig().bitrate_config.min_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1123 | EXPECT_EQ(expected_start_bitrate_bps, |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1124 | fake_call_->GetConfig().bitrate_config.start_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1125 | EXPECT_EQ(expected_max_bitrate_bps, |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1126 | fake_call_->GetConfig().bitrate_config.max_bitrate_bps); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1127 | } |
| 1128 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1129 | void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext, |
| 1130 | const std::string& webrtc_ext) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1131 | FakeCall* call = fake_call_; |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1132 | // Enable extension. |
| 1133 | const int id = 1; |
| 1134 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1135 | extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); |
| 1136 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1137 | |
| 1138 | FakeVideoSendStream* send_stream = |
| 1139 | AddSendStream(cricket::StreamParams::CreateLegacy(123)); |
| 1140 | |
| 1141 | // Verify the send extension id. |
| 1142 | ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
| 1143 | EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); |
| 1144 | EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); |
| 1145 | // Verify call with same set of extensions returns true. |
| 1146 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1147 | // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for |
| 1148 | // receivers. |
| 1149 | EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123)) |
| 1150 | ->GetConfig() |
| 1151 | .rtp.extensions.empty()); |
| 1152 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1153 | // Verify that existing RTP header extensions can be removed. |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1154 | std::vector<cricket::RtpHeaderExtension> empty_extensions; |
| 1155 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions)); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1156 | ASSERT_EQ(1u, call->GetVideoSendStreams().size()); |
| 1157 | send_stream = call->GetVideoSendStreams()[0]; |
| 1158 | EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); |
| 1159 | |
| 1160 | // Verify that adding receive RTP header extensions adds them for existing |
| 1161 | // streams. |
| 1162 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1163 | send_stream = call->GetVideoSendStreams()[0]; |
| 1164 | ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
| 1165 | EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); |
| 1166 | EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1167 | } |
| 1168 | |
| 1169 | void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext, |
| 1170 | const std::string& webrtc_ext) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1171 | FakeCall* call = fake_call_; |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1172 | // Enable extension. |
| 1173 | const int id = 1; |
| 1174 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1175 | extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); |
| 1176 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1177 | |
| 1178 | FakeVideoReceiveStream* recv_stream = |
| 1179 | AddRecvStream(cricket::StreamParams::CreateLegacy(123)); |
| 1180 | |
| 1181 | // Verify the recv extension id. |
| 1182 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); |
| 1183 | EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); |
| 1184 | EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); |
| 1185 | // Verify call with same set of extensions returns true. |
| 1186 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1187 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1188 | // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for |
| 1189 | // senders. |
| 1190 | EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123)) |
| 1191 | ->GetConfig() |
| 1192 | .rtp.extensions.empty()); |
| 1193 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1194 | // Verify that existing RTP header extensions can be removed. |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1195 | std::vector<cricket::RtpHeaderExtension> empty_extensions; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1196 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions)); |
| 1197 | ASSERT_EQ(1u, call->GetVideoReceiveStreams().size()); |
| 1198 | recv_stream = call->GetVideoReceiveStreams()[0]; |
| 1199 | EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty()); |
| 1200 | |
| 1201 | // Verify that adding receive RTP header extensions adds them for existing |
| 1202 | // streams. |
| 1203 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1204 | recv_stream = call->GetVideoReceiveStreams()[0]; |
| 1205 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); |
| 1206 | EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); |
| 1207 | EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1208 | } |
| 1209 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1210 | void TestCpuAdaptation(bool enable_overuse); |
| 1211 | |
| 1212 | FakeCall* fake_call_; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1213 | rtc::scoped_ptr<VideoMediaChannel> channel_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1214 | uint32 last_ssrc_; |
| 1215 | }; |
| 1216 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1217 | TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1218 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 1219 | EXPECT_TRUE(channel_->SetSend(true)); |
| 1220 | cricket::VideoOptions options; |
| 1221 | options.conference_mode.Set(true); |
| 1222 | EXPECT_TRUE(channel_->SetOptions(options)); |
| 1223 | |
| 1224 | // Send side. |
| 1225 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); |
| 1226 | const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
| 1227 | FakeVideoSendStream* send_stream = AddSendStream( |
| 1228 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
| 1229 | |
| 1230 | ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size()); |
| 1231 | for (size_t i = 0; i < rtx_ssrcs.size(); ++i) |
| 1232 | EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]); |
| 1233 | |
| 1234 | // Receiver side. |
| 1235 | FakeVideoReceiveStream* recv_stream = AddRecvStream( |
| 1236 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
| 1237 | ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u) |
| 1238 | << "No SSRCs for RTX configured by AddRecvStream."; |
| 1239 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size()) |
| 1240 | << "This test only works with one receive codec. Please update the test."; |
| 1241 | EXPECT_EQ(rtx_ssrcs[0], |
| 1242 | recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc); |
| 1243 | // TODO(pbos): Make sure we set the RTX for correct payloads etc. |
| 1244 | } |
| 1245 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1246 | TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) { |
| 1247 | // Setup one channel with an associated RTX stream. |
| 1248 | cricket::StreamParams params = |
| 1249 | cricket::StreamParams::CreateLegacy(kSsrcs1[0]); |
| 1250 | params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]); |
| 1251 | FakeVideoReceiveStream* recv_stream = AddRecvStream(params); |
| 1252 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size()); |
| 1253 | EXPECT_EQ(kRtxSsrcs1[0], |
| 1254 | recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1255 | } |
| 1256 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1257 | TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) { |
| 1258 | // Setup one channel without an associated RTX stream. |
| 1259 | cricket::StreamParams params = |
| 1260 | cricket::StreamParams::CreateLegacy(kSsrcs1[0]); |
| 1261 | FakeVideoReceiveStream* recv_stream = AddRecvStream(params); |
| 1262 | ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1263 | } |
| 1264 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1265 | TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) { |
| 1266 | FakeVideoSendStream* send_stream = |
| 1267 | AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0])); |
| 1268 | ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); |
| 1269 | |
| 1270 | FakeVideoReceiveStream* recv_stream = |
| 1271 | AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0])); |
| 1272 | ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1273 | } |
| 1274 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1275 | // Test support for RTP timestamp offset header extension. |
| 1276 | TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) { |
| 1277 | TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension, |
| 1278 | webrtc::RtpExtension::kTOffset); |
| 1279 | } |
| 1280 | TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) { |
| 1281 | TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension, |
| 1282 | webrtc::RtpExtension::kTOffset); |
| 1283 | } |
| 1284 | |
| 1285 | // Test support for absolute send time header extension. |
| 1286 | TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) { |
| 1287 | TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension, |
| 1288 | webrtc::RtpExtension::kAbsSendTime); |
| 1289 | } |
| 1290 | TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) { |
| 1291 | TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension, |
| 1292 | webrtc::RtpExtension::kAbsSendTime); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1293 | } |
| 1294 | |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1295 | // Test support for video rotation header extension. |
| 1296 | TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) { |
| 1297 | TestSetSendRtpHeaderExtensions(kRtpVideoRotationHeaderExtension, |
| 1298 | webrtc::RtpExtension::kVideoRotation); |
| 1299 | } |
| 1300 | TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) { |
| 1301 | TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension, |
| 1302 | webrtc::RtpExtension::kVideoRotation); |
| 1303 | } |
| 1304 | |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1305 | TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) { |
| 1306 | const int kTOffsetId = 1; |
| 1307 | const int kAbsSendTimeId = 2; |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1308 | const int kVideoRotationId = 3; |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1309 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1310 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1311 | kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId)); |
| 1312 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1313 | kRtpTimestampOffsetHeaderExtension, kTOffsetId)); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1314 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1315 | kRtpVideoRotationHeaderExtension, kVideoRotationId)); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1316 | |
| 1317 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1318 | FakeVideoSendStream* send_stream = |
| 1319 | AddSendStream(cricket::StreamParams::CreateLegacy(123)); |
| 1320 | |
| 1321 | EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1322 | ASSERT_EQ(3u, send_stream->GetConfig().rtp.extensions.size()); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1323 | |
| 1324 | // Setting the same extensions (even if in different order) shouldn't |
| 1325 | // reallocate the stream. |
| 1326 | std::reverse(extensions.begin(), extensions.end()); |
| 1327 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1328 | |
| 1329 | EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); |
| 1330 | |
| 1331 | // Setting different extensions should recreate the stream. |
| 1332 | extensions.resize(1); |
| 1333 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1334 | |
| 1335 | EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); |
| 1336 | } |
| 1337 | |
| 1338 | TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) { |
| 1339 | const int kTOffsetId = 1; |
| 1340 | const int kAbsSendTimeId = 2; |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1341 | const int kVideoRotationId = 3; |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1342 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1343 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1344 | kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId)); |
| 1345 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1346 | kRtpTimestampOffsetHeaderExtension, kTOffsetId)); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1347 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1348 | kRtpVideoRotationHeaderExtension, kVideoRotationId)); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1349 | |
| 1350 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1351 | FakeVideoReceiveStream* send_stream = |
| 1352 | AddRecvStream(cricket::StreamParams::CreateLegacy(123)); |
| 1353 | |
| 1354 | EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1355 | ASSERT_EQ(3u, send_stream->GetConfig().rtp.extensions.size()); |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 1356 | |
| 1357 | // Setting the same extensions (even if in different order) shouldn't |
| 1358 | // reallocate the stream. |
| 1359 | std::reverse(extensions.begin(), extensions.end()); |
| 1360 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1361 | |
| 1362 | EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); |
| 1363 | |
| 1364 | // Setting different extensions should recreate the stream. |
| 1365 | extensions.resize(1); |
| 1366 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1367 | |
| 1368 | EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams()); |
| 1369 | } |
| 1370 | |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1371 | TEST_F(WebRtcVideoChannel2Test, |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1372 | SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1373 | const int kUnsupportedId = 1; |
| 1374 | const int kTOffsetId = 2; |
| 1375 | |
| 1376 | std::vector<cricket::RtpHeaderExtension> extensions; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1377 | extensions.push_back( |
| 1378 | cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId)); |
| 1379 | extensions.push_back( |
| 1380 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1381 | EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1382 | FakeVideoSendStream* send_stream = |
| 1383 | AddSendStream(cricket::StreamParams::CreateLegacy(123)); |
| 1384 | |
| 1385 | // Only timestamp offset extension is set to send stream, |
| 1386 | // unsupported rtp extension is ignored. |
| 1387 | ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
| 1388 | EXPECT_STREQ(webrtc::RtpExtension::kTOffset, |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1389 | send_stream->GetConfig().rtp.extensions[0].name.c_str()); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1390 | } |
| 1391 | |
| 1392 | TEST_F(WebRtcVideoChannel2Test, |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1393 | SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1394 | const int kUnsupportedId = 1; |
| 1395 | const int kTOffsetId = 2; |
| 1396 | |
| 1397 | std::vector<cricket::RtpHeaderExtension> extensions; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1398 | extensions.push_back( |
| 1399 | cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId)); |
| 1400 | extensions.push_back( |
| 1401 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1402 | EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1403 | FakeVideoReceiveStream* recv_stream = |
| 1404 | AddRecvStream(cricket::StreamParams::CreateLegacy(123)); |
| 1405 | |
| 1406 | // Only timestamp offset extension is set to receive stream, |
| 1407 | // unsupported rtp extension is ignored. |
| 1408 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); |
| 1409 | EXPECT_STREQ(webrtc::RtpExtension::kTOffset, |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1410 | recv_stream->GetConfig().rtp.extensions[0].name.c_str()); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1411 | } |
| 1412 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1413 | TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) { |
Peter Boström | 23914fe | 2015-03-31 15:08:04 +0200 | [diff] [blame] | 1414 | const int kIncorrectIds[] = {-2, -1, 0, 15, 16}; |
pkasting@chromium.org | e7a4a12 | 2015-01-28 21:36:55 +0000 | [diff] [blame] | 1415 | for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1416 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1417 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1418 | webrtc::RtpExtension::kTOffset, kIncorrectIds[i])); |
| 1419 | EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions)) |
| 1420 | << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; |
| 1421 | } |
| 1422 | } |
| 1423 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1424 | TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) { |
Peter Boström | 23914fe | 2015-03-31 15:08:04 +0200 | [diff] [blame] | 1425 | const int kIncorrectIds[] = {-2, -1, 0, 15, 16}; |
pkasting@chromium.org | e7a4a12 | 2015-01-28 21:36:55 +0000 | [diff] [blame] | 1426 | for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1427 | std::vector<cricket::RtpHeaderExtension> extensions; |
| 1428 | extensions.push_back(cricket::RtpHeaderExtension( |
| 1429 | webrtc::RtpExtension::kTOffset, kIncorrectIds[i])); |
| 1430 | EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions)) |
| 1431 | << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; |
| 1432 | } |
| 1433 | } |
| 1434 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1435 | TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1436 | const int id = 1; |
| 1437 | std::vector<cricket::RtpHeaderExtension> extensions; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1438 | extensions.push_back( |
| 1439 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id)); |
| 1440 | extensions.push_back( |
| 1441 | cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1442 | EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1443 | |
| 1444 | // Duplicate entries are also not supported. |
| 1445 | extensions.clear(); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1446 | extensions.push_back( |
| 1447 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1448 | extensions.push_back(extensions.back()); |
| 1449 | EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions)); |
| 1450 | } |
| 1451 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1452 | TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1453 | const int id = 1; |
| 1454 | std::vector<cricket::RtpHeaderExtension> extensions; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1455 | extensions.push_back( |
| 1456 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id)); |
| 1457 | extensions.push_back( |
| 1458 | cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1459 | EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1460 | |
| 1461 | // Duplicate entries are also not supported. |
| 1462 | extensions.clear(); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1463 | extensions.push_back( |
| 1464 | cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id)); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1465 | extensions.push_back(extensions.back()); |
| 1466 | EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
| 1467 | } |
| 1468 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1469 | TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) { |
| 1470 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1471 | } |
| 1472 | |
| 1473 | TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) { |
| 1474 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1475 | } |
| 1476 | |
| 1477 | TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) { |
| 1478 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1479 | } |
| 1480 | |
| 1481 | TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) { |
| 1482 | EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1483 | EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1484 | } |
| 1485 | |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1486 | TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) { |
| 1487 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 1488 | EXPECT_TRUE(stream->GetConfig().rtp.remb); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1489 | } |
| 1490 | |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1491 | TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) { |
| 1492 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 1493 | EXPECT_TRUE(stream->GetConfig().rtp.remb); |
| 1494 | |
| 1495 | // Verify that REMB is turned off when codecs without REMB are set. |
| 1496 | std::vector<VideoCodec> codecs; |
| 1497 | codecs.push_back(kVp8Codec); |
| 1498 | EXPECT_TRUE(codecs[0].feedback_params.params().empty()); |
| 1499 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1500 | stream = fake_call_->GetVideoReceiveStreams()[0]; |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1501 | EXPECT_FALSE(stream->GetConfig().rtp.remb); |
| 1502 | |
| 1503 | // Verify that REMB is turned on when setting default codecs since the |
| 1504 | // default codecs have REMB enabled. |
| 1505 | EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs())); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1506 | stream = fake_call_->GetVideoReceiveStreams()[0]; |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1507 | EXPECT_TRUE(stream->GetConfig().rtp.remb); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1508 | } |
| 1509 | |
pbos@webrtc.org | f99c2f2 | 2014-06-13 12:27:38 +0000 | [diff] [blame] | 1510 | TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) { |
| 1511 | VerifyCodecHasDefaultFeedbackParams(default_codec_); |
| 1512 | |
pbos@webrtc.org | 1986474 | 2014-05-30 07:35:47 +0000 | [diff] [blame] | 1513 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 1514 | EXPECT_TRUE(channel_->SetSend(true)); |
| 1515 | |
| 1516 | // Send side. |
| 1517 | FakeVideoSendStream* send_stream = |
| 1518 | AddSendStream(cricket::StreamParams::CreateLegacy(1)); |
| 1519 | EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
| 1520 | |
| 1521 | // Receiver side. |
| 1522 | FakeVideoReceiveStream* recv_stream = |
| 1523 | AddRecvStream(cricket::StreamParams::CreateLegacy(1)); |
| 1524 | EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
| 1525 | |
| 1526 | // Nack history size should match between sender and receiver. |
| 1527 | EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms, |
| 1528 | recv_stream->GetConfig().rtp.nack.rtp_history_ms); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1529 | } |
| 1530 | |
pbos@webrtc.org | f99c2f2 | 2014-06-13 12:27:38 +0000 | [diff] [blame] | 1531 | TEST_F(WebRtcVideoChannel2Test, NackCanBeDisabled) { |
| 1532 | std::vector<VideoCodec> codecs; |
| 1533 | codecs.push_back(kVp8Codec); |
| 1534 | |
| 1535 | // Send side. |
| 1536 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1537 | FakeVideoSendStream* send_stream = |
| 1538 | AddSendStream(cricket::StreamParams::CreateLegacy(1)); |
| 1539 | EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms); |
| 1540 | |
| 1541 | // Receiver side. |
| 1542 | ASSERT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 1543 | FakeVideoReceiveStream* recv_stream = |
| 1544 | AddRecvStream(cricket::StreamParams::CreateLegacy(1)); |
| 1545 | EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); |
| 1546 | } |
| 1547 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1548 | TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) { |
| 1549 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1550 | } |
| 1551 | |
| 1552 | TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) { |
| 1553 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1554 | } |
| 1555 | |
| 1556 | TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) { |
| 1557 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1558 | } |
| 1559 | |
| 1560 | TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) { |
| 1561 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1562 | } |
| 1563 | |
| 1564 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRender) { |
| 1565 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1566 | } |
| 1567 | |
| 1568 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) { |
| 1569 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1570 | } |
| 1571 | |
| 1572 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) { |
| 1573 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1574 | } |
| 1575 | |
| 1576 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) { |
| 1577 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1578 | } |
| 1579 | |
| 1580 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) { |
| 1581 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1582 | } |
| 1583 | |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1584 | TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { |
| 1585 | static const int kScreenshareMinBitrateKbps = 800; |
| 1586 | cricket::VideoCodec codec = kVp8Codec360p; |
| 1587 | std::vector<cricket::VideoCodec> codecs; |
| 1588 | codecs.push_back(codec); |
| 1589 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1590 | VideoOptions options; |
| 1591 | options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps); |
| 1592 | channel_->SetOptions(options); |
| 1593 | |
| 1594 | AddSendStream(); |
| 1595 | |
| 1596 | cricket::FakeVideoCapturer capturer; |
| 1597 | capturer.SetScreencast(false); |
| 1598 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); |
| 1599 | cricket::VideoFormat capture_format_hd = |
| 1600 | capturer.GetSupportedFormats()->front(); |
| 1601 | EXPECT_EQ(1280, capture_format_hd.width); |
| 1602 | EXPECT_EQ(720, capture_format_hd.height); |
| 1603 | EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd)); |
| 1604 | |
| 1605 | EXPECT_TRUE(channel_->SetSend(true)); |
| 1606 | |
| 1607 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1608 | ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
| 1609 | FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
| 1610 | |
| 1611 | EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
| 1612 | |
| 1613 | // Verify non-screencast settings. |
| 1614 | webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig(); |
| 1615 | EXPECT_EQ(webrtc::VideoEncoderConfig::kRealtimeVideo, |
| 1616 | encoder_config.content_type); |
| 1617 | EXPECT_EQ(codec.width, encoder_config.streams.front().width); |
| 1618 | EXPECT_EQ(codec.height, encoder_config.streams.front().height); |
| 1619 | EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps) |
| 1620 | << "Non-screenshare shouldn't use min-transmit bitrate."; |
| 1621 | |
| 1622 | capturer.SetScreencast(true); |
| 1623 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1624 | |
| 1625 | EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); |
| 1626 | |
| 1627 | // Verify screencast settings. |
| 1628 | encoder_config = send_stream->GetEncoderConfig(); |
| 1629 | EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare, |
| 1630 | encoder_config.content_type); |
| 1631 | EXPECT_EQ(kScreenshareMinBitrateKbps * 1000, |
| 1632 | encoder_config.min_transmit_bitrate_bps); |
| 1633 | |
| 1634 | EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width); |
| 1635 | EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height); |
pbos@webrtc.org | b7ed779 | 2014-10-31 13:08:10 +0000 | [diff] [blame] | 1636 | EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty()); |
| 1637 | |
| 1638 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); |
| 1639 | } |
| 1640 | |
| 1641 | TEST_F(WebRtcVideoChannel2Test, |
| 1642 | ConferenceModeScreencastConfiguresTemporalLayer) { |
| 1643 | static const int kConferenceScreencastTemporalBitrateBps = 100000; |
| 1644 | VideoOptions options; |
| 1645 | options.conference_mode.Set(true); |
| 1646 | channel_->SetOptions(options); |
| 1647 | |
| 1648 | AddSendStream(); |
| 1649 | |
| 1650 | cricket::FakeVideoCapturer capturer; |
| 1651 | capturer.SetScreencast(true); |
| 1652 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); |
| 1653 | cricket::VideoFormat capture_format_hd = |
| 1654 | capturer.GetSupportedFormats()->front(); |
| 1655 | EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd)); |
| 1656 | |
| 1657 | EXPECT_TRUE(channel_->SetSend(true)); |
| 1658 | |
| 1659 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1660 | ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
| 1661 | FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
| 1662 | |
| 1663 | webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig(); |
| 1664 | |
| 1665 | // Verify screencast settings. |
| 1666 | encoder_config = send_stream->GetEncoderConfig(); |
| 1667 | EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare, |
| 1668 | encoder_config.content_type); |
| 1669 | ASSERT_EQ(1u, encoder_config.streams.size()); |
| 1670 | ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size()); |
| 1671 | EXPECT_EQ(kConferenceScreencastTemporalBitrateBps, |
| 1672 | encoder_config.streams[0].temporal_layer_thresholds_bps[0]); |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1673 | |
| 1674 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1675 | } |
| 1676 | |
| 1677 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) { |
| 1678 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1679 | } |
| 1680 | |
| 1681 | TEST_F(WebRtcVideoChannel2Test, |
| 1682 | DISABLED_SetSendSsrcAfterCreatingReceiveChannel) { |
| 1683 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1684 | } |
| 1685 | |
pbos@webrtc.org | 5ff71ab | 2014-07-23 07:28:56 +0000 | [diff] [blame] | 1686 | TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) { |
| 1687 | FakeVideoSendStream* stream = AddSendStream(); |
| 1688 | EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate); |
| 1689 | } |
| 1690 | |
| 1691 | TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) { |
| 1692 | VideoOptions options; |
| 1693 | options.suspend_below_min_bitrate.Set(true); |
| 1694 | channel_->SetOptions(options); |
| 1695 | |
| 1696 | FakeVideoSendStream* stream = AddSendStream(); |
| 1697 | EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate); |
| 1698 | |
| 1699 | options.suspend_below_min_bitrate.Set(false); |
| 1700 | channel_->SetOptions(options); |
| 1701 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1702 | stream = fake_call_->GetVideoSendStreams()[0]; |
pbos@webrtc.org | 5ff71ab | 2014-07-23 07:28:56 +0000 | [diff] [blame] | 1703 | EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate); |
| 1704 | } |
| 1705 | |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1706 | TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { |
| 1707 | FakeVideoSendStream* stream = AddSendStream(); |
| 1708 | webrtc::VideoCodecVP8 vp8_settings; |
| 1709 | ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; |
| 1710 | EXPECT_TRUE(vp8_settings.denoisingOn); |
| 1711 | } |
| 1712 | |
| 1713 | TEST_F(WebRtcVideoChannel2Test, SetOptionsWithDenoising) { |
| 1714 | VideoOptions options; |
| 1715 | options.video_noise_reduction.Set(false); |
| 1716 | channel_->SetOptions(options); |
| 1717 | |
| 1718 | FakeVideoSendStream* stream = AddSendStream(); |
| 1719 | webrtc::VideoCodecVP8 vp8_settings; |
| 1720 | ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; |
| 1721 | EXPECT_FALSE(vp8_settings.denoisingOn); |
| 1722 | |
| 1723 | options.video_noise_reduction.Set(true); |
| 1724 | channel_->SetOptions(options); |
| 1725 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1726 | stream = fake_call_->GetVideoSendStreams()[0]; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1727 | ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; |
| 1728 | EXPECT_TRUE(vp8_settings.denoisingOn); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1729 | } |
| 1730 | |
| 1731 | TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) { |
| 1732 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1733 | } |
| 1734 | |
pbos@webrtc.org | 8aed945 | 2014-07-26 10:16:49 +0000 | [diff] [blame] | 1735 | TEST_F(WebRtcVideoChannel2Test, DISABLED_SendReceiveBitratesStats) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1736 | FAIL() << "Not implemented."; // TODO(pbos): Implement. |
| 1737 | } |
| 1738 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1739 | TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) { |
| 1740 | TestCpuAdaptation(true); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1741 | } |
| 1742 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1743 | TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) { |
| 1744 | TestCpuAdaptation(false); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1745 | } |
| 1746 | |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1747 | void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse) { |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1748 | cricket::VideoCodec codec = kVp8Codec720p; |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1749 | std::vector<cricket::VideoCodec> codecs; |
| 1750 | codecs.push_back(codec); |
| 1751 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1752 | |
Peter Boström | e432800 | 2015-04-14 22:45:29 +0200 | [diff] [blame] | 1753 | if (!enable_overuse) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1754 | VideoOptions options; |
Peter Boström | e432800 | 2015-04-14 22:45:29 +0200 | [diff] [blame] | 1755 | options.cpu_overuse_detection.Set(false); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1756 | channel_->SetOptions(options); |
| 1757 | } |
| 1758 | |
| 1759 | AddSendStream(); |
| 1760 | |
| 1761 | cricket::FakeVideoCapturer capturer; |
| 1762 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); |
| 1763 | EXPECT_EQ(cricket::CS_RUNNING, |
| 1764 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 1765 | |
| 1766 | EXPECT_TRUE(channel_->SetSend(true)); |
| 1767 | |
| 1768 | // Trigger overuse. |
| 1769 | webrtc::LoadObserver* overuse_callback = |
| 1770 | fake_call_->GetConfig().overuse_callback; |
| 1771 | ASSERT_TRUE(overuse_callback != NULL); |
| 1772 | overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); |
| 1773 | |
| 1774 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1775 | ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
| 1776 | FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
| 1777 | |
| 1778 | EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
| 1779 | |
| 1780 | if (enable_overuse) { |
| 1781 | EXPECT_LT(send_stream->GetLastWidth(), codec.width); |
| 1782 | EXPECT_LT(send_stream->GetLastHeight(), codec.height); |
| 1783 | } else { |
| 1784 | EXPECT_EQ(codec.width, send_stream->GetLastWidth()); |
| 1785 | EXPECT_EQ(codec.height, send_stream->GetLastHeight()); |
| 1786 | } |
| 1787 | |
| 1788 | // Trigger underuse which should go back to normal resolution. |
| 1789 | overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); |
| 1790 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1791 | |
| 1792 | EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); |
| 1793 | |
| 1794 | EXPECT_EQ(codec.width, send_stream->GetLastWidth()); |
| 1795 | EXPECT_EQ(codec.height, send_stream->GetLastHeight()); |
| 1796 | |
| 1797 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1798 | } |
| 1799 | |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 1800 | TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeAndElapsedTimeCorrectly) { |
| 1801 | // Start at last timestamp to verify that wraparounds are estimated correctly. |
| 1802 | static const uint32_t kInitialTimestamp = 0xFFFFFFFFu; |
| 1803 | static const int64_t kInitialNtpTimeMs = 1247891230; |
| 1804 | static const int kFrameOffsetMs = 20; |
| 1805 | EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs())); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1806 | |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 1807 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 1808 | cricket::FakeVideoRenderer renderer; |
| 1809 | EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer)); |
| 1810 | EXPECT_TRUE(channel_->SetRender(true)); |
| 1811 | |
| 1812 | webrtc::I420VideoFrame video_frame; |
| 1813 | CreateBlackFrame(&video_frame, 4, 4); |
| 1814 | video_frame.set_timestamp(kInitialTimestamp); |
| 1815 | // Initial NTP time is not available on the first frame, but should still be |
| 1816 | // able to be estimated. |
| 1817 | stream->InjectFrame(video_frame, 0); |
| 1818 | |
| 1819 | EXPECT_EQ(1, renderer.num_rendered_frames()); |
| 1820 | EXPECT_EQ(0, renderer.last_frame_elapsed_time_ns()); |
| 1821 | |
| 1822 | // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which |
| 1823 | // triggers a constant-overflow warning, hence we're calculating it explicitly |
| 1824 | // here. |
| 1825 | video_frame.set_timestamp(kFrameOffsetMs * 90 - 1); |
| 1826 | video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs); |
| 1827 | stream->InjectFrame(video_frame, 0); |
| 1828 | |
| 1829 | EXPECT_EQ(2, renderer.num_rendered_frames()); |
| 1830 | EXPECT_EQ(kFrameOffsetMs * rtc::kNumNanosecsPerMillisec, |
| 1831 | renderer.last_frame_elapsed_time_ns()); |
| 1832 | |
| 1833 | // Verify that NTP time has been correctly deduced. |
| 1834 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 1835 | ASSERT_TRUE(channel_->GetStats(&info)); |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 1836 | ASSERT_EQ(1u, info.receivers.size()); |
| 1837 | EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1838 | } |
| 1839 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1840 | TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) { |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 1841 | ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1842 | |
| 1843 | VideoCodec codec; |
| 1844 | EXPECT_TRUE(channel_->GetSendCodec(&codec)); |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 1845 | EXPECT_TRUE(codec.Matches(engine_.codecs()[0])); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1846 | |
| 1847 | // Using a RTX setup to verify that the default RTX payload type is good. |
| 1848 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); |
| 1849 | const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
| 1850 | FakeVideoSendStream* stream = AddSendStream( |
| 1851 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
| 1852 | webrtc::VideoSendStream::Config config = stream->GetConfig(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1853 | |
| 1854 | // Make sure NACK and FEC are enabled on the correct payload types. |
| 1855 | EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); |
| 1856 | EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type); |
| 1857 | EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type); |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 1858 | |
| 1859 | EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); |
| 1860 | EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]); |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 1861 | VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1862 | // TODO(juberti): Check RTCP, PLI, TMMBR. |
| 1863 | } |
| 1864 | |
| 1865 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { |
| 1866 | std::vector<VideoCodec> codecs; |
| 1867 | codecs.push_back(kVp8Codec); |
| 1868 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1869 | |
| 1870 | FakeVideoSendStream* stream = AddSendStream(); |
| 1871 | webrtc::VideoSendStream::Config config = stream->GetConfig(); |
| 1872 | |
| 1873 | EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type); |
| 1874 | EXPECT_EQ(-1, config.rtp.fec.red_payload_type); |
| 1875 | } |
| 1876 | |
| 1877 | TEST_F(WebRtcVideoChannel2Test, |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 1878 | SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { |
| 1879 | std::vector<VideoCodec> codecs; |
| 1880 | cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0); |
| 1881 | codecs.push_back(rtx_codec); |
| 1882 | EXPECT_FALSE(channel_->SetSendCodecs(codecs)) |
| 1883 | << "RTX codec without associated payload type should be rejected."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1884 | } |
| 1885 | |
| 1886 | TEST_F(WebRtcVideoChannel2Test, |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 1887 | SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { |
| 1888 | std::vector<VideoCodec> codecs; |
| 1889 | cricket::VideoCodec rtx_codec = |
| 1890 | cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id); |
| 1891 | codecs.push_back(kVp8Codec); |
| 1892 | codecs.push_back(rtx_codec); |
| 1893 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1894 | |
| 1895 | cricket::VideoCodec rtx_codec2 = |
| 1896 | cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1); |
| 1897 | codecs.pop_back(); |
| 1898 | codecs.push_back(rtx_codec2); |
| 1899 | EXPECT_FALSE(channel_->SetSendCodecs(codecs)) |
| 1900 | << "RTX without matching video codec should be rejected."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1901 | } |
| 1902 | |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 1903 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) { |
| 1904 | std::vector<VideoCodec> codecs; |
| 1905 | codecs.push_back(kVp8Codec); |
| 1906 | codecs.push_back(kUlpfecCodec); |
| 1907 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 1908 | |
| 1909 | FakeVideoSendStream* stream = AddSendStream(); |
| 1910 | webrtc::VideoSendStream::Config config = stream->GetConfig(); |
| 1911 | |
| 1912 | EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type); |
| 1913 | |
| 1914 | codecs.pop_back(); |
| 1915 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1916 | stream = fake_call_->GetVideoSendStreams()[0]; |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 1917 | ASSERT_TRUE(stream != NULL); |
| 1918 | config = stream->GetConfig(); |
| 1919 | EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type) |
| 1920 | << "SetSendCodec without FEC should disable current FEC."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1921 | } |
| 1922 | |
pbos@webrtc.org | 38ce7d0 | 2014-07-16 08:01:38 +0000 | [diff] [blame] | 1923 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) { |
| 1924 | std::vector<VideoCodec> codecs; |
| 1925 | codecs.push_back(kVp8Codec720p); |
| 1926 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 1927 | channel_->SetSend(true); |
pbos@webrtc.org | 38ce7d0 | 2014-07-16 08:01:38 +0000 | [diff] [blame] | 1928 | |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 1929 | FakeVideoSendStream* stream = AddSendStream(); |
| 1930 | |
| 1931 | cricket::FakeVideoCapturer capturer; |
| 1932 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); |
| 1933 | EXPECT_EQ(cricket::CS_RUNNING, |
| 1934 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 1935 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 1936 | |
| 1937 | std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); |
pbos@webrtc.org | 38ce7d0 | 2014-07-16 08:01:38 +0000 | [diff] [blame] | 1938 | EXPECT_EQ(kVp8Codec720p.width, streams[0].width); |
| 1939 | EXPECT_EQ(kVp8Codec720p.height, streams[0].height); |
| 1940 | |
| 1941 | codecs.clear(); |
| 1942 | codecs.push_back(kVp8Codec360p); |
| 1943 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 1944 | streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams(); |
pbos@webrtc.org | 38ce7d0 | 2014-07-16 08:01:38 +0000 | [diff] [blame] | 1945 | EXPECT_EQ(kVp8Codec360p.width, streams[0].width); |
| 1946 | EXPECT_EQ(kVp8Codec360p.height, streams[0].height); |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 1947 | EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1948 | } |
| 1949 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1950 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) { |
| 1951 | SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
| 1952 | 200000); |
| 1953 | } |
| 1954 | |
pbos@webrtc.org | a5f6fb5 | 2015-03-23 22:29:39 +0000 | [diff] [blame] | 1955 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) { |
| 1956 | SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); |
| 1957 | std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams(); |
| 1958 | ASSERT_EQ(1u, streams.size()); |
| 1959 | EXPECT_EQ(10000000, streams[0].max_bitrate_bps); |
| 1960 | } |
| 1961 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1962 | TEST_F(WebRtcVideoChannel2Test, |
| 1963 | SetSendCodecsWithoutBitratesUsesCorrectDefaults) { |
| 1964 | SetSendCodecsShouldWorkForBitrates( |
| 1965 | "", 0, "", -1, "", -1); |
| 1966 | } |
| 1967 | |
| 1968 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) { |
| 1969 | SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1970 | } |
| 1971 | |
| 1972 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) { |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 1973 | std::vector<VideoCodec> video_codecs = engine_.codecs(); |
pbos@webrtc.org | 88ef632 | 2014-11-04 15:29:29 +0000 | [diff] [blame] | 1974 | video_codecs[0].params[kCodecParamMinBitrate] = "300"; |
| 1975 | video_codecs[0].params[kCodecParamMaxBitrate] = "200"; |
pbos@webrtc.org | 9fbb717 | 2014-06-13 09:34:13 +0000 | [diff] [blame] | 1976 | EXPECT_FALSE(channel_->SetSendCodecs(video_codecs)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1977 | } |
| 1978 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1979 | TEST_F(WebRtcVideoChannel2Test, |
| 1980 | SetMaxSendBandwidthShouldPreserveOtherBitrates) { |
| 1981 | SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
| 1982 | 200000); |
| 1983 | channel_->SetMaxSendBandwidth(300000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1984 | EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps) |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1985 | << "Setting max bitrate should keep previous min bitrate."; |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1986 | EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps) |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1987 | << "Setting max bitrate should not reset start bitrate."; |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1988 | EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1989 | } |
| 1990 | |
| 1991 | TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) { |
| 1992 | channel_->SetMaxSendBandwidth(300000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1993 | EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1994 | // <= 0 means disable (infinite) max bitrate. |
| 1995 | channel_->SetMaxSendBandwidth(0); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1996 | EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps) |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 1997 | << "Setting zero max bitrate did not reset start bitrate."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1998 | } |
| 1999 | |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 2000 | TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { |
| 2001 | std::vector<VideoCodec> codecs; |
| 2002 | codecs.push_back(kVp8Codec720p); |
| 2003 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2004 | channel_->SetSend(true); |
| 2005 | |
| 2006 | FakeVideoSendStream* stream = AddSendStream(); |
| 2007 | |
| 2008 | std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); |
| 2009 | int initial_max_bitrate_bps = streams[0].max_bitrate_bps; |
| 2010 | EXPECT_GT(initial_max_bitrate_bps, 0); |
| 2011 | |
| 2012 | EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2)); |
| 2013 | streams = stream->GetVideoStreams(); |
| 2014 | EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps); |
| 2015 | } |
| 2016 | |
| 2017 | TEST_F(WebRtcVideoChannel2Test, |
| 2018 | SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { |
| 2019 | std::vector<VideoCodec> codecs; |
| 2020 | codecs.push_back(kVp8Codec720p); |
| 2021 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2022 | channel_->SetSend(true); |
| 2023 | |
| 2024 | FakeVideoSendStream* stream = AddSendStream( |
| 2025 | cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); |
| 2026 | |
| 2027 | // Send a frame to make sure this scales up to >1 stream (simulcast). |
| 2028 | cricket::FakeVideoCapturer capturer; |
| 2029 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer)); |
| 2030 | EXPECT_EQ(cricket::CS_RUNNING, |
| 2031 | capturer.Start(capturer.GetSupportedFormats()->front())); |
| 2032 | EXPECT_TRUE(capturer.CaptureFrame()); |
| 2033 | |
| 2034 | std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); |
| 2035 | ASSERT_GT(streams.size(), 1u) |
| 2036 | << "Without simulcast this test doesn't make sense."; |
| 2037 | int initial_max_bitrate_bps = 0; |
| 2038 | for (auto& video_stream : streams) |
| 2039 | initial_max_bitrate_bps += video_stream.max_bitrate_bps; |
| 2040 | EXPECT_GT(initial_max_bitrate_bps, 0); |
| 2041 | |
| 2042 | EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2)); |
| 2043 | streams = stream->GetVideoStreams(); |
| 2044 | int increased_max_bitrate_bps = 0; |
| 2045 | for (auto& video_stream : streams) |
| 2046 | increased_max_bitrate_bps += video_stream.max_bitrate_bps; |
| 2047 | EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps); |
| 2048 | |
| 2049 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr)); |
| 2050 | } |
| 2051 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2052 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) { |
| 2053 | static const char* kMaxQuantization = "21"; |
| 2054 | std::vector<VideoCodec> codecs; |
| 2055 | codecs.push_back(kVp8Codec); |
| 2056 | codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; |
| 2057 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 2058 | EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)), |
| 2059 | AddSendStream()->GetVideoStreams().back().max_qp); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2060 | |
| 2061 | VideoCodec codec; |
| 2062 | EXPECT_TRUE(channel_->GetSendCodec(&codec)); |
| 2063 | EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]); |
| 2064 | } |
| 2065 | |
| 2066 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) { |
| 2067 | std::vector<cricket::VideoCodec> codecs; |
| 2068 | codecs.push_back(kVp8Codec); |
| 2069 | |
| 2070 | codecs[0].width = 0; |
| 2071 | EXPECT_FALSE(channel_->SetSendCodecs(codecs)) |
| 2072 | << "Codec set though codec width is zero."; |
| 2073 | |
| 2074 | codecs[0].width = kVp8Codec.width; |
| 2075 | codecs[0].height = 0; |
| 2076 | EXPECT_FALSE(channel_->SetSendCodecs(codecs)) |
| 2077 | << "Codec set though codec height is zero."; |
| 2078 | } |
| 2079 | |
| 2080 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { |
| 2081 | // TODO(pbos): Should we only allow the dynamic range? |
pkasting@chromium.org | e7a4a12 | 2015-01-28 21:36:55 +0000 | [diff] [blame] | 2082 | static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2083 | std::vector<cricket::VideoCodec> codecs; |
| 2084 | codecs.push_back(kVp8Codec); |
pkasting@chromium.org | e7a4a12 | 2015-01-28 21:36:55 +0000 | [diff] [blame] | 2085 | for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 2086 | codecs[0].id = kIncorrectPayloads[i]; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2087 | EXPECT_FALSE(channel_->SetSendCodecs(codecs)) |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 2088 | << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2089 | } |
| 2090 | } |
| 2091 | |
| 2092 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { |
| 2093 | std::vector<cricket::VideoCodec> codecs; |
| 2094 | codecs.push_back(kVp8Codec); |
| 2095 | for (int payload_type = 0; payload_type <= 127; ++payload_type) { |
| 2096 | codecs[0].id = payload_type; |
| 2097 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)) |
| 2098 | << "Payload type '" << payload_type << "' rejected."; |
| 2099 | } |
| 2100 | } |
| 2101 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2102 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) { |
| 2103 | std::vector<cricket::VideoCodec> codecs; |
| 2104 | codecs.push_back(kVp8Codec); |
| 2105 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2106 | } |
| 2107 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2108 | // Test that we set our inbound RTX codecs properly. |
| 2109 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { |
| 2110 | std::vector<cricket::VideoCodec> codecs; |
| 2111 | codecs.push_back(kVp8Codec); |
| 2112 | cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0); |
| 2113 | codecs.push_back(rtx_codec); |
| 2114 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) |
| 2115 | << "RTX codec without associated payload should be rejected."; |
| 2116 | |
| 2117 | codecs[1].SetParam("apt", kVp8Codec.id + 1); |
| 2118 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) |
| 2119 | << "RTX codec with invalid associated payload type should be rejected."; |
| 2120 | |
| 2121 | codecs[1].SetParam("apt", kVp8Codec.id); |
| 2122 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2123 | |
| 2124 | cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0); |
| 2125 | rtx_codec2.SetParam("apt", rtx_codec.id); |
| 2126 | codecs.push_back(rtx_codec2); |
| 2127 | |
| 2128 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX " |
| 2129 | "as associated payload type " |
| 2130 | "should be rejected."; |
| 2131 | } |
| 2132 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2133 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) { |
| 2134 | std::vector<cricket::VideoCodec> codecs; |
| 2135 | codecs.push_back(kVp8Codec); |
| 2136 | codecs[0].id = 99; |
| 2137 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2138 | } |
| 2139 | |
pbos@webrtc.org | ccbed3b | 2014-07-11 13:02:54 +0000 | [diff] [blame] | 2140 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2141 | EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs())); |
pbos@webrtc.org | ccbed3b | 2014-07-11 13:02:54 +0000 | [diff] [blame] | 2142 | |
| 2143 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 2144 | webrtc::VideoReceiveStream::Config config = stream->GetConfig(); |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2145 | EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name); |
| 2146 | EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2147 | } |
| 2148 | |
| 2149 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { |
| 2150 | std::vector<VideoCodec> codecs; |
| 2151 | codecs.push_back(kVp8Codec); |
| 2152 | codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0)); |
| 2153 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); |
| 2154 | } |
| 2155 | |
| 2156 | // TODO(pbos): Enable VP9 through external codec support |
| 2157 | TEST_F(WebRtcVideoChannel2Test, |
| 2158 | DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) { |
| 2159 | std::vector<VideoCodec> codecs; |
| 2160 | codecs.push_back(kVp8Codec); |
| 2161 | codecs.push_back(kVp9Codec); |
| 2162 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2163 | } |
| 2164 | |
| 2165 | TEST_F(WebRtcVideoChannel2Test, |
| 2166 | DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) { |
| 2167 | std::vector<VideoCodec> codecs; |
| 2168 | codecs.push_back(kVp8Codec); |
| 2169 | codecs.push_back(kVp9Codec); |
| 2170 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2171 | FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs. |
| 2172 | } |
| 2173 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2174 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { |
| 2175 | std::vector<VideoCodec> codecs; |
| 2176 | codecs.push_back(kVp8Codec); |
| 2177 | codecs.push_back(kUlpfecCodec); |
| 2178 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2179 | |
| 2180 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 2181 | webrtc::VideoReceiveStream::Config config = stream->GetConfig(); |
| 2182 | |
| 2183 | EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type); |
| 2184 | |
| 2185 | codecs.pop_back(); |
| 2186 | ASSERT_TRUE(channel_->SetRecvCodecs(codecs)); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 2187 | stream = fake_call_->GetVideoReceiveStreams()[0]; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2188 | ASSERT_TRUE(stream != NULL); |
| 2189 | config = stream->GetConfig(); |
| 2190 | EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type) |
| 2191 | << "SetSendCodec without FEC should disable current FEC."; |
pbos@webrtc.org | 269605c | 2014-06-26 08:49:03 +0000 | [diff] [blame] | 2192 | } |
| 2193 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2194 | TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) { |
| 2195 | std::vector<VideoCodec> codecs; |
| 2196 | codecs.push_back(kVp8Codec); |
| 2197 | codecs.push_back(kRedCodec); |
| 2198 | codecs[1].id = codecs[0].id; |
| 2199 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); |
| 2200 | } |
| 2201 | |
| 2202 | TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { |
| 2203 | std::vector<VideoCodec> codecs; |
| 2204 | codecs.push_back(kVp8Codec); |
| 2205 | codecs.push_back(kVp9Codec); |
| 2206 | codecs[1].id = codecs[0].id; |
| 2207 | EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); |
| 2208 | } |
| 2209 | |
| 2210 | TEST_F(WebRtcVideoChannel2Test, |
| 2211 | SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { |
| 2212 | std::vector<VideoCodec> codecs; |
| 2213 | codecs.push_back(kVp8Codec); |
| 2214 | codecs.push_back(kVp8Codec); |
| 2215 | codecs[1].id += 1; |
| 2216 | EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); |
| 2217 | } |
| 2218 | |
| 2219 | TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) { |
| 2220 | EXPECT_FALSE(AddSendStream()->IsSending()); |
| 2221 | } |
| 2222 | |
pbos@webrtc.org | 85f4294 | 2014-07-22 09:14:58 +0000 | [diff] [blame] | 2223 | TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) { |
| 2224 | EXPECT_TRUE(AddRecvStream()->IsReceiving()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2225 | } |
| 2226 | |
| 2227 | TEST_F(WebRtcVideoChannel2Test, SetSend) { |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 2228 | FakeVideoSendStream* stream = AddSendStream(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2229 | EXPECT_FALSE(stream->IsSending()); |
| 2230 | |
| 2231 | // false->true |
| 2232 | EXPECT_TRUE(channel_->SetSend(true)); |
| 2233 | EXPECT_TRUE(stream->IsSending()); |
| 2234 | // true->true |
| 2235 | EXPECT_TRUE(channel_->SetSend(true)); |
| 2236 | EXPECT_TRUE(stream->IsSending()); |
| 2237 | // true->false |
| 2238 | EXPECT_TRUE(channel_->SetSend(false)); |
| 2239 | EXPECT_FALSE(stream->IsSending()); |
| 2240 | // false->false |
| 2241 | EXPECT_TRUE(channel_->SetSend(false)); |
| 2242 | EXPECT_FALSE(stream->IsSending()); |
| 2243 | |
| 2244 | EXPECT_TRUE(channel_->SetSend(true)); |
| 2245 | FakeVideoSendStream* new_stream = AddSendStream(); |
| 2246 | EXPECT_TRUE(new_stream->IsSending()) |
| 2247 | << "Send stream created after SetSend(true) not sending initially."; |
| 2248 | } |
| 2249 | |
pbos@webrtc.org | d819803 | 2014-11-10 14:41:43 +0000 | [diff] [blame] | 2250 | // This test verifies DSCP settings are properly applied on video media channel. |
| 2251 | TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) { |
| 2252 | rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface( |
| 2253 | new cricket::FakeNetworkInterface); |
| 2254 | channel_->SetInterface(network_interface.get()); |
| 2255 | cricket::VideoOptions options; |
| 2256 | options.dscp.Set(true); |
| 2257 | EXPECT_TRUE(channel_->SetOptions(options)); |
| 2258 | EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp()); |
| 2259 | // Verify previous value is not modified if dscp option is not set. |
| 2260 | cricket::VideoOptions options1; |
| 2261 | EXPECT_TRUE(channel_->SetOptions(options1)); |
| 2262 | EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp()); |
| 2263 | options.dscp.Set(false); |
| 2264 | EXPECT_TRUE(channel_->SetOptions(options)); |
| 2265 | EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp()); |
| 2266 | channel_->SetInterface(NULL); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2267 | } |
| 2268 | |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 2269 | TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) { |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 2270 | EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState()); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 2271 | |
| 2272 | channel_->OnReadyToSend(false); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 2273 | EXPECT_EQ(webrtc::Call::kNetworkDown, fake_call_->GetNetworkState()); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 2274 | |
| 2275 | channel_->OnReadyToSend(true); |
pbos@webrtc.org | 42684be | 2014-10-03 11:25:45 +0000 | [diff] [blame] | 2276 | EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2277 | } |
| 2278 | |
Peter Boström | 74d9ed7 | 2015-03-26 16:28:31 +0100 | [diff] [blame] | 2279 | TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { |
| 2280 | std::vector<cricket::VideoCodec> codecs; |
| 2281 | codecs.push_back(kVp8Codec); |
| 2282 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2283 | |
| 2284 | AddSendStream(); |
| 2285 | |
| 2286 | cricket::VideoMediaInfo info; |
| 2287 | ASSERT_TRUE(channel_->GetStats(&info)); |
| 2288 | EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name); |
| 2289 | } |
| 2290 | |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 2291 | TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) { |
| 2292 | FakeVideoSendStream* stream = AddSendStream(); |
| 2293 | webrtc::VideoSendStream::Stats stats; |
| 2294 | stats.avg_encode_time_ms = 13; |
| 2295 | stats.encode_usage_percent = 42; |
| 2296 | stream->SetStats(stats); |
| 2297 | |
| 2298 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2299 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 2300 | EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms); |
| 2301 | EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent); |
| 2302 | } |
| 2303 | |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 2304 | TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) { |
| 2305 | FakeVideoSendStream* stream = AddSendStream(); |
| 2306 | webrtc::VideoSendStream::Stats stats; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2307 | stats.substreams[17].width = 123; |
| 2308 | stats.substreams[17].height = 40; |
| 2309 | stats.substreams[42].width = 80; |
| 2310 | stats.substreams[42].height = 31; |
| 2311 | stats.substreams[11].width = 20; |
| 2312 | stats.substreams[11].height = 90; |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 2313 | stream->SetStats(stats); |
| 2314 | |
| 2315 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2316 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 2317 | ASSERT_EQ(1u, info.senders.size()); |
| 2318 | EXPECT_EQ(123, info.senders[0].send_frame_width); |
| 2319 | EXPECT_EQ(90, info.senders[0].send_frame_height); |
| 2320 | } |
| 2321 | |
pbos@webrtc.org | 9a4410e | 2015-02-26 10:03:39 +0000 | [diff] [blame] | 2322 | TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) { |
| 2323 | AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); |
| 2324 | |
| 2325 | // Capture format VGA. |
| 2326 | cricket::FakeVideoCapturer video_capturer_vga; |
| 2327 | const std::vector<cricket::VideoFormat>* formats = |
| 2328 | video_capturer_vga.GetSupportedFormats(); |
| 2329 | cricket::VideoFormat capture_format_vga = (*formats)[1]; |
| 2330 | EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga)); |
| 2331 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga)); |
| 2332 | EXPECT_TRUE(video_capturer_vga.CaptureFrame()); |
| 2333 | |
| 2334 | cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0); |
| 2335 | std::vector<cricket::VideoCodec> codecs; |
| 2336 | codecs.push_back(send_codec); |
| 2337 | EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2338 | EXPECT_TRUE(channel_->SetSend(true)); |
| 2339 | |
| 2340 | // Verify that the CpuOveruseObserver is registered and trigger downgrade. |
| 2341 | cricket::VideoOptions options; |
| 2342 | options.cpu_overuse_detection.Set(true); |
| 2343 | EXPECT_TRUE(channel_->SetOptions(options)); |
| 2344 | // Trigger overuse. |
| 2345 | webrtc::LoadObserver* overuse_callback = |
| 2346 | fake_call_->GetConfig().overuse_callback; |
| 2347 | overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); |
| 2348 | |
| 2349 | // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2. |
| 2350 | EXPECT_TRUE(video_capturer_vga.CaptureFrame()); |
| 2351 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2352 | EXPECT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 9a4410e | 2015-02-26 10:03:39 +0000 | [diff] [blame] | 2353 | ASSERT_EQ(1U, info.senders.size()); |
| 2354 | EXPECT_EQ(1, info.senders[0].adapt_changes); |
| 2355 | EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU, |
| 2356 | info.senders[0].adapt_reason); |
| 2357 | |
| 2358 | // Trigger upgrade and verify that we adapt back up to VGA. |
| 2359 | overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); |
| 2360 | EXPECT_TRUE(video_capturer_vga.CaptureFrame()); |
| 2361 | info.Clear(); |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2362 | EXPECT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 9a4410e | 2015-02-26 10:03:39 +0000 | [diff] [blame] | 2363 | ASSERT_EQ(1U, info.senders.size()); |
| 2364 | EXPECT_EQ(2, info.senders[0].adapt_changes); |
| 2365 | EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE, |
| 2366 | info.senders[0].adapt_reason); |
| 2367 | |
| 2368 | // No capturer (no adapter). Adapt changes from old adapter should be kept. |
| 2369 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL)); |
| 2370 | info.Clear(); |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2371 | EXPECT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 9a4410e | 2015-02-26 10:03:39 +0000 | [diff] [blame] | 2372 | ASSERT_EQ(1U, info.senders.size()); |
| 2373 | EXPECT_EQ(2, info.senders[0].adapt_changes); |
| 2374 | EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE, |
| 2375 | info.senders[0].adapt_reason); |
| 2376 | |
| 2377 | // Set new capturer, capture format HD. |
| 2378 | cricket::FakeVideoCapturer video_capturer_hd; |
| 2379 | cricket::VideoFormat capture_format_hd = (*formats)[0]; |
| 2380 | EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd)); |
| 2381 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd)); |
| 2382 | EXPECT_TRUE(video_capturer_hd.CaptureFrame()); |
| 2383 | |
| 2384 | // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2. |
| 2385 | overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); |
| 2386 | EXPECT_TRUE(video_capturer_hd.CaptureFrame()); |
| 2387 | info.Clear(); |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2388 | EXPECT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 9a4410e | 2015-02-26 10:03:39 +0000 | [diff] [blame] | 2389 | ASSERT_EQ(1U, info.senders.size()); |
| 2390 | EXPECT_EQ(3, info.senders[0].adapt_changes); |
| 2391 | EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU, |
| 2392 | info.senders[0].adapt_reason); |
| 2393 | |
| 2394 | EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL)); |
| 2395 | } |
| 2396 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2397 | TEST_F(WebRtcVideoChannel2Test, |
| 2398 | GetStatsTranslatesSendRtcpPacketTypesCorrectly) { |
| 2399 | FakeVideoSendStream* stream = AddSendStream(); |
| 2400 | webrtc::VideoSendStream::Stats stats; |
| 2401 | stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2; |
| 2402 | stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3; |
| 2403 | stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4; |
| 2404 | |
| 2405 | stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5; |
| 2406 | stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7; |
| 2407 | stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9; |
| 2408 | |
| 2409 | stream->SetStats(stats); |
| 2410 | |
| 2411 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2412 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2413 | EXPECT_EQ(7, info.senders[0].firs_rcvd); |
| 2414 | EXPECT_EQ(10, info.senders[0].nacks_rcvd); |
| 2415 | EXPECT_EQ(13, info.senders[0].plis_rcvd); |
| 2416 | } |
| 2417 | |
| 2418 | TEST_F(WebRtcVideoChannel2Test, |
| 2419 | GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) { |
| 2420 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 2421 | webrtc::VideoReceiveStream::Stats stats; |
| 2422 | stats.rtcp_packet_type_counts.fir_packets = 2; |
| 2423 | stats.rtcp_packet_type_counts.nack_packets = 3; |
| 2424 | stats.rtcp_packet_type_counts.pli_packets = 4; |
| 2425 | stream->SetStats(stats); |
| 2426 | |
| 2427 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2428 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2429 | EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets, |
| 2430 | info.receivers[0].firs_sent); |
| 2431 | EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets, |
| 2432 | info.receivers[0].nacks_sent); |
| 2433 | EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets, |
| 2434 | info.receivers[0].plis_sent); |
| 2435 | } |
| 2436 | |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2437 | TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) { |
| 2438 | FakeVideoReceiveStream* stream = AddRecvStream(); |
| 2439 | webrtc::VideoReceiveStream::Stats stats; |
| 2440 | stats.decode_ms = 2; |
| 2441 | stats.max_decode_ms = 3; |
| 2442 | stats.current_delay_ms = 4; |
| 2443 | stats.target_delay_ms = 5; |
| 2444 | stats.jitter_buffer_ms = 6; |
| 2445 | stats.min_playout_delay_ms = 7; |
| 2446 | stats.render_delay_ms = 8; |
| 2447 | stream->SetStats(stats); |
| 2448 | |
| 2449 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2450 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2451 | EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms); |
| 2452 | EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms); |
| 2453 | EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms); |
| 2454 | EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms); |
| 2455 | EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms); |
| 2456 | EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms); |
| 2457 | EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms); |
| 2458 | } |
| 2459 | |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 2460 | TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) { |
| 2461 | AddSendStream(); |
| 2462 | AddSendStream(); |
| 2463 | webrtc::Call::Stats stats; |
| 2464 | stats.rtt_ms = 123; |
| 2465 | fake_call_->SetStats(stats); |
| 2466 | |
| 2467 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2468 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 2469 | ASSERT_EQ(2u, info.senders.size()); |
| 2470 | EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms); |
| 2471 | EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms); |
| 2472 | } |
| 2473 | |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2474 | TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) { |
| 2475 | FakeVideoSendStream* stream = AddSendStream(); |
| 2476 | webrtc::VideoSendStream::Stats stats; |
pbos@webrtc.org | 891d483 | 2015-02-26 13:15:22 +0000 | [diff] [blame] | 2477 | stats.target_media_bitrate_bps = 156; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2478 | stats.media_bitrate_bps = 123; |
| 2479 | stats.substreams[17].total_bitrate_bps = 1; |
| 2480 | stats.substreams[17].retransmit_bitrate_bps = 2; |
| 2481 | stats.substreams[42].total_bitrate_bps = 3; |
| 2482 | stats.substreams[42].retransmit_bitrate_bps = 4; |
| 2483 | stream->SetStats(stats); |
| 2484 | |
| 2485 | FakeVideoSendStream* stream2 = AddSendStream(); |
| 2486 | webrtc::VideoSendStream::Stats stats2; |
pbos@webrtc.org | 891d483 | 2015-02-26 13:15:22 +0000 | [diff] [blame] | 2487 | stats2.target_media_bitrate_bps = 200; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2488 | stats2.media_bitrate_bps = 321; |
| 2489 | stats2.substreams[13].total_bitrate_bps = 5; |
| 2490 | stats2.substreams[13].retransmit_bitrate_bps = 6; |
| 2491 | stats2.substreams[21].total_bitrate_bps = 7; |
| 2492 | stats2.substreams[21].retransmit_bitrate_bps = 8; |
| 2493 | stream2->SetStats(stats2); |
| 2494 | |
| 2495 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2496 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2497 | ASSERT_EQ(2u, info.senders.size()); |
| 2498 | // Assuming stream and stream2 corresponds to senders[0] and [1] respectively |
| 2499 | // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs. |
| 2500 | EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate); |
| 2501 | EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate); |
pbos@webrtc.org | 891d483 | 2015-02-26 13:15:22 +0000 | [diff] [blame] | 2502 | EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps, |
| 2503 | info.bw_estimations[0].target_enc_bitrate); |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2504 | EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps, |
| 2505 | info.bw_estimations[0].actual_enc_bitrate); |
| 2506 | EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate) |
| 2507 | << "Bandwidth stats should take all streams into account."; |
| 2508 | EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate) |
| 2509 | << "Bandwidth stats should take all streams into account."; |
| 2510 | } |
| 2511 | |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2512 | TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) { |
| 2513 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 2514 | |
| 2515 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); |
| 2516 | const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
| 2517 | |
| 2518 | ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); |
| 2519 | const size_t kDataLength = 12; |
| 2520 | uint8_t data[kDataLength]; |
| 2521 | memset(data, 0, sizeof(data)); |
| 2522 | rtc::SetBE32(&data[8], ssrcs[0]); |
| 2523 | rtc::Buffer packet(data, kDataLength); |
| 2524 | rtc::PacketTime packet_time; |
| 2525 | channel_->OnPacketReceived(&packet, packet_time); |
| 2526 | |
| 2527 | ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) |
| 2528 | << "No default receive stream created."; |
| 2529 | FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
| 2530 | EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size()) |
| 2531 | << "Default receive stream should not have configured RTX"; |
| 2532 | |
| 2533 | EXPECT_TRUE(channel_->AddRecvStream( |
| 2534 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs))); |
| 2535 | ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) |
| 2536 | << "AddRecvStream should've reconfigured, not added a new receiver."; |
| 2537 | recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
| 2538 | ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size()); |
| 2539 | EXPECT_EQ(rtx_ssrcs[0], |
| 2540 | recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc); |
| 2541 | } |
| 2542 | |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 2543 | TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) { |
| 2544 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 2545 | |
| 2546 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); |
| 2547 | const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
| 2548 | |
| 2549 | StreamParams sp = |
| 2550 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); |
| 2551 | sp.ssrcs = ssrcs; // Without RTXs, this is the important part. |
| 2552 | |
| 2553 | EXPECT_FALSE(channel_->AddSendStream(sp)); |
| 2554 | EXPECT_FALSE(channel_->AddRecvStream(sp)); |
| 2555 | } |
| 2556 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 2557 | TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) { |
| 2558 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 2559 | |
| 2560 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); |
| 2561 | const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
| 2562 | |
| 2563 | StreamParams sp = |
| 2564 | cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); |
| 2565 | |
| 2566 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 2567 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 2568 | |
| 2569 | // The RTX SSRC is already used in previous streams, using it should fail. |
| 2570 | sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]); |
| 2571 | EXPECT_FALSE(channel_->AddSendStream(sp)); |
| 2572 | EXPECT_FALSE(channel_->AddRecvStream(sp)); |
| 2573 | |
| 2574 | // After removing the original stream this should be fine to add (makes sure |
| 2575 | // that RTX ssrcs are not forever taken). |
| 2576 | EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0])); |
| 2577 | EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0])); |
| 2578 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 2579 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 2580 | } |
| 2581 | |
| 2582 | TEST_F(WebRtcVideoChannel2Test, |
| 2583 | RejectsAddingStreamsWithOverlappingSimulcastSsrcs) { |
| 2584 | static const uint32 kFirstStreamSsrcs[] = {1, 2, 3}; |
| 2585 | static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5}; |
| 2586 | EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
| 2587 | |
| 2588 | const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); |
| 2589 | |
| 2590 | StreamParams sp = |
| 2591 | cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs)); |
| 2592 | |
| 2593 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 2594 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 2595 | |
| 2596 | // One of the SSRCs is already used in previous streams, using it should fail. |
| 2597 | sp = cricket::CreateSimStreamParams("cname", |
| 2598 | MAKE_VECTOR(kOverlappingStreamSsrcs)); |
| 2599 | EXPECT_FALSE(channel_->AddSendStream(sp)); |
| 2600 | EXPECT_FALSE(channel_->AddRecvStream(sp)); |
| 2601 | |
| 2602 | // After removing the original stream this should be fine to add (makes sure |
| 2603 | // that RTX ssrcs are not forever taken). |
| 2604 | EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0])); |
| 2605 | EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0])); |
| 2606 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 2607 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 2608 | } |
| 2609 | |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2610 | class WebRtcVideoEngine2SimulcastTest : public testing::Test { |
| 2611 | public: |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 2612 | WebRtcVideoEngine2SimulcastTest() : engine_(nullptr) {} |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2613 | |
| 2614 | protected: |
| 2615 | WebRtcVideoEngine2 engine_; |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2616 | }; |
| 2617 | |
| 2618 | class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest, |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 2619 | public WebRtcCallFactory { |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2620 | public: |
| 2621 | WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {} |
| 2622 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 2623 | void SetUp() override { |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2624 | engine_.SetCallFactory(this); |
| 2625 | engine_.Init(rtc::Thread::Current()); |
| 2626 | channel_.reset(engine_.CreateChannel(VideoOptions(), NULL)); |
| 2627 | ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory."; |
| 2628 | last_ssrc_ = 123; |
| 2629 | } |
| 2630 | |
| 2631 | protected: |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 2632 | webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2633 | assert(fake_call_ == NULL); |
| 2634 | fake_call_ = new FakeCall(config); |
| 2635 | return fake_call_; |
| 2636 | } |
| 2637 | |
| 2638 | void VerifySimulcastSettings(const VideoCodec& codec, |
| 2639 | VideoOptions::HighestBitrate bitrate_mode, |
| 2640 | size_t num_configured_streams, |
| 2641 | size_t expected_num_streams, |
| 2642 | SimulcastBitrateMode simulcast_bitrate_mode) { |
| 2643 | cricket::VideoOptions options; |
| 2644 | options.video_highest_bitrate.Set(bitrate_mode); |
| 2645 | EXPECT_TRUE(channel_->SetOptions(options)); |
| 2646 | |
| 2647 | std::vector<VideoCodec> codecs; |
| 2648 | codecs.push_back(codec); |
| 2649 | ASSERT_TRUE(channel_->SetSendCodecs(codecs)); |
| 2650 | |
| 2651 | std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); |
| 2652 | assert(num_configured_streams <= ssrcs.size()); |
| 2653 | ssrcs.resize(num_configured_streams); |
| 2654 | |
| 2655 | FakeVideoSendStream* stream = |
| 2656 | AddSendStream(CreateSimStreamParams("cname", ssrcs)); |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 2657 | // Send a full-size frame to trigger a stream reconfiguration to use all |
| 2658 | // expected simulcast layers. |
| 2659 | cricket::FakeVideoCapturer capturer; |
| 2660 | EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer)); |
| 2661 | EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat( |
| 2662 | codec.width, codec.height, |
| 2663 | cricket::VideoFormat::FpsToInterval(30), |
| 2664 | cricket::FOURCC_I420))); |
| 2665 | channel_->SetSend(true); |
| 2666 | EXPECT_TRUE(capturer.CaptureFrame()); |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2667 | |
| 2668 | std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams(); |
| 2669 | ASSERT_EQ(expected_num_streams, video_streams.size()); |
| 2670 | |
| 2671 | std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig( |
| 2672 | num_configured_streams, |
| 2673 | simulcast_bitrate_mode, |
| 2674 | codec.width, |
| 2675 | codec.height, |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2676 | 0, |
| 2677 | kDefaultQpMax, |
| 2678 | codec.framerate != 0 ? codec.framerate : kDefaultFramerate); |
| 2679 | |
| 2680 | ASSERT_EQ(expected_streams.size(), video_streams.size()); |
| 2681 | |
| 2682 | size_t num_streams = video_streams.size(); |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2683 | int total_max_bitrate_bps = 0; |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2684 | for (size_t i = 0; i < num_streams; ++i) { |
| 2685 | EXPECT_EQ(expected_streams[i].width, video_streams[i].width); |
| 2686 | EXPECT_EQ(expected_streams[i].height, video_streams[i].height); |
| 2687 | |
| 2688 | EXPECT_GT(video_streams[i].max_framerate, 0); |
| 2689 | EXPECT_EQ(expected_streams[i].max_framerate, |
| 2690 | video_streams[i].max_framerate); |
| 2691 | |
| 2692 | EXPECT_GT(video_streams[i].min_bitrate_bps, 0); |
| 2693 | EXPECT_EQ(expected_streams[i].min_bitrate_bps, |
| 2694 | video_streams[i].min_bitrate_bps); |
| 2695 | |
| 2696 | EXPECT_GT(video_streams[i].target_bitrate_bps, 0); |
| 2697 | EXPECT_EQ(expected_streams[i].target_bitrate_bps, |
| 2698 | video_streams[i].target_bitrate_bps); |
| 2699 | |
| 2700 | EXPECT_GT(video_streams[i].max_bitrate_bps, 0); |
| 2701 | EXPECT_EQ(expected_streams[i].max_bitrate_bps, |
| 2702 | video_streams[i].max_bitrate_bps); |
| 2703 | |
| 2704 | EXPECT_GT(video_streams[i].max_qp, 0); |
| 2705 | EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp); |
| 2706 | |
| 2707 | EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty()); |
| 2708 | EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps, |
| 2709 | video_streams[i].temporal_layer_thresholds_bps); |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2710 | |
| 2711 | if (i == num_streams - 1) { |
| 2712 | total_max_bitrate_bps += video_streams[i].max_bitrate_bps; |
| 2713 | } else { |
| 2714 | total_max_bitrate_bps += video_streams[i].target_bitrate_bps; |
| 2715 | } |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2716 | } |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2717 | cricket::VideoMediaInfo info; |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 2718 | ASSERT_TRUE(channel_->GetStats(&info)); |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2719 | ASSERT_EQ(1u, info.senders.size()); |
| 2720 | EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate); |
| 2721 | |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 2722 | EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL)); |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2723 | } |
| 2724 | |
| 2725 | FakeVideoSendStream* AddSendStream() { |
| 2726 | return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++)); |
| 2727 | } |
| 2728 | |
| 2729 | FakeVideoSendStream* AddSendStream(const StreamParams& sp) { |
| 2730 | size_t num_streams = |
| 2731 | fake_call_->GetVideoSendStreams().size(); |
| 2732 | EXPECT_TRUE(channel_->AddSendStream(sp)); |
| 2733 | std::vector<FakeVideoSendStream*> streams = |
| 2734 | fake_call_->GetVideoSendStreams(); |
| 2735 | EXPECT_EQ(num_streams + 1, streams.size()); |
| 2736 | return streams[streams.size() - 1]; |
| 2737 | } |
| 2738 | |
| 2739 | std::vector<FakeVideoSendStream*> GetFakeSendStreams() { |
| 2740 | return fake_call_->GetVideoSendStreams(); |
| 2741 | } |
| 2742 | |
| 2743 | FakeVideoReceiveStream* AddRecvStream() { |
| 2744 | return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++)); |
| 2745 | } |
| 2746 | |
| 2747 | FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) { |
| 2748 | size_t num_streams = |
| 2749 | fake_call_->GetVideoReceiveStreams().size(); |
| 2750 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 2751 | std::vector<FakeVideoReceiveStream*> streams = |
| 2752 | fake_call_->GetVideoReceiveStreams(); |
| 2753 | EXPECT_EQ(num_streams + 1, streams.size()); |
| 2754 | return streams[streams.size() - 1]; |
| 2755 | } |
| 2756 | |
| 2757 | FakeCall* fake_call_; |
| 2758 | rtc::scoped_ptr<VideoMediaChannel> channel_; |
| 2759 | uint32 last_ssrc_; |
| 2760 | }; |
| 2761 | |
| 2762 | TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { |
| 2763 | VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); |
| 2764 | } |
| 2765 | |
| 2766 | TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { |
| 2767 | VerifySimulcastSettings( |
| 2768 | kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL); |
| 2769 | } |
| 2770 | |
| 2771 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 2772 | SetSendCodecsWith2SimulcastStreamsHighBitrateMode) { |
| 2773 | VerifySimulcastSettings(kVp8Codec, VideoOptions::HIGH, 2, 2, SBM_HIGH); |
| 2774 | } |
| 2775 | |
| 2776 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 2777 | SetSendCodecsWith3SimulcastStreamsHighBitrateMode) { |
| 2778 | VerifySimulcastSettings(kVp8Codec720p, VideoOptions::HIGH, 3, 3, SBM_HIGH); |
| 2779 | } |
| 2780 | |
| 2781 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 2782 | SetSendCodecsWith2SimulcastStreamsVeryHighBitrateMode) { |
| 2783 | VerifySimulcastSettings( |
| 2784 | kVp8Codec, VideoOptions::VERY_HIGH, 2, 2, SBM_VERY_HIGH); |
| 2785 | } |
| 2786 | |
| 2787 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 2788 | SetSendCodecsWith3SimulcastStreamsVeryHighBitrateMode) { |
| 2789 | VerifySimulcastSettings( |
| 2790 | kVp8Codec720p, VideoOptions::VERY_HIGH, 3, 3, SBM_VERY_HIGH); |
| 2791 | } |
| 2792 | |
| 2793 | // Test that we normalize send codec format size in simulcast. |
| 2794 | TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { |
| 2795 | cricket::VideoCodec codec(kVp8Codec270p); |
| 2796 | codec.width += 1; |
| 2797 | codec.height += 1; |
| 2798 | VerifySimulcastSettings(codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); |
| 2799 | } |
| 2800 | |
| 2801 | // Test that if we add a stream with RTX SSRC's, SSRC's get set correctly. |
| 2802 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) { |
| 2803 | // TODO(pbos): Implement. |
| 2804 | FAIL() << "Not implemented."; |
| 2805 | } |
| 2806 | |
| 2807 | // Test that if we get too few ssrcs are given in AddSendStream(), |
| 2808 | // only supported sub-streams will be added. |
| 2809 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TooFewSimulcastSsrcs) { |
| 2810 | // TODO(pbos): Implement. |
| 2811 | FAIL() << "Not implemented."; |
| 2812 | } |
| 2813 | |
| 2814 | // Test that even more than enough ssrcs are given in AddSendStream(), |
| 2815 | // only supported sub-streams will be added. |
| 2816 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_MoreThanEnoughSimulcastSscrs) { |
| 2817 | // TODO(pbos): Implement. |
| 2818 | FAIL() << "Not implemented."; |
| 2819 | } |
| 2820 | |
| 2821 | // Test that SetSendStreamFormat works well with simulcast. |
| 2822 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2823 | DISABLED_SetSendStreamFormatWithSimulcast) { |
| 2824 | // TODO(pbos): Implement. |
| 2825 | FAIL() << "Not implemented."; |
| 2826 | } |
| 2827 | |
| 2828 | // Test that simulcast send codec is reset on new video frame size. |
| 2829 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2830 | DISABLED_ResetSimulcastSendCodecOnNewFrameSize) { |
| 2831 | // TODO(pbos): Implement. |
| 2832 | FAIL() << "Not implemented."; |
| 2833 | } |
| 2834 | |
| 2835 | // Test that simulcast send codec is reset on new portait mode video frame. |
| 2836 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2837 | DISABLED_ResetSimulcastSendCodecOnNewPortaitFrame) { |
| 2838 | // TODO(pbos): Implement. |
| 2839 | FAIL() << "Not implemented."; |
| 2840 | } |
| 2841 | |
| 2842 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2843 | DISABLED_SetBandwidthInConferenceWithSimulcast) { |
| 2844 | // TODO(pbos): Implement. |
| 2845 | FAIL() << "Not implemented."; |
| 2846 | } |
| 2847 | |
| 2848 | // Test that sending screencast frames in conference mode changes |
| 2849 | // bitrate. |
| 2850 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2851 | DISABLED_SetBandwidthScreencastInConference) { |
| 2852 | // TODO(pbos): Implement. |
| 2853 | FAIL() << "Not implemented."; |
| 2854 | } |
| 2855 | |
| 2856 | // Test AddSendStream with simulcast rejects bad StreamParams. |
| 2857 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2858 | DISABLED_AddSendStreamWithBadStreamParams) { |
| 2859 | // TODO(pbos): Implement. |
| 2860 | FAIL() << "Not implemented."; |
| 2861 | } |
| 2862 | |
| 2863 | // Test AddSendStream with simulcast sets ssrc and cname correctly. |
| 2864 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_AddSendStreamWithSimulcast) { |
| 2865 | // TODO(pbos): Implement. |
| 2866 | FAIL() << "Not implemented."; |
| 2867 | } |
| 2868 | |
| 2869 | // Test RemoveSendStream with simulcast. |
| 2870 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2871 | DISABLED_RemoveSendStreamWithSimulcast) { |
| 2872 | // TODO(pbos): Implement. |
| 2873 | FAIL() << "Not implemented."; |
| 2874 | } |
| 2875 | |
| 2876 | // Test AddSendStream after send codec has already been set will reset |
| 2877 | // send codec with simulcast settings. |
| 2878 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2879 | DISABLED_AddSimulcastStreamAfterSetSendCodec) { |
| 2880 | // TODO(pbos): Implement. |
| 2881 | FAIL() << "Not implemented."; |
| 2882 | } |
| 2883 | |
| 2884 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_GetStatsWithMultipleSsrcs) { |
| 2885 | // TODO(pbos): Implement. |
| 2886 | FAIL() << "Not implemented."; |
| 2887 | } |
| 2888 | |
| 2889 | // Test receiving channel(s) local ssrc is set to the same as the first |
| 2890 | // simulcast sending ssrc. |
| 2891 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2892 | DISABLED_AddSimulcastStreamAfterCreatingRecvChannels) { |
| 2893 | // TODO(pbos): Implement. |
| 2894 | FAIL() << "Not implemented."; |
| 2895 | } |
| 2896 | |
| 2897 | // Test 1:1 call never turn on simulcast. |
| 2898 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_NoSimulcastWith1on1) { |
| 2899 | // TODO(pbos): Implement. |
| 2900 | FAIL() << "Not implemented."; |
| 2901 | } |
| 2902 | |
| 2903 | // Test SetOptions with OPT_CONFERENCE flag. |
| 2904 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_SetOptionsWithConferenceMode) { |
| 2905 | // TODO(pbos): Implement. |
| 2906 | FAIL() << "Not implemented."; |
| 2907 | } |
| 2908 | |
| 2909 | // Test that two different streams can have different formats. |
| 2910 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2911 | DISABLED_MultipleSendStreamsDifferentFormats) { |
| 2912 | // TODO(pbos): Implement. |
| 2913 | FAIL() << "Not implemented."; |
| 2914 | } |
| 2915 | |
| 2916 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToOutputFormat) { |
| 2917 | // TODO(pbos): Implement. |
| 2918 | FAIL() << "Not implemented."; |
| 2919 | } |
| 2920 | |
| 2921 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoad) { |
| 2922 | // TODO(pbos): Implement. |
| 2923 | FAIL() << "Not implemented."; |
| 2924 | } |
| 2925 | |
| 2926 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoadDisabled) { |
| 2927 | // TODO(pbos): Implement. |
| 2928 | FAIL() << "Not implemented."; |
| 2929 | } |
| 2930 | |
| 2931 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2932 | DISABLED_TestAdaptWithCpuOveruseObserver) { |
| 2933 | // TODO(pbos): Implement. |
| 2934 | FAIL() << "Not implemented."; |
| 2935 | } |
| 2936 | |
| 2937 | // Test that codec is not reset for every frame sent in non-conference and |
| 2938 | // non-screencast mode. |
| 2939 | TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_DontResetCodecOnSendFrame) { |
| 2940 | // TODO(pbos): Implement. |
| 2941 | FAIL() << "Not implemented."; |
| 2942 | } |
| 2943 | |
| 2944 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2945 | DISABLED_UseSimulcastAdapterOnVp8OnlyFactory) { |
| 2946 | // TODO(pbos): Implement. |
| 2947 | FAIL() << "Not implemented."; |
| 2948 | } |
| 2949 | |
| 2950 | TEST_F(WebRtcVideoEngine2SimulcastTest, |
| 2951 | DISABLED_DontUseSimulcastAdapterOnNoneVp8Factory) { |
| 2952 | // TODO(pbos): Implement. |
| 2953 | FAIL() << "Not implemented."; |
| 2954 | } |
| 2955 | |
buildbot@webrtc.org | a853077 | 2014-12-10 09:01:18 +0000 | [diff] [blame] | 2956 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x800) { |
| 2957 | // TODO(pbos): Implement. |
| 2958 | FAIL() << "Not implemented."; |
| 2959 | } |
| 2960 | |
| 2961 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x720) { |
| 2962 | // TODO(pbos): Implement. |
| 2963 | FAIL() << "Not implemented."; |
| 2964 | } |
| 2965 | |
| 2966 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x540) { |
| 2967 | // TODO(pbos): Implement. |
| 2968 | FAIL() << "Not implemented."; |
| 2969 | } |
| 2970 | |
| 2971 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x600) { |
| 2972 | // TODO(pbos): Implement. |
| 2973 | FAIL() << "Not implemented."; |
| 2974 | } |
| 2975 | |
| 2976 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x400) { |
| 2977 | // TODO(pbos): Implement. |
| 2978 | FAIL() << "Not implemented."; |
| 2979 | } |
| 2980 | |
| 2981 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x360) { |
| 2982 | // TODO(pbos): Implement. |
| 2983 | FAIL() << "Not implemented."; |
| 2984 | } |
| 2985 | |
| 2986 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_480x300) { |
| 2987 | // TODO(pbos): Implement. |
| 2988 | FAIL() << "Not implemented."; |
| 2989 | } |
| 2990 | |
| 2991 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 2992 | DISABLED_DISABLED_SimulcastSend_480x270) { |
| 2993 | // TODO(pbos): Implement. |
| 2994 | FAIL() << "Not implemented."; |
| 2995 | } |
| 2996 | |
| 2997 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x200) { |
| 2998 | // TODO(pbos): Implement. |
| 2999 | FAIL() << "Not implemented."; |
| 3000 | } |
| 3001 | |
| 3002 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x180) { |
| 3003 | // TODO(pbos): Implement. |
| 3004 | FAIL() << "Not implemented."; |
| 3005 | } |
| 3006 | |
| 3007 | // Test reset send codec with simulcast. |
| 3008 | // Disabled per b/6773425 |
| 3009 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 3010 | DISABLED_DISABLED_SimulcastResetSendCodec) { |
| 3011 | // TODO(pbos): Implement. |
| 3012 | FAIL() << "Not implemented."; |
| 3013 | } |
| 3014 | |
| 3015 | // Test simulcast streams are decodeable with expected sizes. |
| 3016 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastStreams) { |
| 3017 | // TODO(pbos): Implement. |
| 3018 | FAIL() << "Not implemented."; |
| 3019 | } |
| 3020 | |
| 3021 | // Simulcast and resolution resizing should be turned off when screencasting |
| 3022 | // but not otherwise. |
| 3023 | TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_ScreencastRendering) { |
| 3024 | // TODO(pbos): Implement. |
| 3025 | FAIL() << "Not implemented."; |
| 3026 | } |
| 3027 | |
| 3028 | // Ensures that the correct settings are applied to the codec when single |
| 3029 | // temporal layer screencasting is enabled, and that the correct simulcast |
| 3030 | // settings are reapplied when disabling screencasting. |
| 3031 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 3032 | DISABLED_OneTemporalLayerScreencastSettings) { |
| 3033 | // TODO(pbos): Implement. |
| 3034 | FAIL() << "Not implemented."; |
| 3035 | } |
| 3036 | |
| 3037 | // Ensures that the correct settings are applied to the codec when two temporal |
| 3038 | // layer screencasting is enabled, and that the correct simulcast settings are |
| 3039 | // reapplied when disabling screencasting. |
| 3040 | TEST_F(WebRtcVideoChannel2SimulcastTest, |
| 3041 | DISABLED_TwoTemporalLayerScreencastSettings) { |
| 3042 | // TODO(pbos): Implement. |
| 3043 | FAIL() << "Not implemented."; |
| 3044 | } |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 3045 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3046 | } // namespace cricket |