Injectable audio encoders: WebRtcVoiceEngine and company

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 19 matching lines @@
 #include "webrtc/pc/channel.h"
 #include "webrtc/test/field_trial.h"
 
 using testing::Return;
 using testing::StrictMock;
 
 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);
 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);
 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1);
 const cricket::AudioCodec
     kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1);
 const cricket::AudioCodec
     kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1);
 
 const uint32_t kSsrc1 = 0x99;
@@ skipping 243 matching lines @@
     return channel_->SetRtpSendParameters(ssrc, parameters);
   }
 
   void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
     cricket::AudioSendParameters send_parameters;
     send_parameters.codecs.push_back(codec);
     send_parameters.max_bandwidth_bps = bitrate;
     SetSendParameters(send_parameters);
   }
 
-  void CheckSendCodec(int32_t ssrc,
-                      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);
+  void CheckSendCodecBitrate(int32_t ssrc,
+                             const char expected_name[],
+                             int expected_bitrate) {
+    const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec;
+    EXPECT_EQ(expected_name, spec.format.name);
+    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) {
     return GetSendStreamConfig(ssrc).audio_network_adaptor_config;
   }
 
   void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
                               int global_max,
                               int stream_max,
                               bool expected_result,
@@ skipping 313 matching lines @@
 // Tests that the list of supported codecs is created properly and ordered
 // correctly (such that opus appears first).
 // TODO(ossu): This test should move into a separate builtin audio codecs
 // module.
 TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) {
   const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
   ASSERT_FALSE(codecs.empty());
   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) {
   const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
   bool opus_found = false;
   for (cricket::AudioCodec codec : codecs) {
     if (codec.name == "opus") {
       EXPECT_TRUE(HasTransportCc(codec));
       opus_found = true;
     }
   }
   EXPECT_TRUE(opus_found);
 }
 
-// Tests that we can find codecs by name or id, and that we interpret the
-// 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());
   cricket::AudioRecvParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kTelephoneEventCodec1);
   parameters.codecs.push_back(kTelephoneEventCodec2);
   parameters.codecs[0].id = 106;  // collide with existing CN 32k
   parameters.codecs[2].id = 126;
@@ skipping 190 matching lines @@
   // Test that when autobw is enabled, bitrate is kept as the default
   // value. autobw is enabled for the following tests because the target
   // bitrate is <= 0.
 
   // ISAC, default bitrate == 32000.
   TestMaxSendBandwidth(kIsacCodec, 0, true, 32000);
 
   // 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);
 
   // opus, default bitrate == 64000.
   TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000);
   TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000);
   // Rates above the max (510000) should be capped.
   TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
   EXPECT_TRUE(SetupSendStream());
@@ skipping 42 matching lines @@
   send_parameters_.max_bandwidth_bps = 128;
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
 }
 
 // Test that the per-stream bitrate limit and the global
 // bitrate limit both apply.
 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);
 
   // CBR codecs allow both maximums to exceed the bitrate.
   SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000);
   SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000);
   SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000);
   SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000);
 
@@ skipping 64 matching lines @@
 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
   SetupForMultiSendStream();
   // Create send streams.
   for (uint32_t ssrc : kSsrcs4) {
     EXPECT_TRUE(
         channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc)));
   }
   // 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.
 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   SetSendParameters(parameters);
 
@@ skipping 79 matching lines @@
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs[0].id = 96;
   parameters.codecs[0].bitrate = 48000;
   const int initial_num = call_.GetNumCreatedSendStreams();
   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(13, send_codec_spec.cng_payload_type);
-  EXPECT_EQ(webrtc::kFreq8000Hz, 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.name.c_str());
+  EXPECT_NE(send_codec_spec.format.clockrate_hz,
+            8000);
+  EXPECT_EQ(-1, send_codec_spec.cng_payload_type);
+  //  EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   EXPECT_FALSE(channel_->CanInsertDtmf());
 }
 
 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
 // to apply.
 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs[0].id = 96;
   parameters.codecs[0].bitrate = 48000;
   const int initial_num = call_.GetNumCreatedSendStreams();
   SetSendParameters(parameters);
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
   // Calling SetSendCodec again with same codec which is already set.
   // In this case media channel shouldn't send codec to VoE.
   SetSendParameters(parameters);
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
 }
 
-// Verify that G722 is set with 16000 samples per second to WebRTC.
-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) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].clockrate = 50000;
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
@@ skipping 44 matching lines @@
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].channels = 1;
   parameters.codecs[0].params["stereo"] = "1";
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
-// Test that with bitrate=0 and no stereo,
-// channels and bitrate are 1 and 32000.
+// Test that with bitrate=0 and no stereo, bitrate is 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 32000);
 }
 
