Injectable audio encoders: WebRtcVoiceEngine and company

webrtc/media/engine/webrtcvoiceengine_unittest.cc

Index: webrtc/media/engine/webrtcvoiceengine_unittest.cc
diff --git a/webrtc/media/engine/webrtcvoiceengine_unittest.cc b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
index c97421ac7115a71fd4f1637403d830241cfff501..f39f2fdceeb4b65fe5d25877efcae53000ae146d 100644
--- a/webrtc/media/engine/webrtcvoiceengine_unittest.cc
+++ b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
@@ -37,7 +37,7 @@ namespace {
 
 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1);
 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1);
-const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2);
+const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 32000, 2);

[ossu, 2017/02/21 11:04:14]

Stereo opus is 64kbps, mono is 32kbps. This value needs to match what the codec
implementation's QueryAudioFormat says.

[kwiberg-webrtc, 2017/02/21 23:35:03]

Speculation: whoever wrote this thought that the "2" in the number of channels
field meant this was stereo. :-)

 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1);
 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1);
 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1);
@@ -305,30 +305,14 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
                       const char expected_name[],
                       int expected_channels,
                       int expected_bitrate) {
-    const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst;
-    EXPECT_STREQ(expected_name, codec.plname);
-    EXPECT_EQ(expected_channels, codec.channels);
-    EXPECT_EQ(expected_bitrate, codec.rate);
+    const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec;
+    EXPECT_EQ(expected_name, spec.format.format.name);
+    EXPECT_EQ(expected_channels, spec.format.info.num_channels);
+    EXPECT_EQ(expected_bitrate, spec.target_bitrate_bps);
   }
 
-  int GetOpusMaxPlaybackRate(int32_t ssrc) {
-    return GetSendStreamConfig(ssrc).send_codec_spec.opus_max_playback_rate;
-  }
-
-  bool GetOpusDtx(int32_t ssrc) {
-    return GetSendStreamConfig(ssrc).send_codec_spec.enable_opus_dtx;
-  }
-
-  bool GetCodecFec(int32_t ssrc) {
-    return GetSendStreamConfig(ssrc).send_codec_spec.enable_codec_fec;
-  }
-
-  int GetCodecBitrate(int32_t ssrc) {
-    return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.rate;
-  }
-
-  int GetCodecPacSize(int32_t ssrc) {
-    return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.pacsize;
+  rtc::Optional<int> GetCodecBitrate(int32_t ssrc) {
+    return GetSendStreamConfig(ssrc).send_codec_spec.target_bitrate_bps;
   }
 
   const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) {
@@ -662,7 +646,6 @@ TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) {
   EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
   EXPECT_EQ(48000, codecs[0].clockrate);
   EXPECT_EQ(2, codecs[0].channels);
-  EXPECT_EQ(64000, codecs[0].bitrate);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
@@ -677,46 +660,6 @@ TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
   EXPECT_TRUE(opus_found);
 }
 
-// Tests that we can find codecs by name or id, and that we interpret the

[ossu, 2017/02/21 11:04:14]

These are just removed because the underlying functionality is/should be removed
as well.

-// clockrate and bitrate fields properly.
-TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
-  cricket::AudioCodec codec;
-  webrtc::CodecInst codec_inst;
-  // Find PCMU with explicit clockrate and bitrate.
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst));
-  // Find ISAC with explicit clockrate and 0 bitrate.
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst));
-  // Find telephone-event with explicit clockrate and 0 bitrate.
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec1,
-                                                      &codec_inst));
-  // Find telephone-event with explicit clockrate and 0 bitrate.
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec2,
-                                                      &codec_inst));
-  // Find ISAC with a different payload id.
-  codec = kIsacCodec;
-  codec.id = 127;
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
-  EXPECT_EQ(codec.id, codec_inst.pltype);
-  // Find PCMU with a 0 clockrate.
-  codec = kPcmuCodec;
-  codec.clockrate = 0;
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
-  EXPECT_EQ(codec.id, codec_inst.pltype);
-  EXPECT_EQ(8000, codec_inst.plfreq);
-  // Find PCMU with a 0 bitrate.
-  codec = kPcmuCodec;
-  codec.bitrate = 0;
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
-  EXPECT_EQ(codec.id, codec_inst.pltype);
-  EXPECT_EQ(64000, codec_inst.rate);
-  // Find ISAC with an explicit bitrate.
-  codec = kIsacCodec;
-  codec.bitrate = 32000;
-  EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
-  EXPECT_EQ(codec.id, codec_inst.pltype);
-  EXPECT_EQ(32000, codec_inst.rate);
-}
-
 // Test that we set our inbound codecs properly, including changing PT.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
   EXPECT_TRUE(SetupChannel());
