OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 223 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
234 // |expected_result| is the expected result from SetMaxSendBandwidth(). | 234 // |expected_result| is the expected result from SetMaxSendBandwidth(). |
235 // |expected_bitrate| is the expected audio bitrate afterward. | 235 // |expected_bitrate| is the expected audio bitrate afterward. |
236 void TestMaxSendBandwidth(const cricket::AudioCodec& codec, | 236 void TestMaxSendBandwidth(const cricket::AudioCodec& codec, |
237 int max_bitrate, | 237 int max_bitrate, |
238 bool expected_result, | 238 bool expected_result, |
239 int expected_bitrate) { | 239 int expected_bitrate) { |
240 cricket::AudioSendParameters parameters; | 240 cricket::AudioSendParameters parameters; |
241 parameters.codecs.push_back(codec); | 241 parameters.codecs.push_back(codec); |
242 parameters.max_bandwidth_bps = max_bitrate; | 242 parameters.max_bandwidth_bps = max_bitrate; |
243 EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters)); | 243 EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters)); |
244 | 244 EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrc1)); |
245 int channel_num = voe_.GetLastChannel(); | |
246 webrtc::CodecInst temp_codec; | |
247 EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec)); | |
248 EXPECT_EQ(expected_bitrate, temp_codec.rate); | |
249 } | 245 } |
250 | 246 |
251 // Sets the per-stream maximum bitrate limit for the specified SSRC. | 247 // Sets the per-stream maximum bitrate limit for the specified SSRC. |
252 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { | 248 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { |
253 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc); | 249 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc); |
254 EXPECT_EQ(1UL, parameters.encodings.size()); | 250 EXPECT_EQ(1UL, parameters.encodings.size()); |
255 | 251 |
256 parameters.encodings[0].max_bitrate_bps = bitrate; | 252 parameters.encodings[0].max_bitrate_bps = bitrate; |
257 return channel_->SetRtpSendParameters(ssrc, parameters); | 253 return channel_->SetRtpSendParameters(ssrc, parameters); |
258 } | 254 } |
259 | 255 |
260 bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { | 256 bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { |
261 cricket::AudioSendParameters send_parameters; | 257 cricket::AudioSendParameters send_parameters; |
262 send_parameters.codecs.push_back(codec); | 258 send_parameters.codecs.push_back(codec); |
263 send_parameters.max_bandwidth_bps = bitrate; | 259 send_parameters.max_bandwidth_bps = bitrate; |
264 return channel_->SetSendParameters(send_parameters); | 260 return channel_->SetSendParameters(send_parameters); |
265 } | 261 } |
266 | 262 |
| 263 void CheckSendCodec(int32_t ssrc, |
| 264 const char expected_name[], |
| 265 int expected_channels, |
| 266 int expected_bitrate) { |
| 267 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; |
| 268 EXPECT_STREQ(expected_name, codec.plname); |
| 269 EXPECT_EQ(expected_channels, codec.channels); |
| 270 EXPECT_EQ(expected_bitrate, codec.rate); |
| 271 } |
| 272 |
| 273 int GetOpusMaxPlaybackRate(int32_t ssrc) { |
| 274 return GetSendStreamConfig(ssrc).send_codec_spec.opus_max_playback_rate; |
| 275 } |
| 276 |
| 277 bool GetOpusDtx(int32_t ssrc) { |
| 278 return GetSendStreamConfig(ssrc).send_codec_spec.enable_opus_dtx; |
| 279 } |
| 280 |
| 281 bool GetCodecFec(int32_t ssrc) { |
| 282 return GetSendStreamConfig(ssrc).send_codec_spec.enable_codec_fec; |
| 283 } |
| 284 |
267 int GetCodecBitrate(int32_t ssrc) { | 285 int GetCodecBitrate(int32_t ssrc) { |
268 cricket::WebRtcVoiceMediaChannel* media_channel = | 286 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.rate; |
269 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 287 } |
270 int channel = media_channel->GetSendChannelId(ssrc); | 288 |
271 EXPECT_NE(-1, channel); | 289 int GetCodecPacSize(int32_t ssrc) { |
272 webrtc::CodecInst codec; | 290 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.pacsize; |
273 EXPECT_FALSE(voe_.GetSendCodec(channel, codec)); | |
274 return codec.rate; | |
275 } | 291 } |
276 | 292 |
277 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, | 293 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
278 int global_max, | 294 int global_max, |
279 int stream_max, | 295 int stream_max, |
280 bool expected_result, | 296 bool expected_result, |
281 int expected_codec_bitrate) { | 297 int expected_codec_bitrate) { |
282 // Clear the bitrate limit from the previous test case. | 298 // Clear the bitrate limit from the previous test case. |
283 EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1)); | 299 EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1)); |
284 | 300 |
(...skipping 558 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
843 EXPECT_TRUE(SetupChannel()); | 859 EXPECT_TRUE(SetupChannel()); |
844 const int kDesiredBitrate = 128000; | 860 const int kDesiredBitrate = 128000; |
845 cricket::AudioSendParameters parameters; | 861 cricket::AudioSendParameters parameters; |
846 parameters.codecs = engine_->send_codecs(); | 862 parameters.codecs = engine_->send_codecs(); |
847 parameters.max_bandwidth_bps = kDesiredBitrate; | 863 parameters.max_bandwidth_bps = kDesiredBitrate; |
848 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 864 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
849 | 865 |
850 EXPECT_TRUE(channel_->AddSendStream( | 866 EXPECT_TRUE(channel_->AddSendStream( |
851 cricket::StreamParams::CreateLegacy(kSsrc1))); | 867 cricket::StreamParams::CreateLegacy(kSsrc1))); |
852 | 868 |
853 int channel_num = voe_.GetLastChannel(); | 869 EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrc1)); |
854 webrtc::CodecInst codec; | |
855 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); | |
856 EXPECT_EQ(kDesiredBitrate, codec.rate); | |
857 } | 870 } |
858 | 871 |
859 // Test that bitrate cannot be set for CBR codecs. | 872 // Test that bitrate cannot be set for CBR codecs. |
860 // Bitrate is ignored if it is higher than the fixed bitrate. | 873 // Bitrate is ignored if it is higher than the fixed bitrate. |
861 // Bitrate less then the fixed bitrate is an error. | 874 // Bitrate less then the fixed bitrate is an error. |
862 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { | 875 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { |
863 EXPECT_TRUE(SetupSendStream()); | 876 EXPECT_TRUE(SetupSendStream()); |
864 | 877 |
865 // PCMU, default bitrate == 64000. | 878 // PCMU, default bitrate == 64000. |
866 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 879 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
867 int channel_num = voe_.GetLastChannel(); | 880 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
868 webrtc::CodecInst codec; | |
869 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); | |
870 EXPECT_EQ(64000, codec.rate); | |
871 | 881 |
872 send_parameters_.max_bandwidth_bps = 128000; | 882 send_parameters_.max_bandwidth_bps = 128000; |
873 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 883 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
874 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); | 884 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
875 EXPECT_EQ(64000, codec.rate); | |
876 | 885 |
877 send_parameters_.max_bandwidth_bps = 128; | 886 send_parameters_.max_bandwidth_bps = 128; |
878 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); | 887 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
879 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); | 888 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
880 EXPECT_EQ(64000, codec.rate); | |
881 } | 889 } |
882 | 890 |
883 // Test that the per-stream bitrate limit and the global | 891 // Test that the per-stream bitrate limit and the global |
884 // bitrate limit both apply. | 892 // bitrate limit both apply. |
885 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { | 893 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
886 EXPECT_TRUE(SetupSendStream()); | 894 EXPECT_TRUE(SetupSendStream()); |
887 | 895 |
888 // opus, default bitrate == 64000. | 896 // opus, default bitrate == 64000. |
889 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); | 897 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); |
890 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); | 898 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1051 | 1059 |
1052 // Test that we apply codecs properly. | 1060 // Test that we apply codecs properly. |
1053 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { | 1061 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
1054 EXPECT_TRUE(SetupSendStream()); | 1062 EXPECT_TRUE(SetupSendStream()); |
1055 cricket::AudioSendParameters parameters; | 1063 cricket::AudioSendParameters parameters; |
1056 parameters.codecs.push_back(kIsacCodec); | 1064 parameters.codecs.push_back(kIsacCodec); |
1057 parameters.codecs.push_back(kPcmuCodec); | 1065 parameters.codecs.push_back(kPcmuCodec); |
1058 parameters.codecs.push_back(kCn8000Codec); | 1066 parameters.codecs.push_back(kCn8000Codec); |
1059 parameters.codecs[0].id = 96; | 1067 parameters.codecs[0].id = 96; |
1060 parameters.codecs[0].bitrate = 48000; | 1068 parameters.codecs[0].bitrate = 48000; |
| 1069 const int initial_num = call_.GetNumCreatedSendStreams(); |
1061 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1070 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1062 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); | 1071 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1063 int channel_num = voe_.GetLastChannel(); | 1072 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1064 webrtc::CodecInst gcodec; | 1073 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1065 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1074 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); |
1066 EXPECT_EQ(96, gcodec.pltype); | 1075 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1067 EXPECT_EQ(48000, gcodec.rate); | 1076 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1068 EXPECT_STREQ("ISAC", gcodec.plname); | 1077 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
1069 EXPECT_FALSE(voe_.GetVAD(channel_num)); | 1078 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1070 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | |
1071 EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true)); | |
1072 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1079 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1073 } | 1080 } |
1074 | 1081 |
1075 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1082 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried |
1076 // to apply. | 1083 // to apply. |
1077 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1084 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { |
1078 EXPECT_TRUE(SetupSendStream()); | 1085 EXPECT_TRUE(SetupSendStream()); |
1079 cricket::AudioSendParameters parameters; | 1086 cricket::AudioSendParameters parameters; |
1080 parameters.codecs.push_back(kIsacCodec); | 1087 parameters.codecs.push_back(kIsacCodec); |
1081 parameters.codecs.push_back(kPcmuCodec); | 1088 parameters.codecs.push_back(kPcmuCodec); |
1082 parameters.codecs.push_back(kCn8000Codec); | 1089 parameters.codecs.push_back(kCn8000Codec); |
1083 parameters.codecs[0].id = 96; | 1090 parameters.codecs[0].id = 96; |
1084 parameters.codecs[0].bitrate = 48000; | 1091 parameters.codecs[0].bitrate = 48000; |
| 1092 const int initial_num = call_.GetNumCreatedSendStreams(); |
1085 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1093 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1086 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); | 1094 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1087 // Calling SetSendCodec again with same codec which is already set. | 1095 // Calling SetSendCodec again with same codec which is already set. |
1088 // In this case media channel shouldn't send codec to VoE. | 1096 // In this case media channel shouldn't send codec to VoE. |
1089 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1097 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1090 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); | 1098 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1091 } | 1099 } |
1092 | 1100 |
1093 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1101 // Verify that G722 is set with 16000 samples per second to WebRTC. |
1094 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1102 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { |
1095 EXPECT_TRUE(SetupSendStream()); | 1103 EXPECT_TRUE(SetupSendStream()); |
1096 int channel_num = voe_.GetLastChannel(); | |
1097 cricket::AudioSendParameters parameters; | 1104 cricket::AudioSendParameters parameters; |
1098 parameters.codecs.push_back(kG722CodecSdp); | 1105 parameters.codecs.push_back(kG722CodecSdp); |
1099 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1106 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1100 webrtc::CodecInst gcodec; | 1107 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1101 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1102 EXPECT_STREQ("G722", gcodec.plname); | 1108 EXPECT_STREQ("G722", gcodec.plname); |
1103 EXPECT_EQ(1, gcodec.channels); | 1109 EXPECT_EQ(1, gcodec.channels); |
1104 EXPECT_EQ(16000, gcodec.plfreq); | 1110 EXPECT_EQ(16000, gcodec.plfreq); |
1105 } | 1111 } |
1106 | 1112 |
1107 // Test that if clockrate is not 48000 for opus, we fail. | 1113 // Test that if clockrate is not 48000 for opus, we fail. |
1108 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1114 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1109 EXPECT_TRUE(SetupSendStream()); | 1115 EXPECT_TRUE(SetupSendStream()); |
1110 cricket::AudioSendParameters parameters; | 1116 cricket::AudioSendParameters parameters; |
1111 parameters.codecs.push_back(kOpusCodec); | 1117 parameters.codecs.push_back(kOpusCodec); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1164 parameters.codecs[0].bitrate = 0; | 1170 parameters.codecs[0].bitrate = 0; |
1165 parameters.codecs[0].channels = 1; | 1171 parameters.codecs[0].channels = 1; |
1166 parameters.codecs[0].params["stereo"] = "1"; | 1172 parameters.codecs[0].params["stereo"] = "1"; |
1167 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1173 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1168 } | 1174 } |
1169 | 1175 |
1170 // Test that with bitrate=0 and no stereo, | 1176 // Test that with bitrate=0 and no stereo, |
1171 // channels and bitrate are 1 and 32000. | 1177 // channels and bitrate are 1 and 32000. |
1172 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { | 1178 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
1173 EXPECT_TRUE(SetupSendStream()); | 1179 EXPECT_TRUE(SetupSendStream()); |
1174 int channel_num = voe_.GetLastChannel(); | |
1175 cricket::AudioSendParameters parameters; | 1180 cricket::AudioSendParameters parameters; |
1176 parameters.codecs.push_back(kOpusCodec); | 1181 parameters.codecs.push_back(kOpusCodec); |
1177 parameters.codecs[0].bitrate = 0; | 1182 parameters.codecs[0].bitrate = 0; |
1178 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1183 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1179 webrtc::CodecInst gcodec; | 1184 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1180 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1181 EXPECT_STREQ("opus", gcodec.plname); | |
1182 EXPECT_EQ(1, gcodec.channels); | |
1183 EXPECT_EQ(32000, gcodec.rate); | |
1184 } | 1185 } |
1185 | 1186 |
1186 // Test that with bitrate=0 and stereo=0, | 1187 // Test that with bitrate=0 and stereo=0, |
1187 // channels and bitrate are 1 and 32000. | 1188 // channels and bitrate are 1 and 32000. |
1188 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { | 1189 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
1189 EXPECT_TRUE(SetupSendStream()); | 1190 EXPECT_TRUE(SetupSendStream()); |
1190 int channel_num = voe_.GetLastChannel(); | |
1191 cricket::AudioSendParameters parameters; | 1191 cricket::AudioSendParameters parameters; |
1192 parameters.codecs.push_back(kOpusCodec); | 1192 parameters.codecs.push_back(kOpusCodec); |
1193 parameters.codecs[0].bitrate = 0; | 1193 parameters.codecs[0].bitrate = 0; |
1194 parameters.codecs[0].params["stereo"] = "0"; | 1194 parameters.codecs[0].params["stereo"] = "0"; |
1195 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1195 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1196 webrtc::CodecInst gcodec; | 1196 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1197 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1198 EXPECT_STREQ("opus", gcodec.plname); | |
1199 EXPECT_EQ(1, gcodec.channels); | |
1200 EXPECT_EQ(32000, gcodec.rate); | |
1201 } | 1197 } |
1202 | 1198 |
1203 // Test that with bitrate=invalid and stereo=0, | 1199 // Test that with bitrate=invalid and stereo=0, |
1204 // channels and bitrate are 1 and 32000. | 1200 // channels and bitrate are 1 and 32000. |
1205 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { | 1201 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
1206 EXPECT_TRUE(SetupSendStream()); | 1202 EXPECT_TRUE(SetupSendStream()); |
1207 int channel_num = voe_.GetLastChannel(); | |
1208 cricket::AudioSendParameters parameters; | 1203 cricket::AudioSendParameters parameters; |
1209 parameters.codecs.push_back(kOpusCodec); | 1204 parameters.codecs.push_back(kOpusCodec); |
1210 parameters.codecs[0].params["stereo"] = "0"; | 1205 parameters.codecs[0].params["stereo"] = "0"; |
1211 webrtc::CodecInst gcodec; | |
1212 | |
1213 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1206 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1214 parameters.codecs[0].bitrate = 5999; | 1207 parameters.codecs[0].bitrate = 5999; |
1215 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1208 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1216 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1209 CheckSendCodec(kSsrc1, "opus", 1, 6000); |
1217 EXPECT_STREQ("opus", gcodec.plname); | |
1218 EXPECT_EQ(1, gcodec.channels); | |
1219 EXPECT_EQ(6000, gcodec.rate); | |
1220 | 1210 |
1221 parameters.codecs[0].bitrate = 510001; | 1211 parameters.codecs[0].bitrate = 510001; |
1222 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1212 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1223 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1213 CheckSendCodec(kSsrc1, "opus", 1, 510000); |
1224 EXPECT_STREQ("opus", gcodec.plname); | |
1225 EXPECT_EQ(1, gcodec.channels); | |
1226 EXPECT_EQ(510000, gcodec.rate); | |
1227 } | 1214 } |
1228 | 1215 |
1229 // Test that with bitrate=0 and stereo=1, | 1216 // Test that with bitrate=0 and stereo=1, |
1230 // channels and bitrate are 2 and 64000. | 1217 // channels and bitrate are 2 and 64000. |
1231 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { | 1218 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
1232 EXPECT_TRUE(SetupSendStream()); | 1219 EXPECT_TRUE(SetupSendStream()); |
1233 int channel_num = voe_.GetLastChannel(); | |
1234 cricket::AudioSendParameters parameters; | 1220 cricket::AudioSendParameters parameters; |
1235 parameters.codecs.push_back(kOpusCodec); | 1221 parameters.codecs.push_back(kOpusCodec); |
1236 parameters.codecs[0].bitrate = 0; | 1222 parameters.codecs[0].bitrate = 0; |
1237 parameters.codecs[0].params["stereo"] = "1"; | 1223 parameters.codecs[0].params["stereo"] = "1"; |
1238 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1224 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1239 webrtc::CodecInst gcodec; | 1225 CheckSendCodec(kSsrc1, "opus", 2, 64000); |
1240 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1241 EXPECT_STREQ("opus", gcodec.plname); | |
1242 EXPECT_EQ(2, gcodec.channels); | |
1243 EXPECT_EQ(64000, gcodec.rate); | |
1244 } | 1226 } |
1245 | 1227 |
1246 // Test that with bitrate=invalid and stereo=1, | 1228 // Test that with bitrate=invalid and stereo=1, |
1247 // channels and bitrate are 2 and 64000. | 1229 // channels and bitrate are 2 and 64000. |
1248 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { | 1230 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
1249 EXPECT_TRUE(SetupSendStream()); | 1231 EXPECT_TRUE(SetupSendStream()); |
1250 int channel_num = voe_.GetLastChannel(); | |
1251 cricket::AudioSendParameters parameters; | 1232 cricket::AudioSendParameters parameters; |
1252 parameters.codecs.push_back(kOpusCodec); | 1233 parameters.codecs.push_back(kOpusCodec); |
1253 parameters.codecs[0].params["stereo"] = "1"; | 1234 parameters.codecs[0].params["stereo"] = "1"; |
1254 webrtc::CodecInst gcodec; | |
1255 | |
1256 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1235 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1257 parameters.codecs[0].bitrate = 5999; | 1236 parameters.codecs[0].bitrate = 5999; |
1258 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1237 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1259 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1238 CheckSendCodec(kSsrc1, "opus", 2, 6000); |
1260 EXPECT_STREQ("opus", gcodec.plname); | |
1261 EXPECT_EQ(2, gcodec.channels); | |
1262 EXPECT_EQ(6000, gcodec.rate); | |
1263 | 1239 |
1264 parameters.codecs[0].bitrate = 510001; | 1240 parameters.codecs[0].bitrate = 510001; |
1265 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1241 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1266 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1242 CheckSendCodec(kSsrc1, "opus", 2, 510000); |
1267 EXPECT_STREQ("opus", gcodec.plname); | |
1268 EXPECT_EQ(2, gcodec.channels); | |
1269 EXPECT_EQ(510000, gcodec.rate); | |
1270 } | 1243 } |
1271 | 1244 |
1272 // Test that with bitrate=N and stereo unset, | 1245 // Test that with bitrate=N and stereo unset, |
1273 // channels and bitrate are 1 and N. | 1246 // channels and bitrate are 1 and N. |
1274 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1247 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1275 EXPECT_TRUE(SetupSendStream()); | 1248 EXPECT_TRUE(SetupSendStream()); |
1276 int channel_num = voe_.GetLastChannel(); | |
1277 cricket::AudioSendParameters parameters; | 1249 cricket::AudioSendParameters parameters; |
1278 parameters.codecs.push_back(kOpusCodec); | 1250 parameters.codecs.push_back(kOpusCodec); |
1279 parameters.codecs[0].bitrate = 96000; | 1251 parameters.codecs[0].bitrate = 96000; |
1280 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1252 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1281 webrtc::CodecInst gcodec; | 1253 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1282 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1283 EXPECT_EQ(111, gcodec.pltype); | 1254 EXPECT_EQ(111, gcodec.pltype); |
1284 EXPECT_EQ(96000, gcodec.rate); | 1255 EXPECT_EQ(96000, gcodec.rate); |
1285 EXPECT_STREQ("opus", gcodec.plname); | 1256 EXPECT_STREQ("opus", gcodec.plname); |
1286 EXPECT_EQ(1, gcodec.channels); | 1257 EXPECT_EQ(1, gcodec.channels); |
1287 EXPECT_EQ(48000, gcodec.plfreq); | 1258 EXPECT_EQ(48000, gcodec.plfreq); |
1288 } | 1259 } |
1289 | 1260 |
1290 // Test that with bitrate=N and stereo=0, | 1261 // Test that with bitrate=N and stereo=0, |
1291 // channels and bitrate are 1 and N. | 1262 // channels and bitrate are 1 and N. |
1292 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1263 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1293 EXPECT_TRUE(SetupSendStream()); | 1264 EXPECT_TRUE(SetupSendStream()); |
1294 int channel_num = voe_.GetLastChannel(); | |
1295 cricket::AudioSendParameters parameters; | 1265 cricket::AudioSendParameters parameters; |
1296 parameters.codecs.push_back(kOpusCodec); | 1266 parameters.codecs.push_back(kOpusCodec); |
1297 parameters.codecs[0].bitrate = 30000; | 1267 parameters.codecs[0].bitrate = 30000; |
1298 parameters.codecs[0].params["stereo"] = "0"; | 1268 parameters.codecs[0].params["stereo"] = "0"; |
1299 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1269 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1300 webrtc::CodecInst gcodec; | 1270 CheckSendCodec(kSsrc1, "opus", 1, 30000); |
1301 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1302 EXPECT_EQ(1, gcodec.channels); | |
1303 EXPECT_EQ(30000, gcodec.rate); | |
1304 EXPECT_STREQ("opus", gcodec.plname); | |
1305 } | 1271 } |
1306 | 1272 |
1307 // Test that with bitrate=N and without any parameters, | 1273 // Test that with bitrate=N and without any parameters, |
1308 // channels and bitrate are 1 and N. | 1274 // channels and bitrate are 1 and N. |
1309 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { | 1275 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
1310 EXPECT_TRUE(SetupSendStream()); | 1276 EXPECT_TRUE(SetupSendStream()); |
1311 int channel_num = voe_.GetLastChannel(); | |
1312 cricket::AudioSendParameters parameters; | 1277 cricket::AudioSendParameters parameters; |
1313 parameters.codecs.push_back(kOpusCodec); | 1278 parameters.codecs.push_back(kOpusCodec); |
1314 parameters.codecs[0].bitrate = 30000; | 1279 parameters.codecs[0].bitrate = 30000; |
1315 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1280 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1316 webrtc::CodecInst gcodec; | 1281 CheckSendCodec(kSsrc1, "opus", 1, 30000); |
1317 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1318 EXPECT_EQ(1, gcodec.channels); | |
1319 EXPECT_EQ(30000, gcodec.rate); | |
1320 EXPECT_STREQ("opus", gcodec.plname); | |
1321 } | 1282 } |
1322 | 1283 |
1323 // Test that with bitrate=N and stereo=1, | 1284 // Test that with bitrate=N and stereo=1, |
1324 // channels and bitrate are 2 and N. | 1285 // channels and bitrate are 2 and N. |
1325 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1286 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1326 EXPECT_TRUE(SetupSendStream()); | 1287 EXPECT_TRUE(SetupSendStream()); |
1327 int channel_num = voe_.GetLastChannel(); | |
1328 cricket::AudioSendParameters parameters; | 1288 cricket::AudioSendParameters parameters; |
1329 parameters.codecs.push_back(kOpusCodec); | 1289 parameters.codecs.push_back(kOpusCodec); |
1330 parameters.codecs[0].bitrate = 30000; | 1290 parameters.codecs[0].bitrate = 30000; |
1331 parameters.codecs[0].params["stereo"] = "1"; | 1291 parameters.codecs[0].params["stereo"] = "1"; |
1332 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1292 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1333 webrtc::CodecInst gcodec; | 1293 CheckSendCodec(kSsrc1, "opus", 2, 30000); |
1334 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1335 EXPECT_EQ(2, gcodec.channels); | |
1336 EXPECT_EQ(30000, gcodec.rate); | |
1337 EXPECT_STREQ("opus", gcodec.plname); | |
1338 } | 1294 } |
1339 | 1295 |
1340 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | 1296 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. |
1341 // Also test that the "maxaveragebitrate" can't be set to values outside the | 1297 // Also test that the "maxaveragebitrate" can't be set to values outside the |
1342 // range of 6000 and 510000 | 1298 // range of 6000 and 510000 |
1343 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | 1299 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { |
1344 EXPECT_TRUE(SetupSendStream()); | 1300 EXPECT_TRUE(SetupSendStream()); |
1345 int channel_num = voe_.GetLastChannel(); | |
1346 cricket::AudioSendParameters parameters; | 1301 cricket::AudioSendParameters parameters; |
1347 parameters.codecs.push_back(kOpusCodec); | 1302 parameters.codecs.push_back(kOpusCodec); |
1348 parameters.codecs[0].bitrate = 30000; | 1303 parameters.codecs[0].bitrate = 30000; |
1349 webrtc::CodecInst gcodec; | |
1350 | |
1351 // Ignore if less than 6000. | 1304 // Ignore if less than 6000. |
1352 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | 1305 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; |
1353 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1306 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1354 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1307 EXPECT_EQ(6000, GetCodecBitrate(kSsrc1)); |
1355 EXPECT_EQ(6000, gcodec.rate); | |
1356 | 1308 |
1357 // Ignore if larger than 510000. | 1309 // Ignore if larger than 510000. |
1358 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | 1310 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; |
1359 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1311 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1360 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1312 EXPECT_EQ(510000, GetCodecBitrate(kSsrc1)); |
1361 EXPECT_EQ(510000, gcodec.rate); | |
1362 | 1313 |
1363 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | 1314 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; |
1364 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1315 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1365 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1316 EXPECT_EQ(200000, GetCodecBitrate(kSsrc1)); |
1366 EXPECT_EQ(200000, gcodec.rate); | |
1367 } | 1317 } |
1368 | 1318 |
1369 // Test that we can enable NACK with opus as caller. | 1319 // Test that we can enable NACK with opus as caller. |
1370 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { | 1320 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { |
1371 EXPECT_TRUE(SetupSendStream()); | 1321 EXPECT_TRUE(SetupSendStream()); |
1372 cricket::AudioSendParameters parameters; | 1322 cricket::AudioSendParameters parameters; |
1373 parameters.codecs.push_back(kOpusCodec); | 1323 parameters.codecs.push_back(kOpusCodec); |
1374 parameters.codecs[0].AddFeedbackParam( | 1324 parameters.codecs[0].AddFeedbackParam( |
1375 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1325 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1376 cricket::kParamValueEmpty)); | 1326 cricket::kParamValueEmpty)); |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1464 | 1414 |
1465 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 1415 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
1466 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1416 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1467 EXPECT_TRUE(AddRecvStream(kSsrc3)); | 1417 EXPECT_TRUE(AddRecvStream(kSsrc3)); |
1468 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); | 1418 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); |
1469 } | 1419 } |
1470 | 1420 |
1471 // Test that without useinbandfec, Opus FEC is off. | 1421 // Test that without useinbandfec, Opus FEC is off. |
1472 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | 1422 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { |
1473 EXPECT_TRUE(SetupSendStream()); | 1423 EXPECT_TRUE(SetupSendStream()); |
1474 int channel_num = voe_.GetLastChannel(); | |
1475 cricket::AudioSendParameters parameters; | 1424 cricket::AudioSendParameters parameters; |
1476 parameters.codecs.push_back(kOpusCodec); | 1425 parameters.codecs.push_back(kOpusCodec); |
1477 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1426 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1478 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); | 1427 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1479 } | 1428 } |
1480 | 1429 |
1481 // Test that with useinbandfec=0, Opus FEC is off. | 1430 // Test that with useinbandfec=0, Opus FEC is off. |
1482 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | 1431 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { |
1483 EXPECT_TRUE(SetupSendStream()); | 1432 EXPECT_TRUE(SetupSendStream()); |
1484 int channel_num = voe_.GetLastChannel(); | |
1485 cricket::AudioSendParameters parameters; | 1433 cricket::AudioSendParameters parameters; |
1486 parameters.codecs.push_back(kOpusCodec); | 1434 parameters.codecs.push_back(kOpusCodec); |
1487 parameters.codecs[0].bitrate = 0; | 1435 parameters.codecs[0].bitrate = 0; |
1488 parameters.codecs[0].params["useinbandfec"] = "0"; | 1436 parameters.codecs[0].params["useinbandfec"] = "0"; |
1489 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1437 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1490 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); | 1438 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1491 webrtc::CodecInst gcodec; | |
1492 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1493 EXPECT_STREQ("opus", gcodec.plname); | |
1494 EXPECT_EQ(1, gcodec.channels); | |
1495 EXPECT_EQ(32000, gcodec.rate); | |
1496 } | 1439 } |
1497 | 1440 |
1498 // Test that with useinbandfec=1, Opus FEC is on. | 1441 // Test that with useinbandfec=1, Opus FEC is on. |
1499 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | 1442 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { |
1500 EXPECT_TRUE(SetupSendStream()); | 1443 EXPECT_TRUE(SetupSendStream()); |
1501 int channel_num = voe_.GetLastChannel(); | |
1502 cricket::AudioSendParameters parameters; | 1444 cricket::AudioSendParameters parameters; |
1503 parameters.codecs.push_back(kOpusCodec); | 1445 parameters.codecs.push_back(kOpusCodec); |
1504 parameters.codecs[0].bitrate = 0; | 1446 parameters.codecs[0].bitrate = 0; |
1505 parameters.codecs[0].params["useinbandfec"] = "1"; | 1447 parameters.codecs[0].params["useinbandfec"] = "1"; |
1506 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1448 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1507 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); | 1449 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1508 webrtc::CodecInst gcodec; | 1450 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1509 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1510 EXPECT_STREQ("opus", gcodec.plname); | |
1511 EXPECT_EQ(1, gcodec.channels); | |
1512 EXPECT_EQ(32000, gcodec.rate); | |
1513 } | 1451 } |
1514 | 1452 |
1515 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | 1453 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. |
1516 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | 1454 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { |
1517 EXPECT_TRUE(SetupSendStream()); | 1455 EXPECT_TRUE(SetupSendStream()); |
1518 int channel_num = voe_.GetLastChannel(); | |
1519 cricket::AudioSendParameters parameters; | 1456 cricket::AudioSendParameters parameters; |
1520 parameters.codecs.push_back(kOpusCodec); | 1457 parameters.codecs.push_back(kOpusCodec); |
1521 parameters.codecs[0].bitrate = 0; | 1458 parameters.codecs[0].bitrate = 0; |
1522 parameters.codecs[0].params["stereo"] = "1"; | 1459 parameters.codecs[0].params["stereo"] = "1"; |
1523 parameters.codecs[0].params["useinbandfec"] = "1"; | 1460 parameters.codecs[0].params["useinbandfec"] = "1"; |
1524 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1461 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1525 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); | 1462 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1526 webrtc::CodecInst gcodec; | 1463 CheckSendCodec(kSsrc1, "opus", 2, 64000); |
1527 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1528 EXPECT_STREQ("opus", gcodec.plname); | |
1529 EXPECT_EQ(2, gcodec.channels); | |
1530 EXPECT_EQ(64000, gcodec.rate); | |
1531 } | 1464 } |
1532 | 1465 |
1533 // Test that with non-Opus, codec FEC is off. | 1466 // Test that with non-Opus, codec FEC is off. |
1534 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | 1467 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { |
1535 EXPECT_TRUE(SetupSendStream()); | 1468 EXPECT_TRUE(SetupSendStream()); |
1536 int channel_num = voe_.GetLastChannel(); | |
1537 cricket::AudioSendParameters parameters; | 1469 cricket::AudioSendParameters parameters; |
1538 parameters.codecs.push_back(kIsacCodec); | 1470 parameters.codecs.push_back(kIsacCodec); |
1539 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1471 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1540 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); | 1472 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1541 } | 1473 } |
1542 | 1474 |
1543 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | 1475 // Test the with non-Opus, even if useinbandfec=1, FEC is off. |
1544 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | 1476 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { |
1545 EXPECT_TRUE(SetupSendStream()); | 1477 EXPECT_TRUE(SetupSendStream()); |
1546 int channel_num = voe_.GetLastChannel(); | |
1547 cricket::AudioSendParameters parameters; | 1478 cricket::AudioSendParameters parameters; |
1548 parameters.codecs.push_back(kIsacCodec); | 1479 parameters.codecs.push_back(kIsacCodec); |
1549 parameters.codecs[0].params["useinbandfec"] = "1"; | 1480 parameters.codecs[0].params["useinbandfec"] = "1"; |
1550 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1481 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1551 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); | 1482 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1552 } | 1483 } |
1553 | 1484 |
1554 // Test that Opus FEC status can be changed. | 1485 // Test that Opus FEC status can be changed. |
1555 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | 1486 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { |
1556 EXPECT_TRUE(SetupSendStream()); | 1487 EXPECT_TRUE(SetupSendStream()); |
1557 int channel_num = voe_.GetLastChannel(); | |
1558 cricket::AudioSendParameters parameters; | 1488 cricket::AudioSendParameters parameters; |
1559 parameters.codecs.push_back(kOpusCodec); | 1489 parameters.codecs.push_back(kOpusCodec); |
1560 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1490 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1561 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); | 1491 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
| 1492 |
1562 parameters.codecs[0].params["useinbandfec"] = "1"; | 1493 parameters.codecs[0].params["useinbandfec"] = "1"; |
1563 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1494 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1564 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); | 1495 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1565 } | 1496 } |
1566 | 1497 |
1567 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1498 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1568 EXPECT_TRUE(SetupChannel()); | 1499 EXPECT_TRUE(SetupChannel()); |
1569 cricket::AudioSendParameters send_parameters; | 1500 cricket::AudioSendParameters send_parameters; |
1570 send_parameters.codecs.push_back(kOpusCodec); | 1501 send_parameters.codecs.push_back(kOpusCodec); |
1571 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1502 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1572 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); | 1503 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); |
1573 | 1504 |
1574 cricket::AudioRecvParameters recv_parameters; | 1505 cricket::AudioRecvParameters recv_parameters; |
1575 recv_parameters.codecs.push_back(kIsacCodec); | 1506 recv_parameters.codecs.push_back(kIsacCodec); |
1576 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1507 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1577 EXPECT_TRUE(AddRecvStream(kSsrc1)); | 1508 EXPECT_TRUE(AddRecvStream(kSsrc1)); |
1578 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1509 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1579 EXPECT_FALSE( | 1510 EXPECT_FALSE( |
1580 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1511 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1581 | 1512 |
1582 send_parameters.codecs = engine_->send_codecs(); | 1513 send_parameters.codecs = engine_->send_codecs(); |
1583 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); | 1514 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); |
1584 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1515 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1585 EXPECT_TRUE( | 1516 EXPECT_TRUE( |
1586 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1517 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1587 } | 1518 } |
1588 | 1519 |
1589 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | 1520 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. |
1590 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | 1521 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { |
1591 EXPECT_TRUE(SetupSendStream()); | 1522 EXPECT_TRUE(SetupSendStream()); |
1592 int channel_num = voe_.GetLastChannel(); | |
1593 cricket::AudioSendParameters parameters; | 1523 cricket::AudioSendParameters parameters; |
1594 parameters.codecs.push_back(kOpusCodec); | 1524 parameters.codecs.push_back(kOpusCodec); |
1595 parameters.codecs[0].bitrate = 0; | 1525 parameters.codecs[0].bitrate = 0; |
1596 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | 1526 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
1597 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1527 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1598 EXPECT_EQ(cricket::kOpusBandwidthNb, | 1528 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); |
1599 voe_.GetMaxEncodingBandwidth(channel_num)); | 1529 EXPECT_EQ(12000, GetCodecBitrate(kSsrc1)); |
1600 webrtc::CodecInst gcodec; | 1530 |
1601 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1531 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1602 EXPECT_STREQ("opus", gcodec.plname); | 1532 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1603 | 1533 EXPECT_EQ(24000, GetCodecBitrate(kSsrc1)); |
1604 EXPECT_EQ(12000, gcodec.rate); | |
1605 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1606 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
1607 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1608 EXPECT_EQ(24000, gcodec.rate); | |
1609 } | 1534 } |
1610 | 1535 |
1611 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | 1536 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. |
1612 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | 1537 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { |
1613 EXPECT_TRUE(SetupSendStream()); | 1538 EXPECT_TRUE(SetupSendStream()); |
1614 int channel_num = voe_.GetLastChannel(); | |
1615 cricket::AudioSendParameters parameters; | 1539 cricket::AudioSendParameters parameters; |
1616 parameters.codecs.push_back(kOpusCodec); | 1540 parameters.codecs.push_back(kOpusCodec); |
1617 parameters.codecs[0].bitrate = 0; | 1541 parameters.codecs[0].bitrate = 0; |
1618 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | 1542 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); |
1619 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1543 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1620 EXPECT_EQ(cricket::kOpusBandwidthMb, | 1544 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1)); |
1621 voe_.GetMaxEncodingBandwidth(channel_num)); | 1545 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); |
1622 webrtc::CodecInst gcodec; | 1546 |
1623 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1547 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1624 EXPECT_STREQ("opus", gcodec.plname); | 1548 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1625 | 1549 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); |
1626 EXPECT_EQ(20000, gcodec.rate); | |
1627 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1628 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
1629 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1630 EXPECT_EQ(40000, gcodec.rate); | |
1631 } | 1550 } |
1632 | 1551 |
1633 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | 1552 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. |
1634 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | 1553 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { |
1635 EXPECT_TRUE(SetupSendStream()); | 1554 EXPECT_TRUE(SetupSendStream()); |
1636 int channel_num = voe_.GetLastChannel(); | |
1637 cricket::AudioSendParameters parameters; | 1555 cricket::AudioSendParameters parameters; |
1638 parameters.codecs.push_back(kOpusCodec); | 1556 parameters.codecs.push_back(kOpusCodec); |
1639 parameters.codecs[0].bitrate = 0; | 1557 parameters.codecs[0].bitrate = 0; |
1640 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | 1558 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); |
1641 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1559 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1642 EXPECT_EQ(cricket::kOpusBandwidthWb, | 1560 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1)); |
1643 voe_.GetMaxEncodingBandwidth(channel_num)); | 1561 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); |
1644 webrtc::CodecInst gcodec; | 1562 |
1645 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1563 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1646 EXPECT_STREQ("opus", gcodec.plname); | 1564 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1647 | 1565 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); |
1648 EXPECT_EQ(20000, gcodec.rate); | |
1649 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1650 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
1651 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1652 EXPECT_EQ(40000, gcodec.rate); | |
1653 } | 1566 } |
1654 | 1567 |
1655 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | 1568 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. |
1656 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | 1569 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { |
1657 EXPECT_TRUE(SetupSendStream()); | 1570 EXPECT_TRUE(SetupSendStream()); |
1658 int channel_num = voe_.GetLastChannel(); | |
1659 cricket::AudioSendParameters parameters; | 1571 cricket::AudioSendParameters parameters; |
1660 parameters.codecs.push_back(kOpusCodec); | 1572 parameters.codecs.push_back(kOpusCodec); |
1661 parameters.codecs[0].bitrate = 0; | 1573 parameters.codecs[0].bitrate = 0; |
1662 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | 1574 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); |
1663 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1575 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1664 EXPECT_EQ(cricket::kOpusBandwidthSwb, | 1576 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1)); |
1665 voe_.GetMaxEncodingBandwidth(channel_num)); | 1577 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); |
1666 webrtc::CodecInst gcodec; | 1578 |
1667 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1579 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1668 EXPECT_STREQ("opus", gcodec.plname); | 1580 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1669 | 1581 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
1670 EXPECT_EQ(32000, gcodec.rate); | |
1671 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1672 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
1673 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1674 EXPECT_EQ(64000, gcodec.rate); | |
1675 } | 1582 } |
1676 | 1583 |
1677 // Test 24000 < maxplaybackrate triggers Opus full band mode. | 1584 // Test 24000 < maxplaybackrate triggers Opus full band mode. |
1678 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | 1585 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { |
1679 EXPECT_TRUE(SetupSendStream()); | 1586 EXPECT_TRUE(SetupSendStream()); |
1680 int channel_num = voe_.GetLastChannel(); | |
1681 cricket::AudioSendParameters parameters; | 1587 cricket::AudioSendParameters parameters; |
1682 parameters.codecs.push_back(kOpusCodec); | 1588 parameters.codecs.push_back(kOpusCodec); |
1683 parameters.codecs[0].bitrate = 0; | 1589 parameters.codecs[0].bitrate = 0; |
1684 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | 1590 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); |
1685 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1591 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1686 EXPECT_EQ(cricket::kOpusBandwidthFb, | 1592 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1)); |
1687 voe_.GetMaxEncodingBandwidth(channel_num)); | 1593 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); |
1688 webrtc::CodecInst gcodec; | 1594 |
1689 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1595 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1690 EXPECT_STREQ("opus", gcodec.plname); | 1596 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1691 | 1597 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
1692 EXPECT_EQ(32000, gcodec.rate); | |
1693 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1694 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
1695 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1696 EXPECT_EQ(64000, gcodec.rate); | |
1697 } | 1598 } |
1698 | 1599 |
1699 // Test Opus that without maxplaybackrate, default playback rate is used. | 1600 // Test Opus that without maxplaybackrate, default playback rate is used. |
1700 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | 1601 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { |
1701 EXPECT_TRUE(SetupSendStream()); | 1602 EXPECT_TRUE(SetupSendStream()); |
1702 int channel_num = voe_.GetLastChannel(); | 1603 cricket::AudioSendParameters parameters; |
1703 cricket::AudioSendParameters parameters; | 1604 parameters.codecs.push_back(kOpusCodec); |
1704 parameters.codecs.push_back(kOpusCodec); | 1605 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1705 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1606 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); |
1706 EXPECT_EQ(cricket::kOpusBandwidthFb, | |
1707 voe_.GetMaxEncodingBandwidth(channel_num)); | |
1708 } | 1607 } |
1709 | 1608 |
1710 // Test the with non-Opus, maxplaybackrate has no effect. | 1609 // Test the with non-Opus, maxplaybackrate has no effect. |
1711 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | 1610 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { |
1712 EXPECT_TRUE(SetupSendStream()); | 1611 EXPECT_TRUE(SetupSendStream()); |
1713 int channel_num = voe_.GetLastChannel(); | |
1714 cricket::AudioSendParameters parameters; | 1612 cricket::AudioSendParameters parameters; |
1715 parameters.codecs.push_back(kIsacCodec); | 1613 parameters.codecs.push_back(kIsacCodec); |
1716 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | 1614 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); |
1717 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1615 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1718 EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num)); | 1616 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1)); |
1719 } | 1617 } |
1720 | 1618 |
1721 // Test maxplaybackrate can be set on two streams. | 1619 // Test maxplaybackrate can be set on two streams. |
1722 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | 1620 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { |
1723 EXPECT_TRUE(SetupSendStream()); | 1621 EXPECT_TRUE(SetupSendStream()); |
1724 int channel_num = voe_.GetLastChannel(); | 1622 cricket::AudioSendParameters parameters; |
1725 cricket::AudioSendParameters parameters; | 1623 parameters.codecs.push_back(kOpusCodec); |
1726 parameters.codecs.push_back(kOpusCodec); | 1624 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1727 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1625 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); |
1728 // Default bandwidth is 24000. | |
1729 EXPECT_EQ(cricket::kOpusBandwidthFb, | |
1730 voe_.GetMaxEncodingBandwidth(channel_num)); | |
1731 | 1626 |
1732 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | 1627 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
1733 | 1628 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1734 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1629 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); |
1735 EXPECT_EQ(cricket::kOpusBandwidthNb, | |
1736 voe_.GetMaxEncodingBandwidth(channel_num)); | |
1737 | 1630 |
1738 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); | 1631 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); |
1739 channel_num = voe_.GetLastChannel(); | 1632 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2)); |
1740 EXPECT_EQ(cricket::kOpusBandwidthNb, | |
1741 voe_.GetMaxEncodingBandwidth(channel_num)); | |
1742 } | 1633 } |
1743 | 1634 |
1744 // Test that with usedtx=0, Opus DTX is off. | 1635 // Test that with usedtx=0, Opus DTX is off. |
1745 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | 1636 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { |
1746 EXPECT_TRUE(SetupSendStream()); | 1637 EXPECT_TRUE(SetupSendStream()); |
1747 int channel_num = voe_.GetLastChannel(); | |
1748 cricket::AudioSendParameters parameters; | 1638 cricket::AudioSendParameters parameters; |
1749 parameters.codecs.push_back(kOpusCodec); | 1639 parameters.codecs.push_back(kOpusCodec); |
1750 parameters.codecs[0].params["usedtx"] = "0"; | 1640 parameters.codecs[0].params["usedtx"] = "0"; |
1751 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1641 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1752 EXPECT_FALSE(voe_.GetOpusDtx(channel_num)); | 1642 EXPECT_FALSE(GetOpusDtx(kSsrc1)); |
1753 } | 1643 } |
1754 | 1644 |
1755 // Test that with usedtx=1, Opus DTX is on. | 1645 // Test that with usedtx=1, Opus DTX is on. |
1756 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | 1646 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { |
1757 EXPECT_TRUE(SetupSendStream()); | 1647 EXPECT_TRUE(SetupSendStream()); |
1758 int channel_num = voe_.GetLastChannel(); | |
1759 cricket::AudioSendParameters parameters; | 1648 cricket::AudioSendParameters parameters; |
1760 parameters.codecs.push_back(kOpusCodec); | 1649 parameters.codecs.push_back(kOpusCodec); |
1761 parameters.codecs[0].params["usedtx"] = "1"; | 1650 parameters.codecs[0].params["usedtx"] = "1"; |
1762 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1651 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1763 EXPECT_TRUE(voe_.GetOpusDtx(channel_num)); | 1652 EXPECT_TRUE(GetOpusDtx(kSsrc1)); |
1764 EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD. | |
1765 } | 1653 } |
1766 | 1654 |
1767 // Test that usedtx=1 works with stereo Opus. | 1655 // Test that usedtx=1 works with stereo Opus. |
1768 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | 1656 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { |
1769 EXPECT_TRUE(SetupSendStream()); | 1657 EXPECT_TRUE(SetupSendStream()); |
1770 int channel_num = voe_.GetLastChannel(); | |
1771 cricket::AudioSendParameters parameters; | 1658 cricket::AudioSendParameters parameters; |
1772 parameters.codecs.push_back(kOpusCodec); | 1659 parameters.codecs.push_back(kOpusCodec); |
1773 parameters.codecs[0].params["usedtx"] = "1"; | 1660 parameters.codecs[0].params["usedtx"] = "1"; |
1774 parameters.codecs[0].params["stereo"] = "1"; | 1661 parameters.codecs[0].params["stereo"] = "1"; |
1775 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1662 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1776 EXPECT_TRUE(voe_.GetOpusDtx(channel_num)); | 1663 EXPECT_TRUE(GetOpusDtx(kSsrc1)); |
1777 EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD. | |
1778 } | 1664 } |
1779 | 1665 |
1780 // Test that usedtx=1 does not work with non Opus. | 1666 // Test that usedtx=1 does not work with non Opus. |
1781 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | 1667 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { |
1782 EXPECT_TRUE(SetupSendStream()); | 1668 EXPECT_TRUE(SetupSendStream()); |
1783 int channel_num = voe_.GetLastChannel(); | |
1784 cricket::AudioSendParameters parameters; | 1669 cricket::AudioSendParameters parameters; |
1785 parameters.codecs.push_back(kIsacCodec); | 1670 parameters.codecs.push_back(kIsacCodec); |
1786 parameters.codecs[0].params["usedtx"] = "1"; | 1671 parameters.codecs[0].params["usedtx"] = "1"; |
1787 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1672 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1788 EXPECT_FALSE(voe_.GetOpusDtx(channel_num)); | 1673 EXPECT_FALSE(GetOpusDtx(kSsrc1)); |
1789 } | 1674 } |
1790 | 1675 |
1791 // Test that we can switch back and forth between Opus and ISAC with CN. | 1676 // Test that we can switch back and forth between Opus and ISAC with CN. |
1792 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1677 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1793 EXPECT_TRUE(SetupSendStream()); | 1678 EXPECT_TRUE(SetupSendStream()); |
1794 int channel_num = voe_.GetLastChannel(); | 1679 |
1795 cricket::AudioSendParameters opus_parameters; | 1680 cricket::AudioSendParameters opus_parameters; |
1796 opus_parameters.codecs.push_back(kOpusCodec); | 1681 opus_parameters.codecs.push_back(kOpusCodec); |
1797 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); | 1682 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); |
1798 webrtc::CodecInst gcodec; | 1683 { |
1799 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1684 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1800 EXPECT_EQ(111, gcodec.pltype); | 1685 EXPECT_EQ(111, gcodec.pltype); |
1801 EXPECT_STREQ("opus", gcodec.plname); | 1686 EXPECT_STREQ("opus", gcodec.plname); |
| 1687 } |
1802 | 1688 |
1803 cricket::AudioSendParameters isac_parameters; | 1689 cricket::AudioSendParameters isac_parameters; |
1804 isac_parameters.codecs.push_back(kIsacCodec); | 1690 isac_parameters.codecs.push_back(kIsacCodec); |
1805 isac_parameters.codecs.push_back(kCn16000Codec); | 1691 isac_parameters.codecs.push_back(kCn16000Codec); |
1806 isac_parameters.codecs.push_back(kOpusCodec); | 1692 isac_parameters.codecs.push_back(kOpusCodec); |
1807 EXPECT_TRUE(channel_->SetSendParameters(isac_parameters)); | 1693 EXPECT_TRUE(channel_->SetSendParameters(isac_parameters)); |
1808 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1694 { |
1809 EXPECT_EQ(103, gcodec.pltype); | 1695 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1810 EXPECT_STREQ("ISAC", gcodec.plname); | 1696 EXPECT_EQ(103, gcodec.pltype); |
| 1697 EXPECT_STREQ("ISAC", gcodec.plname); |
| 1698 } |
1811 | 1699 |
1812 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); | 1700 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); |
1813 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1701 { |
1814 EXPECT_EQ(111, gcodec.pltype); | 1702 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1815 EXPECT_STREQ("opus", gcodec.plname); | 1703 EXPECT_EQ(111, gcodec.pltype); |
| 1704 EXPECT_STREQ("opus", gcodec.plname); |
| 1705 } |
1816 } | 1706 } |
1817 | 1707 |
1818 // Test that we handle various ways of specifying bitrate. | 1708 // Test that we handle various ways of specifying bitrate. |
1819 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1709 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1820 EXPECT_TRUE(SetupSendStream()); | 1710 EXPECT_TRUE(SetupSendStream()); |
1821 int channel_num = voe_.GetLastChannel(); | |
1822 cricket::AudioSendParameters parameters; | 1711 cricket::AudioSendParameters parameters; |
1823 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1712 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1824 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1713 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1825 webrtc::CodecInst gcodec; | 1714 { |
1826 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1715 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1827 EXPECT_EQ(103, gcodec.pltype); | 1716 EXPECT_EQ(103, gcodec.pltype); |
1828 EXPECT_STREQ("ISAC", gcodec.plname); | 1717 EXPECT_STREQ("ISAC", gcodec.plname); |
1829 EXPECT_EQ(32000, gcodec.rate); | 1718 EXPECT_EQ(32000, gcodec.rate); |
| 1719 } |
1830 | 1720 |
1831 parameters.codecs[0].bitrate = 0; // bitrate == default | 1721 parameters.codecs[0].bitrate = 0; // bitrate == default |
1832 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1722 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1833 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1723 { |
1834 EXPECT_EQ(103, gcodec.pltype); | 1724 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1835 EXPECT_STREQ("ISAC", gcodec.plname); | 1725 EXPECT_EQ(103, gcodec.pltype); |
1836 EXPECT_EQ(-1, gcodec.rate); | 1726 EXPECT_STREQ("ISAC", gcodec.plname); |
1837 | 1727 EXPECT_EQ(-1, gcodec.rate); |
| 1728 } |
1838 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1729 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1839 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1730 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1840 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1731 { |
1841 EXPECT_EQ(103, gcodec.pltype); | 1732 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1842 EXPECT_STREQ("ISAC", gcodec.plname); | 1733 EXPECT_EQ(103, gcodec.pltype); |
1843 EXPECT_EQ(28000, gcodec.rate); | 1734 EXPECT_STREQ("ISAC", gcodec.plname); |
| 1735 EXPECT_EQ(28000, gcodec.rate); |
| 1736 } |
1844 | 1737 |
1845 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1738 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1846 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1739 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1847 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1740 { |
1848 EXPECT_EQ(0, gcodec.pltype); | 1741 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1849 EXPECT_STREQ("PCMU", gcodec.plname); | 1742 EXPECT_EQ(0, gcodec.pltype); |
1850 EXPECT_EQ(64000, gcodec.rate); | 1743 EXPECT_STREQ("PCMU", gcodec.plname); |
| 1744 EXPECT_EQ(64000, gcodec.rate); |
| 1745 } |
1851 | 1746 |
1852 parameters.codecs[0].bitrate = 0; // bitrate == default | 1747 parameters.codecs[0].bitrate = 0; // bitrate == default |
1853 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1748 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1854 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1749 { |
1855 EXPECT_EQ(0, gcodec.pltype); | 1750 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1856 EXPECT_STREQ("PCMU", gcodec.plname); | 1751 EXPECT_EQ(0, gcodec.pltype); |
1857 EXPECT_EQ(64000, gcodec.rate); | 1752 EXPECT_STREQ("PCMU", gcodec.plname); |
| 1753 EXPECT_EQ(64000, gcodec.rate); |
| 1754 } |
1858 | 1755 |
1859 parameters.codecs[0] = kOpusCodec; | 1756 parameters.codecs[0] = kOpusCodec; |
1860 parameters.codecs[0].bitrate = 0; // bitrate == default | 1757 parameters.codecs[0].bitrate = 0; // bitrate == default |
1861 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1758 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1862 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1759 { |
1863 EXPECT_EQ(111, gcodec.pltype); | 1760 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1864 EXPECT_STREQ("opus", gcodec.plname); | 1761 EXPECT_EQ(111, gcodec.pltype); |
1865 EXPECT_EQ(32000, gcodec.rate); | 1762 EXPECT_STREQ("opus", gcodec.plname); |
| 1763 EXPECT_EQ(32000, gcodec.rate); |
| 1764 } |
1866 } | 1765 } |
1867 | 1766 |
1868 // Test that we could set packet size specified in kCodecParamPTime. | 1767 // Test that we could set packet size specified in kCodecParamPTime. |
1869 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | 1768 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
1870 EXPECT_TRUE(SetupSendStream()); | 1769 EXPECT_TRUE(SetupSendStream()); |
1871 int channel_num = voe_.GetLastChannel(); | |
1872 cricket::AudioSendParameters parameters; | 1770 cricket::AudioSendParameters parameters; |
1873 parameters.codecs.push_back(kOpusCodec); | 1771 parameters.codecs.push_back(kOpusCodec); |
1874 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1772 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1875 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1773 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1876 webrtc::CodecInst gcodec; | 1774 EXPECT_EQ(1920, GetCodecPacSize(kSsrc1)); // Opus gets 40ms. |
1877 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1878 EXPECT_EQ(1920, gcodec.pacsize); // Opus gets 40ms. | |
1879 | 1775 |
1880 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | 1776 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
1881 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1777 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1882 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1778 EXPECT_EQ(480, GetCodecPacSize(kSsrc1)); // Opus gets 10ms. |
1883 EXPECT_EQ(480, gcodec.pacsize); // Opus gets 10ms. | |
1884 | 1779 |
1885 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | 1780 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
1886 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1781 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1887 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1782 EXPECT_EQ(2880, GetCodecPacSize(kSsrc1)); // Opus gets 60ms. |
1888 EXPECT_EQ(2880, gcodec.pacsize); // Opus gets 60ms. | |
1889 | 1783 |
1890 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | 1784 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
1891 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1785 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1892 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1786 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1893 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1787 EXPECT_EQ(480, GetCodecPacSize( |
1894 EXPECT_EQ(480, gcodec.pacsize); // Isac gets 30ms as the next smallest value. | 1788 kSsrc1)); // Isac gets 30ms as the next smallest value. |
1895 | 1789 |
1896 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | 1790 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
1897 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | 1791 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
1898 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1792 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1899 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1793 EXPECT_EQ(640, GetCodecPacSize( |
1900 EXPECT_EQ(640, gcodec.pacsize); // G722 gets 40ms @16kHz as defined in VoE. | 1794 kSsrc1)); // G722 gets 40ms @16kHz as defined in VoE. |
1901 } | 1795 } |
1902 | 1796 |
1903 // Test that we fail if no codecs are specified. | 1797 // Test that we fail if no codecs are specified. |
1904 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1798 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
1905 EXPECT_TRUE(SetupSendStream()); | 1799 EXPECT_TRUE(SetupSendStream()); |
1906 cricket::AudioSendParameters parameters; | 1800 cricket::AudioSendParameters parameters; |
1907 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1801 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1908 } | 1802 } |
1909 | 1803 |
1910 // Test that we can set send codecs even with telephone-event codec as the first | 1804 // Test that we can set send codecs even with telephone-event codec as the first |
1911 // one on the list. | 1805 // one on the list. |
1912 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1806 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
1913 EXPECT_TRUE(SetupSendStream()); | 1807 EXPECT_TRUE(SetupSendStream()); |
1914 int channel_num = voe_.GetLastChannel(); | |
1915 cricket::AudioSendParameters parameters; | 1808 cricket::AudioSendParameters parameters; |
1916 parameters.codecs.push_back(kTelephoneEventCodec); | 1809 parameters.codecs.push_back(kTelephoneEventCodec); |
1917 parameters.codecs.push_back(kIsacCodec); | 1810 parameters.codecs.push_back(kIsacCodec); |
1918 parameters.codecs.push_back(kPcmuCodec); | 1811 parameters.codecs.push_back(kPcmuCodec); |
1919 parameters.codecs[0].id = 98; // DTMF | 1812 parameters.codecs[0].id = 98; // DTMF |
1920 parameters.codecs[1].id = 96; | 1813 parameters.codecs[1].id = 96; |
1921 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1814 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1922 webrtc::CodecInst gcodec; | 1815 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1923 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | |
1924 EXPECT_EQ(96, gcodec.pltype); | 1816 EXPECT_EQ(96, gcodec.pltype); |
1925 EXPECT_STREQ("ISAC", gcodec.plname); | 1817 EXPECT_STREQ("ISAC", gcodec.plname); |
1926 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1818 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1927 } | 1819 } |
1928 | 1820 |
1929 // Test that payload type range is limited for telephone-event codec. | 1821 // Test that payload type range is limited for telephone-event codec. |
1930 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1822 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
1931 EXPECT_TRUE(SetupSendStream()); | 1823 EXPECT_TRUE(SetupSendStream()); |
1932 cricket::AudioSendParameters parameters; | 1824 cricket::AudioSendParameters parameters; |
1933 parameters.codecs.push_back(kTelephoneEventCodec); | 1825 parameters.codecs.push_back(kTelephoneEventCodec); |
(...skipping 10 matching lines...) Expand all Loading... |
1944 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1836 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1945 parameters.codecs[0].id = -1; // DTMF | 1837 parameters.codecs[0].id = -1; // DTMF |
1946 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1838 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1947 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1839 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1948 } | 1840 } |
1949 | 1841 |
1950 // Test that we can set send codecs even with CN codec as the first | 1842 // Test that we can set send codecs even with CN codec as the first |
1951 // one on the list. | 1843 // one on the list. |
1952 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1844 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
1953 EXPECT_TRUE(SetupSendStream()); | 1845 EXPECT_TRUE(SetupSendStream()); |
1954 int channel_num = voe_.GetLastChannel(); | |
1955 cricket::AudioSendParameters parameters; | 1846 cricket::AudioSendParameters parameters; |
1956 parameters.codecs.push_back(kCn16000Codec); | 1847 parameters.codecs.push_back(kCn16000Codec); |
1957 parameters.codecs.push_back(kIsacCodec); | 1848 parameters.codecs.push_back(kIsacCodec); |
1958 parameters.codecs.push_back(kPcmuCodec); | 1849 parameters.codecs.push_back(kPcmuCodec); |
1959 parameters.codecs[0].id = 98; // wideband CN | 1850 parameters.codecs[0].id = 98; // wideband CN |
1960 parameters.codecs[1].id = 96; | 1851 parameters.codecs[1].id = 96; |
1961 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1852 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1962 webrtc::CodecInst gcodec; | 1853 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1963 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1854 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1964 EXPECT_EQ(96, gcodec.pltype); | 1855 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1965 EXPECT_STREQ("ISAC", gcodec.plname); | 1856 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
1966 EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true)); | 1857 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1967 } | 1858 } |
1968 | 1859 |
1969 // Test that we set VAD and DTMF types correctly as caller. | 1860 // Test that we set VAD and DTMF types correctly as caller. |
1970 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1861 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
1971 EXPECT_TRUE(SetupSendStream()); | 1862 EXPECT_TRUE(SetupSendStream()); |
1972 int channel_num = voe_.GetLastChannel(); | |
1973 cricket::AudioSendParameters parameters; | 1863 cricket::AudioSendParameters parameters; |
1974 parameters.codecs.push_back(kIsacCodec); | 1864 parameters.codecs.push_back(kIsacCodec); |
1975 parameters.codecs.push_back(kPcmuCodec); | 1865 parameters.codecs.push_back(kPcmuCodec); |
1976 // TODO(juberti): cn 32000 | 1866 // TODO(juberti): cn 32000 |
1977 parameters.codecs.push_back(kCn16000Codec); | 1867 parameters.codecs.push_back(kCn16000Codec); |
1978 parameters.codecs.push_back(kCn8000Codec); | 1868 parameters.codecs.push_back(kCn8000Codec); |
1979 parameters.codecs.push_back(kTelephoneEventCodec); | 1869 parameters.codecs.push_back(kTelephoneEventCodec); |
1980 parameters.codecs[0].id = 96; | 1870 parameters.codecs[0].id = 96; |
1981 parameters.codecs[2].id = 97; // wideband CN | 1871 parameters.codecs[2].id = 97; // wideband CN |
1982 parameters.codecs[4].id = 98; // DTMF | 1872 parameters.codecs[4].id = 98; // DTMF |
1983 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1873 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1984 webrtc::CodecInst gcodec; | 1874 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1985 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1875 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1986 EXPECT_EQ(96, gcodec.pltype); | 1876 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1987 EXPECT_STREQ("ISAC", gcodec.plname); | 1877 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1988 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1878 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1989 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | 1879 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
1990 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 1880 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1991 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1881 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1992 } | 1882 } |
1993 | 1883 |
1994 // Test that we set VAD and DTMF types correctly as callee. | 1884 // Test that we set VAD and DTMF types correctly as callee. |
1995 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1885 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
1996 EXPECT_TRUE(SetupChannel()); | 1886 EXPECT_TRUE(SetupChannel()); |
1997 cricket::AudioSendParameters parameters; | 1887 cricket::AudioSendParameters parameters; |
1998 parameters.codecs.push_back(kIsacCodec); | 1888 parameters.codecs.push_back(kIsacCodec); |
1999 parameters.codecs.push_back(kPcmuCodec); | 1889 parameters.codecs.push_back(kPcmuCodec); |
2000 // TODO(juberti): cn 32000 | 1890 // TODO(juberti): cn 32000 |
2001 parameters.codecs.push_back(kCn16000Codec); | 1891 parameters.codecs.push_back(kCn16000Codec); |
2002 parameters.codecs.push_back(kCn8000Codec); | 1892 parameters.codecs.push_back(kCn8000Codec); |
2003 parameters.codecs.push_back(kTelephoneEventCodec); | 1893 parameters.codecs.push_back(kTelephoneEventCodec); |
2004 parameters.codecs[0].id = 96; | 1894 parameters.codecs[0].id = 96; |
2005 parameters.codecs[2].id = 97; // wideband CN | 1895 parameters.codecs[2].id = 97; // wideband CN |
2006 parameters.codecs[4].id = 98; // DTMF | 1896 parameters.codecs[4].id = 98; // DTMF |
2007 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1897 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2008 EXPECT_TRUE(channel_->AddSendStream( | 1898 EXPECT_TRUE(channel_->AddSendStream( |
2009 cricket::StreamParams::CreateLegacy(kSsrc1))); | 1899 cricket::StreamParams::CreateLegacy(kSsrc1))); |
2010 int channel_num = voe_.GetLastChannel(); | |
2011 | 1900 |
2012 webrtc::CodecInst gcodec; | 1901 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2013 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1902 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
2014 EXPECT_EQ(96, gcodec.pltype); | 1903 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
2015 EXPECT_STREQ("ISAC", gcodec.plname); | 1904 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
2016 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1905 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
2017 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | 1906 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2018 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 1907 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2019 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1908 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2020 } | 1909 } |
2021 | 1910 |
2022 // Test that we only apply VAD if we have a CN codec that matches the | 1911 // Test that we only apply VAD if we have a CN codec that matches the |
2023 // send codec clockrate. | 1912 // send codec clockrate. |
2024 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1913 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
2025 EXPECT_TRUE(SetupSendStream()); | 1914 EXPECT_TRUE(SetupSendStream()); |
2026 int channel_num = voe_.GetLastChannel(); | |
2027 cricket::AudioSendParameters parameters; | 1915 cricket::AudioSendParameters parameters; |
2028 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1916 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2029 parameters.codecs.push_back(kIsacCodec); | 1917 parameters.codecs.push_back(kIsacCodec); |
2030 parameters.codecs.push_back(kCn16000Codec); | 1918 parameters.codecs.push_back(kCn16000Codec); |
2031 parameters.codecs[1].id = 97; | 1919 parameters.codecs[1].id = 97; |
2032 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1920 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2033 webrtc::CodecInst gcodec; | 1921 { |
2034 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1922 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2035 EXPECT_STREQ("ISAC", gcodec.plname); | 1923 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
2036 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1924 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
2037 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 1925 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 1926 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
| 1927 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
| 1928 } |
2038 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1929 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
2039 parameters.codecs[0] = kPcmuCodec; | 1930 parameters.codecs[0] = kPcmuCodec; |
2040 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1931 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2041 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1932 { |
2042 EXPECT_STREQ("PCMU", gcodec.plname); | 1933 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2043 EXPECT_FALSE(voe_.GetVAD(channel_num)); | 1934 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
| 1935 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 1936 } |
2044 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1937 // Set PCMU(8K) and CN(8K). VAD should be activated. |
2045 parameters.codecs[1] = kCn8000Codec; | 1938 parameters.codecs[1] = kCn8000Codec; |
2046 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1939 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2047 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1940 { |
2048 EXPECT_STREQ("PCMU", gcodec.plname); | 1941 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2049 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1942 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
2050 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | 1943 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
| 1944 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 1945 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
| 1946 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
| 1947 } |
2051 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1948 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
2052 parameters.codecs[0] = kIsacCodec; | 1949 parameters.codecs[0] = kIsacCodec; |
2053 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1950 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2054 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1951 { |
2055 EXPECT_STREQ("ISAC", gcodec.plname); | 1952 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2056 EXPECT_FALSE(voe_.GetVAD(channel_num)); | 1953 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
| 1954 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 1955 } |
2057 } | 1956 } |
2058 | 1957 |
2059 // Test that we perform case-insensitive matching of codec names. | 1958 // Test that we perform case-insensitive matching of codec names. |
2060 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1959 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
2061 EXPECT_TRUE(SetupSendStream()); | 1960 EXPECT_TRUE(SetupSendStream()); |
2062 int channel_num = voe_.GetLastChannel(); | |
2063 cricket::AudioSendParameters parameters; | 1961 cricket::AudioSendParameters parameters; |
2064 parameters.codecs.push_back(kIsacCodec); | 1962 parameters.codecs.push_back(kIsacCodec); |
2065 parameters.codecs.push_back(kPcmuCodec); | 1963 parameters.codecs.push_back(kPcmuCodec); |
2066 parameters.codecs.push_back(kCn16000Codec); | 1964 parameters.codecs.push_back(kCn16000Codec); |
2067 parameters.codecs.push_back(kCn8000Codec); | 1965 parameters.codecs.push_back(kCn8000Codec); |
2068 parameters.codecs.push_back(kTelephoneEventCodec); | 1966 parameters.codecs.push_back(kTelephoneEventCodec); |
2069 parameters.codecs[0].name = "iSaC"; | 1967 parameters.codecs[0].name = "iSaC"; |
2070 parameters.codecs[0].id = 96; | 1968 parameters.codecs[0].id = 96; |
2071 parameters.codecs[2].id = 97; // wideband CN | 1969 parameters.codecs[2].id = 97; // wideband CN |
2072 parameters.codecs[4].id = 98; // DTMF | 1970 parameters.codecs[4].id = 98; // DTMF |
2073 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1971 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2074 webrtc::CodecInst gcodec; | 1972 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2075 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1973 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
2076 EXPECT_EQ(96, gcodec.pltype); | 1974 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
2077 EXPECT_STREQ("ISAC", gcodec.plname); | 1975 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
2078 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1976 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
2079 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | 1977 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2080 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 1978 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2081 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1979 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2082 } | 1980 } |
2083 | 1981 |
2084 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { | 1982 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
2085 public: | 1983 public: |
2086 WebRtcVoiceEngineWithSendSideBweTest() | 1984 WebRtcVoiceEngineWithSendSideBweTest() |
2087 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} | 1985 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
2088 }; | 1986 }; |
2089 | 1987 |
2090 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, | 1988 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2223 } | 2121 } |
2224 | 2122 |
2225 cricket::AudioSendParameters parameters; | 2123 cricket::AudioSendParameters parameters; |
2226 // Set ISAC(16K) and CN(16K). VAD should be activated. | 2124 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2227 parameters.codecs.push_back(kIsacCodec); | 2125 parameters.codecs.push_back(kIsacCodec); |
2228 parameters.codecs.push_back(kCn16000Codec); | 2126 parameters.codecs.push_back(kCn16000Codec); |
2229 parameters.codecs[1].id = 97; | 2127 parameters.codecs[1].id = 97; |
2230 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2128 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2231 | 2129 |
2232 // Verify ISAC and VAD are corrected configured on all send channels. | 2130 // Verify ISAC and VAD are corrected configured on all send channels. |
2233 webrtc::CodecInst gcodec; | |
2234 for (uint32_t ssrc : kSsrcs4) { | 2131 for (uint32_t ssrc : kSsrcs4) { |
2235 int channel_num = GetSendStreamConfig(ssrc).voe_channel_id; | 2132 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2236 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 2133 const auto& send_codec_spec = |
2237 EXPECT_STREQ("ISAC", gcodec.plname); | 2134 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2238 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 2135 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
2239 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 2136 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 2137 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
| 2138 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
| 2139 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2240 } | 2140 } |
2241 | 2141 |
2242 // Change to PCMU(8K) and CN(16K). VAD should not be activated. | 2142 // Change to PCMU(8K) and CN(16K). |
2243 parameters.codecs[0] = kPcmuCodec; | 2143 parameters.codecs[0] = kPcmuCodec; |
2244 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2144 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2245 for (uint32_t ssrc : kSsrcs4) { | 2145 for (uint32_t ssrc : kSsrcs4) { |
2246 int channel_num = GetSendStreamConfig(ssrc).voe_channel_id; | 2146 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2247 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 2147 const auto& send_codec_spec = |
2248 EXPECT_STREQ("PCMU", gcodec.plname); | 2148 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2249 EXPECT_FALSE(voe_.GetVAD(channel_num)); | 2149 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
| 2150 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
| 2151 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
| 2152 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2250 } | 2153 } |
2251 } | 2154 } |
2252 | 2155 |
2253 // Test we can SetSend on all send streams correctly. | 2156 // Test we can SetSend on all send streams correctly. |
2254 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 2157 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2255 SetupForMultiSendStream(); | 2158 SetupForMultiSendStream(); |
2256 | 2159 |
2257 // Create the send channels and they should be a "not sending" date. | 2160 // Create the send channels and they should be a "not sending" date. |
2258 for (uint32_t ssrc : kSsrcs4) { | 2161 for (uint32_t ssrc : kSsrcs4) { |
2259 EXPECT_TRUE(channel_->AddSendStream( | 2162 EXPECT_TRUE(channel_->AddSendStream( |
(...skipping 1256 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3516 nullptr, webrtc::CreateBuiltinAudioDecoderFactory()); | 3419 nullptr, webrtc::CreateBuiltinAudioDecoderFactory()); |
3517 webrtc::RtcEventLogNullImpl event_log; | 3420 webrtc::RtcEventLogNullImpl event_log; |
3518 std::unique_ptr<webrtc::Call> call( | 3421 std::unique_ptr<webrtc::Call> call( |
3519 webrtc::Call::Create(webrtc::Call::Config(&event_log))); | 3422 webrtc::Call::Create(webrtc::Call::Config(&event_log))); |
3520 cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(), | 3423 cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(), |
3521 cricket::AudioOptions(), call.get()); | 3424 cricket::AudioOptions(), call.get()); |
3522 cricket::AudioRecvParameters parameters; | 3425 cricket::AudioRecvParameters parameters; |
3523 parameters.codecs = engine.recv_codecs(); | 3426 parameters.codecs = engine.recv_codecs(); |
3524 EXPECT_TRUE(channel.SetRecvParameters(parameters)); | 3427 EXPECT_TRUE(channel.SetRecvParameters(parameters)); |
3525 } | 3428 } |
OLD | NEW |