-// Test that with bitrate=0 and stereo=0,
-// channels and bitrate are 1 and 32000.
+// Test that with bitrate=0 and stereo=0, bitrate is 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "0";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 32000);
 }
 
-// Test that with bitrate=invalid and stereo=0,
-// channels and bitrate are 1 and 32000.
+// Test that with bitrate=invalid and stereo=0, bitrate is 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["stereo"] = "0";
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 6000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 6000);
 
   parameters.codecs[0].bitrate = 510001;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 510000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 510000);
 }
 
-// Test that with bitrate=0 and stereo=1,
-// channels and bitrate are 2 and 64000.
+// Test that with bitrate=0 and stereo=1, bitrate is 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "1";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 64000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 64000);
 }
 
-// Test that with bitrate=invalid and stereo=1,
-// channels and bitrate are 2 and 64000.
+// Test that with bitrate=invalid and stereo=1, bitrate is 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["stereo"] = "1";
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 6000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 6000);
 
   parameters.codecs[0].bitrate = 510001;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 510000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 510000);
 }
 
-// Test that with bitrate=N and stereo unset,
-// channels and bitrate are 1 and N.
+// Test that with bitrate=N and stereo unset, bitrate is N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   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.name);
+  EXPECT_EQ(2, spec.format.num_channels);
+  EXPECT_EQ(48000, spec.format.clockrate_hz);
 }
 
-// Test that with bitrate=N and stereo=0,
-// channels and bitrate are 1 and N.
+// Test that with bitrate=N and stereo=0, bitrate is N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "0";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 30000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 30000);
 }
 
-// Test that with bitrate=N and without any parameters,
-// channels and bitrate are 1 and N.
+// Test that with bitrate=N and without any parameters, bitrate is N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 30000);
+  CheckSendCodecBitrate(kSsrc1, "opus", 30000);
 }
 
-// Test that with bitrate=N and stereo=1,
-// channels and bitrate are 2 and N.
+// Test that with bitrate=N and stereo=1, bitrate is N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "1";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 30000);
-}
-
-// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
-// 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));
+  CheckSendCodecBitrate(kSsrc1, "opus", 30000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
                                      200000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) {
   SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
 }
@@ skipping 115 matching lines @@
                              cricket::kParamValueEmpty));
   SetSendParameters(parameters);
   EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
 
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
   EXPECT_TRUE(AddRecvStream(kSsrc3));
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms);
 }
 
-// Test that without useinbandfec, Opus FEC is off.
-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;
   send_parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
   SetSendParameters(send_parameters);
 
   cricket::AudioRecvParameters recv_parameters;
   recv_parameters.codecs.push_back(kIsacCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
   EXPECT_TRUE(AddRecvStream(kSsrc1));
   ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
   EXPECT_FALSE(
       call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
 
   send_parameters.codecs = engine_->send_codecs();
   SetSendParameters(send_parameters);
   ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
   EXPECT_TRUE(
       call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
 }
 
-// Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
-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());
 
   cricket::AudioSendParameters opus_parameters;
   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.name.c_str());
   }
 
   cricket::AudioSendParameters isac_parameters;
   isac_parameters.codecs.push_back(kIsacCodec);
   isac_parameters.codecs.push_back(kCn16000Codec);
   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.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.name.c_str());
   }
 }
 
 // Test that we handle various ways of specifying bitrate.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   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.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.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.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.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.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.name.c_str());
+    EXPECT_EQ(32000, spec.target_bitrate_bps);
   }
 }
 
+#if 0
 // Test that we could set packet size specified in kCodecParamPTime.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   SetSendParameters(parameters);
   EXPECT_EQ(1920, GetCodecPacSize(kSsrc1));  // Opus gets 40ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range.
   SetSendParameters(parameters);
   EXPECT_EQ(480, GetCodecPacSize(kSsrc1));  // Opus gets 10ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range.
   SetSendParameters(parameters);
   EXPECT_EQ(2880, GetCodecPacSize(kSsrc1));  // Opus gets 60ms.
 
   parameters.codecs[0] = kIsacCodec;  // Also try Isac, with unsupported size.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   SetSendParameters(parameters);
   EXPECT_EQ(480, GetCodecPacSize(
                      kSsrc1));  // Isac gets 30ms as the next smallest value.
 
   parameters.codecs[0] = kG722CodecSdp;  // Try G722 @8kHz as negotiated in SDP.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40);
   SetSendParameters(parameters);
   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) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that we can set send codecs even with telephone-event codec as the first
 // one on the list.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kTelephoneEventCodec1);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   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.name.c_str());
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that payload type range is limited for telephone-event codec.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kTelephoneEventCodec2);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].id = 0;  // DTMF
@@ skipping 16 matching lines @@
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs[0].id = 98;  // wideband CN
   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.name.c_str());
   EXPECT_EQ(98, send_codec_spec.cng_payload_type);