@@ -927,20 +870,17 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
   // PCMU, default bitrate == 64000.
   TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000);
 
-  // opus, default bitrate == 64000.
-  TestMaxSendBandwidth(kOpusCodec, -1, true, 64000);
+  // opus, default bitrate == 32000 in mono.
+  TestMaxSendBandwidth(kOpusCodec, -1, true, 32000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
   EXPECT_TRUE(SetupSendStream());
 
-  // Test that the bitrate of a multi-rate codec is always the maximum.
-
   // ISAC, default bitrate == 32000.
-  TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000);
   TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000);
   // Rates above the max (56000) should be capped.
-  TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000);
+  TestMaxSendBandwidth(kIsacCodec, 100000, true, 32000);

[kwiberg-webrtc, 2017/02/21 23:35:03]

Why did this change?

 
   // opus, default bitrate == 64000.
   TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000);
@@ -1003,8 +943,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) {
   EXPECT_TRUE(SetupSendStream());
 
-  // opus, default bitrate == 64000.
-  SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000);
+  // opus, default bitrate == 32000.
+  SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000);
   SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000);
   SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000);
   SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000);
@@ -1089,21 +1029,21 @@ TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
   // Configure one stream to be limited by the stream config, another to be
   // limited by the global max, and the third one with no per-stream limit
   // (still subject to the global limit).
-  SetGlobalMaxBitrate(kOpusCodec, 64000);
-  EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000));
-  EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000));
+  SetGlobalMaxBitrate(kOpusCodec, 32000);
+  EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000));
+  EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1));
 
-  EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
+  EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0]));
+  EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1]));
+  EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2]));
 
   // Remove the global cap; the streams should switch to their respective
   // maximums (or remain unchanged if there was no other limit on them.)
   SetGlobalMaxBitrate(kOpusCodec, -1);
-  EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
-  EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
+  EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0]));
+  EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1]));
+  EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2]));
 }
 
 // Test that GetRtpSendParameters returns the currently configured codecs.
@@ -1203,10 +1143,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   SetSendParameters(parameters);
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
   const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
-  EXPECT_EQ(48000, send_codec_spec.codec_inst.rate);
-  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-  EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  //  EXPECT_EQ(48000, send_codec_spec.codec_inst.rate);
+  EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+  EXPECT_NE(send_codec_spec.format.format.clockrate_hz,
+            send_codec_spec.cng_plfreq);
   EXPECT_EQ(13, send_codec_spec.cng_payload_type);
   EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   EXPECT_FALSE(channel_->CanInsertDtmf());
@@ -1231,17 +1172,9 @@ TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
 }
 
-// Verify that G722 is set with 16000 samples per second to WebRTC.

[ossu, 2017/02/21 11:04:15]

The clock rate <-> sample rate functionality is now moved into the codecs, so
shouldn't be tested here. I believe the implementation in AudioEncoderG722 is
trivial enough it might not need a separate test even there.

[kwiberg-webrtc, 2017/02/21 23:35:03]

Acknowledged.

-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kG722CodecSdp);
-  SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-  EXPECT_STREQ("G722", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(16000, gcodec.plfreq);
-}
+// TODO(ossu): Move these tests into tests for Audio{Encoder,Decoder}Opus or,
+// possibly, BuiltinAudio{Encoder,Decoder}Factory; this depends on where we move
+// validation.
 
 // Test that if clockrate is not 48000 for opus, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
@@ -1383,12 +1316,13 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 96000;
   SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-  EXPECT_EQ(111, gcodec.pltype);
-  EXPECT_EQ(96000, gcodec.rate);
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(48000, gcodec.plfreq);
+  const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  EXPECT_EQ(111, spec.payload_type);
+  EXPECT_EQ(96000, spec.target_bitrate_bps);
+  EXPECT_EQ("opus", spec.format.format.name);
+  EXPECT_EQ(1, spec.format.info.num_channels);
+  EXPECT_EQ(48000, spec.format.info.sample_rate_hz);
+  EXPECT_EQ(48000, spec.format.format.clockrate_hz);
 }
 
 // Test that with bitrate=N and stereo=0,
@@ -1426,29 +1360,6 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
   CheckSendCodec(kSsrc1, "opus", 2, 30000);
 }
 
-// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.

[ossu, 2017/02/21 11:04:14]