-  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
+  //  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
 }
 
 // Test that we set VAD and DTMF types correctly as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec1);
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   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.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
-  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   EXPECT_TRUE(SetupChannel());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec2);
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
   EXPECT_TRUE(channel_->AddSendStream(
       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.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
-  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that we only apply VAD if we have a CN codec that matches the
 // send codec clockrate.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs[1].id = 97;
   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.name.c_str());
+    EXPECT_EQ(1, send_codec_spec.format.num_channels);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
-    EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
   // Set PCMU(8K) and CN(16K). VAD should not be activated.
   parameters.codecs[0] = kPcmuCodec;
   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.name.c_str());
+    EXPECT_EQ(-1, send_codec_spec.cng_payload_type);
   }
   // 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.name.c_str());
+    EXPECT_EQ(1, send_codec_spec.format.num_channels);
     EXPECT_EQ(13, send_codec_spec.cng_payload_type);
-    EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   }
   // Set ISAC(16K) and CN(8K). VAD should not be activated.
   parameters.codecs[0] = kIsacCodec;
   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.name.c_str());
+    EXPECT_EQ(-1, send_codec_spec.cng_payload_type);
   }
 }
 
 // Test that we perform case-insensitive matching of codec names.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec1);
   parameters.codecs[0].name = "iSaC";
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   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.name.c_str());
+  EXPECT_EQ(1, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
-  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
  public:
   WebRtcVoiceEngineWithSendSideBweTest()
       : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
 };
 
 TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
@@ skipping 138 matching lines @@
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs[1].id = 97;
   SetSendParameters(parameters);
 
   // Verify ISAC and VAD are corrected configured on all send channels.
   for (uint32_t ssrc : kSsrcs4) {
     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.name.c_str());
+    EXPECT_EQ(1, send_codec_spec.format.num_channels);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
-    EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
 
   // Change to PCMU(8K) and CN(16K).
   parameters.codecs[0] = kPcmuCodec;
   SetSendParameters(parameters);
   for (uint32_t ssrc : kSsrcs4) {
     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_EQ(97, send_codec_spec.cng_payload_type);
-    EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
+    EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
+    EXPECT_EQ(-1, send_codec_spec.cng_payload_type);
   }
 }
 
 // Test we can SetSend on all send streams correctly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
   // Create the send channels and they should be a "not sending" date.
   for (uint32_t ssrc : kSsrcs4) {
     EXPECT_TRUE(channel_->AddSendStream(
@@ skipping 1218 matching lines @@
     delete channel;
   }
 }
 
 // Tests that the library is configured with the codecs we want.
 TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
   // TODO(ossu): These tests should move into a future "builtin audio codecs"
   // module.
 
   // Check codecs by name.
 #ifdef WEBRTC_CODEC_OPUS

[ossu, 2017/03/20 18:19:48]

Turns out these #ifdef'ed tests never activated, because those flags aren't
defined for the test. We've got this covered in other tests now, and keeping
them here would be wrong in the long run. I've just removed them.

   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
       cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr));
 #endif
 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
       cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr));
 #endif
 #if (defined(WEBRTC_CODEC_ISAC))
   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
       cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr));
@@ skipping 40 matching lines @@
       cricket::AudioCodec(0, "", 5000, 0, 1), nullptr));
   EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
       cricket::AudioCodec(0, "", 0, 5000, 1), nullptr));
 
   // Verify the payload id of common audio codecs, including CN, ISAC, and G722.
   // TODO(ossu): Why are the payload types of codecs with non-static payload
   // type assignments checked here? It shouldn't really matter.
   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);
       ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end());
       EXPECT_EQ("1", codec.params.find("useinbandfec")->second);
     }
   }
 }
 
 // Tests that VoE supports at least 32 channels
@@ skipping 111 matching lines @@
   // Without this cast, the comparison turned unsigned and, thus, failed for -1.
   const int num_specs = static_cast<int>(specs.size());
   EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs);
   EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs);
   EXPECT_EQ(find_codec({"cn", 32000, 1}), -1);
   EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs);
 }