Moved into AudioEncoderOpus unit tests.

-// Also test that the "maxaveragebitrate" can't be set to values outside the
-// range of 6000 and 510000
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 30000;
-  // Ignore if less than 6000.
-  parameters.codecs[0].params["maxaveragebitrate"] = "5999";
-  SetSendParameters(parameters);
-  EXPECT_EQ(6000, GetCodecBitrate(kSsrc1));
-
-  // Ignore if larger than 510000.
-  parameters.codecs[0].params["maxaveragebitrate"] = "510001";
-  SetSendParameters(parameters);
-  EXPECT_EQ(510000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].params["maxaveragebitrate"] = "200000";
-  SetSendParameters(parameters);
-  EXPECT_EQ(200000, GetCodecBitrate(kSsrc1));
-}
-
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
                                      200000);
@@ -1582,83 +1493,6 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms);
 }
 
-// Test that without useinbandfec, Opus FEC is off.

[ossu, 2017/02/21 11:04:14]

These are all moved into AudioEncoderOpus unit tests or, in the case of the
Isac-related tests, completely removed, since there's no FEC to set or test for
Isac.

-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
-}
-
-// Test that with useinbandfec=0, Opus FEC is off.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].params["useinbandfec"] = "0";
-  SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
-}
-
-// Test that with useinbandfec=1, Opus FEC is on.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].params["useinbandfec"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
-}
-
-// Test that with useinbandfec=1, stereo=1, Opus FEC is on.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].params["stereo"] = "1";
-  parameters.codecs[0].params["useinbandfec"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
-  CheckSendCodec(kSsrc1, "opus", 2, 64000);
-}
-
-// Test that with non-Opus, codec FEC is off.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kIsacCodec);
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
-}
-
-// Test the with non-Opus, even if useinbandfec=1, FEC is off.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kIsacCodec);
-  parameters.codecs[0].params["useinbandfec"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
-}
-
-// Test that Opus FEC status can be changed.
-TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
-
-  parameters.codecs[0].params["useinbandfec"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
-}
-
 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
   EXPECT_TRUE(SetupChannel());
   cricket::AudioSendParameters send_parameters;
@@ -1681,162 +1515,6 @@ TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
       call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
 }
 
-// Test maxplaybackrate <= 8000 triggers Opus narrow band mode.

[ossu, 2017/02/21 11:04:14]

Moved into AudioEncoderOpus unit tests.

-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
-  SetSendParameters(parameters);
-  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(12000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  SetSendParameters(parameters);
-  EXPECT_EQ(24000, GetCodecBitrate(kSsrc1));
-}
-
-// Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
-  SetSendParameters(parameters);
-  EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(20000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  SetSendParameters(parameters);
-  EXPECT_EQ(40000, GetCodecBitrate(kSsrc1));
-}
-
-// Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
-  SetSendParameters(parameters);
-  EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(20000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  SetSendParameters(parameters);
-  EXPECT_EQ(40000, GetCodecBitrate(kSsrc1));
-}
-
-// Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
-  SetSendParameters(parameters);
-  EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(32000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  SetSendParameters(parameters);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
-}
-
-// Test 24000 < maxplaybackrate triggers Opus full band mode.
-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].bitrate = 0;
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
-  SetSendParameters(parameters);
-  EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(32000, GetCodecBitrate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  SetSendParameters(parameters);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
-}
-
-// Test Opus that without maxplaybackrate, default playback rate is used.
-TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  SetSendParameters(parameters);
-  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1));
-}
-
-// Test the with non-Opus, maxplaybackrate has no effect.
-TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kIsacCodec);
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
-  SetSendParameters(parameters);
-  EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1));
-}
-
-// Test maxplaybackrate can be set on two streams.
-TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  SetSendParameters(parameters);
-  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1));
-
-  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
-  SetSendParameters(parameters);
-  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1));
-
-  channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
-  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2));
-}
-
-// Test that with usedtx=0, Opus DTX is off.
-TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].params["usedtx"] = "0";
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetOpusDtx(kSsrc1));
-}
-
-// Test that with usedtx=1, Opus DTX is on.
-TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].params["usedtx"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_TRUE(GetOpusDtx(kSsrc1));
-}
-
-// Test that usedtx=1 works with stereo Opus.
-TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kOpusCodec);
-  parameters.codecs[0].params["usedtx"] = "1";
-  parameters.codecs[0].params["stereo"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_TRUE(GetOpusDtx(kSsrc1));
-}
-
-// Test that usedtx=1 does not work with non Opus.
-TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
-  EXPECT_TRUE(SetupSendStream());
-  cricket::AudioSendParameters parameters;
-  parameters.codecs.push_back(kIsacCodec);
-  parameters.codecs[0].params["usedtx"] = "1";
-  SetSendParameters(parameters);
-  EXPECT_FALSE(GetOpusDtx(kSsrc1));
-}
-
 // Test that we can switch back and forth between Opus and ISAC with CN.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   EXPECT_TRUE(SetupSendStream());
@@ -1845,9 +1523,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   opus_parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(opus_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(111, gcodec.pltype);
-    EXPECT_STREQ("opus", gcodec.plname);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(111, spec.payload_type);
+    EXPECT_STRCASEEQ("opus", spec.format.format.name.c_str());
   }
 
   cricket::AudioSendParameters isac_parameters;
@@ -1856,16 +1534,16 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   isac_parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(isac_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(103, gcodec.pltype);
-    EXPECT_STREQ("ISAC", gcodec.plname);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(103, spec.payload_type);
+    EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str());
   }
 
   SetSendParameters(opus_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(111, gcodec.pltype);
-    EXPECT_STREQ("opus", gcodec.plname);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(111, spec.payload_type);
+    EXPECT_STRCASEEQ("opus", spec.format.format.name.c_str());
   }
 }
 
@@ -1876,58 +1554,59 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs.push_back(kIsacCodec);  // bitrate == 32000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(103, gcodec.pltype);
-    EXPECT_STREQ("ISAC", gcodec.plname);
-    EXPECT_EQ(32000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(103, spec.payload_type);
+    EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str());
+    EXPECT_EQ(32000, spec.target_bitrate_bps);
   }
 
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(103, gcodec.pltype);
-    EXPECT_STREQ("ISAC", gcodec.plname);
-    EXPECT_EQ(32000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(103, spec.payload_type);
+    EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str());
+    EXPECT_EQ(32000, spec.target_bitrate_bps);
   }
   parameters.codecs[0].bitrate = 28000;     // bitrate == 28000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(103, gcodec.pltype);
-    EXPECT_STREQ("ISAC", gcodec.plname);
-    EXPECT_EQ(28000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(103, spec.payload_type);
+    EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str());
+    EXPECT_EQ(28000, spec.target_bitrate_bps);
   }
 
   parameters.codecs[0] = kPcmuCodec;        // bitrate == 64000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(0, gcodec.pltype);
-    EXPECT_STREQ("PCMU", gcodec.plname);
-    EXPECT_EQ(64000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(0, spec.payload_type);
+    EXPECT_STRCASEEQ("PCMU", spec.format.format.name.c_str());
+    EXPECT_EQ(64000, spec.target_bitrate_bps);
   }
 
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(0, gcodec.pltype);
-    EXPECT_STREQ("PCMU", gcodec.plname);
-    EXPECT_EQ(64000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(0, spec.payload_type);
+    EXPECT_STREQ("PCMU", spec.format.format.name.c_str());
+    EXPECT_EQ(64000, spec.target_bitrate_bps);
   }
 
   parameters.codecs[0] = kOpusCodec;
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-    EXPECT_EQ(111, gcodec.pltype);
-    EXPECT_STREQ("opus", gcodec.plname);
-    EXPECT_EQ(32000, gcodec.rate);
+    const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    EXPECT_EQ(111, spec.payload_type);
+    EXPECT_STREQ("opus", spec.format.format.name.c_str());
+    EXPECT_EQ(32000, spec.target_bitrate_bps);
   }
 }
 
+#if 0

[ossu, 2017/02/22 10:24:23]

I think these should be removed. The encoders that support setting packet times
should have their own tests for it.

[kwiberg-webrtc, 2017/02/22 10:42:06]

Acknowledged.

 // Test that we could set packet size specified in kCodecParamPTime.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
   EXPECT_TRUE(SetupSendStream());
@@ -1957,6 +1636,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
   EXPECT_EQ(640, GetCodecPacSize(
                      kSsrc1));  // G722 gets 40ms @16kHz as defined in VoE.
 }
+#endif
 
 // Test that we fail if no codecs are specified.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
@@ -1976,9 +1656,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
   parameters.codecs[0].id = 98;  // DTMF
   parameters.codecs[1].id = 96;
   SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_STREQ("ISAC", gcodec.plname);
+  const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  EXPECT_EQ(96, spec.payload_type);
+  EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str());
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
@@ -2015,8 +1695,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   parameters.codecs[1].id = 96;
   SetSendParameters(parameters);
   const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
-  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
   EXPECT_EQ(98, send_codec_spec.cng_payload_type);
   EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
 }
@@ -2036,10 +1716,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
   const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
-  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
-  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
+  EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+            send_codec_spec.cng_plfreq);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -2063,10 +1744,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
       cricket::StreamParams::CreateLegacy(kSsrc1)));
 
   const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
-  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
-  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
+  EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+            send_codec_spec.cng_plfreq);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -2084,9 +1766,10 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   SetSendParameters(parameters);
   {
     const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-    EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-    EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
-    EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+    EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
+    EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
     EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
@@ -2095,17 +1778,19 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   SetSendParameters(parameters);
   {
     const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-    EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
-    EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str());
+    EXPECT_NE(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
   }
   // Set PCMU(8K) and CN(8K). VAD should be activated.
   parameters.codecs[1] = kCn8000Codec;
   SetSendParameters(parameters);
   {
     const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-    EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
-    EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
-    EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str());
+    EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
+    EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
     EXPECT_EQ(13, send_codec_spec.cng_payload_type);
     EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   }
@@ -2114,8 +1799,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   SetSendParameters(parameters);
   {
     const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-    EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-    EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+    EXPECT_NE(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
   }
 }
 
@@ -2134,10 +1820,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
   const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
-  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
-  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
-  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(96, send_codec_spec.payload_type);
+  EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
+  EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+            send_codec_spec.cng_plfreq);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -2298,9 +1985,10 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
     ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
     const auto& send_codec_spec =
         call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
-    EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
-    EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
-    EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+    EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str());
+    EXPECT_EQ(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
+    EXPECT_EQ(1, send_codec_spec.format.info.num_channels);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
     EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
@@ -2312,8 +2000,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
     ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
     const auto& send_codec_spec =
         call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
-    EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
-    EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str());
+    EXPECT_NE(send_codec_spec.format.format.clockrate_hz,
+              send_codec_spec.cng_plfreq);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
     EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
@@ -3615,28 +3304,32 @@ TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
   cricket::WebRtcVoiceEngine engine(
       nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr);
   for (const cricket::AudioCodec& codec : engine.send_codecs()) {
-    if (codec.name == "CN" && codec.clockrate == 16000) {
+    auto is_codec = [&codec](const char* name, int clockrate = 0) {
+      return STR_CASE_CMP(codec.name.c_str(), name) == 0 &&
+             (clockrate == 0 || codec.clockrate == clockrate);
+    };
+    if (is_codec("CN", 16000)) {
       EXPECT_EQ(105, codec.id);
-    } else if (codec.name == "CN" && codec.clockrate == 32000) {
+    } else if (is_codec("CN", 32000)) {
       EXPECT_EQ(106, codec.id);
-    } else if (codec.name == "ISAC" && codec.clockrate == 16000) {
+    } else if (is_codec("ISAC", 16000)) {
       EXPECT_EQ(103, codec.id);
-    } else if (codec.name == "ISAC" && codec.clockrate == 32000) {
+    } else if (is_codec("ISAC", 32000)) {
       EXPECT_EQ(104, codec.id);
-    } else if (codec.name == "G722" && codec.clockrate == 8000) {
+    } else if (is_codec("G722", 8000)) {
       EXPECT_EQ(9, codec.id);
-    } else if (codec.name == "telephone-event" && codec.clockrate == 8000) {
+    } else if (is_codec("telephone-event", 8000)) {
       EXPECT_EQ(126, codec.id);
     // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned.
     // Remove these checks once both send and receive side assigns payload types
     // dynamically.
-    } else if (codec.name == "telephone-event" && codec.clockrate == 16000) {
+    } else if (is_codec("telephone-event", 16000)) {
       EXPECT_EQ(113, codec.id);
-    } else if (codec.name == "telephone-event" && codec.clockrate == 32000) {
+    } else if (is_codec("telephone-event", 32000)) {
       EXPECT_EQ(112, codec.id);
-    } else if (codec.name == "telephone-event" && codec.clockrate == 48000) {
+    } else if (is_codec("telephone-event", 48000)) {
       EXPECT_EQ(110, codec.id);
-    } else if (codec.name == "opus") {
+    } else if (is_codec("opus")) {
       EXPECT_EQ(111, codec.id);
       ASSERT_TRUE(codec.params.find("minptime") != codec.params.end());
       EXPECT_EQ("10", codec.params.find("minptime")->second);