Remove old AcmReceiver::AddCodec overload

webrtc/modules/audio_coding/acm2/acm_receiver_unittest.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 #include "webrtc/modules/audio_coding/acm2/acm_receiver.h"
 
 #include <algorithm>  // std::min
 #include <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/safe_conversions.h"
+#include "webrtc/modules/audio_coding/codecs/audio_format_conversion.h"
 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 namespace webrtc {
 
@@ skipping 84 matching lines @@
       timestamp_ += frame.samples_per_channel_;
       ASSERT_GE(acm_->Add10MsData(frame), 0);
     }
   }
 
   template <size_t N>
   void AddSetOfCodecs(const RentACodec::CodecId(&ids)[N]) {
     for (auto id : ids) {
       const auto i = RentACodec::CodecIndexFromId(id);
       ASSERT_TRUE(i);
-      ASSERT_EQ(0, receiver_->AddCodec(*i, codecs_[*i].pltype,
-                                       codecs_[*i].channels, codecs_[*i].plfreq,
-                                       nullptr, codecs_[*i].plname));
+      ASSERT_EQ(true, receiver_->AddCodec(codecs_[*i].pltype,
+                                          CodecInstToSdp(codecs_[*i])));
     }
   }
 
   int SendData(FrameType frame_type,
                uint8_t payload_type,
                uint32_t timestamp,
                const uint8_t* payload_data,
                size_t payload_len_bytes,
                const RTPFragmentationHeader* fragmentation) override {
     if (frame_type == kEmptyFrame)
@@ skipping 33 matching lines @@
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_AddCodecGetCodec DISABLED_AddCodecGetCodec
 #else
 #define MAYBE_AddCodecGetCodec AddCodecGetCodec
 #endif
 TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecGetCodec) {
   // Add codec.
   for (size_t n = 0; n < codecs_.size(); ++n) {
     if (n & 0x1) {  // Just add codecs with odd index.
-      EXPECT_EQ(
-          0, receiver_->AddCodec(n, codecs_[n].pltype, codecs_[n].channels,
-                                 codecs_[n].plfreq, NULL, codecs_[n].plname));
+      EXPECT_EQ(true, receiver_->AddCodec(codecs_[n].pltype,
+                                          CodecInstToSdp(codecs_[n])));
     }
   }
   // Get codec and compare.
   for (size_t n = 0; n < codecs_.size(); ++n) {
     CodecInst my_codec;
     if (n & 0x1) {
       // Codecs with odd index should match the reference.
       EXPECT_EQ(0, receiver_->DecoderByPayloadType(codecs_[n].pltype,
                                                    &my_codec));
       EXPECT_TRUE(CodecsEqual(codecs_[n], my_codec));
@@ skipping 10 matching lines @@
 #else
 #define MAYBE_AddCodecChangePayloadType AddCodecChangePayloadType
 #endif
 TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecChangePayloadType) {
   const CodecIdInst codec1(RentACodec::CodecId::kPCMA);
   CodecInst codec2 = codec1.inst;
   ++codec2.pltype;
   CodecInst test_codec;
 
   // Register the same codec with different payloads.
-  EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec1.inst.pltype,
-                                   codec1.inst.channels, codec1.inst.plfreq,
-                                   nullptr, codec1.inst.plname));
-  EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec2.pltype, codec2.channels,
-                                   codec2.plfreq, NULL, codec2.plname));
+  EXPECT_EQ(true, receiver_->AddCodec(codec1.inst.pltype,
+                                      CodecInstToSdp(codec1.inst)));
+  EXPECT_EQ(true, receiver_->AddCodec(codec2.pltype, CodecInstToSdp(codec2)));
 
   // Both payload types should exist.
   EXPECT_EQ(0,
             receiver_->DecoderByPayloadType(codec1.inst.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec1.inst, test_codec));
   EXPECT_EQ(0, receiver_->DecoderByPayloadType(codec2.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec2, test_codec));
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_AddCodecChangeCodecId DISABLED_AddCodecChangeCodecId
 #else
 #define MAYBE_AddCodecChangeCodecId AddCodecChangeCodecId
 #endif
 TEST_F(AcmReceiverTestOldApi, AddCodecChangeCodecId) {
   const CodecIdInst codec1(RentACodec::CodecId::kPCMU);
   CodecIdInst codec2(RentACodec::CodecId::kPCMA);
   codec2.inst.pltype = codec1.inst.pltype;
   CodecInst test_codec;
 
-  // Register the same payload type with different codec ID.
-  EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec1.inst.pltype,
-                                   codec1.inst.channels, codec1.inst.plfreq,
-                                   nullptr, codec1.inst.plname));
-  EXPECT_EQ(0, receiver_->AddCodec(codec2.id, codec2.inst.pltype,
-                                   codec2.inst.channels, codec2.inst.plfreq,
-                                   nullptr, codec2.inst.plname));
+  // Register the same payload type with different codec.
+  EXPECT_EQ(true, receiver_->AddCodec(codec1.inst.pltype,
+                                      CodecInstToSdp(codec1.inst)));
+  EXPECT_EQ(true, receiver_->AddCodec(codec2.inst.pltype,
+                                      CodecInstToSdp(codec2.inst)));
 
   // Make sure that the last codec is used.
   EXPECT_EQ(0,
             receiver_->DecoderByPayloadType(codec2.inst.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec2.inst, test_codec));
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_AddCodecRemoveCodec DISABLED_AddCodecRemoveCodec
 #else
 #define MAYBE_AddCodecRemoveCodec AddCodecRemoveCodec
 #endif
 TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecRemoveCodec) {
   const CodecIdInst codec(RentACodec::CodecId::kPCMA);
   const int payload_type = codec.inst.pltype;
-  EXPECT_EQ(
-      0, receiver_->AddCodec(codec.id, codec.inst.pltype, codec.inst.channels,
-                             codec.inst.plfreq, nullptr, codec.inst.plname));
+  EXPECT_EQ(true,
+            receiver_->AddCodec(codec.inst.pltype, CodecInstToSdp(codec.inst)));
 
   // Remove non-existing codec should not fail. ACM1 legacy.
   EXPECT_EQ(0, receiver_->RemoveCodec(payload_type + 1));
 
   // Remove an existing codec.
   EXPECT_EQ(0, receiver_->RemoveCodec(payload_type));
 
   // Ask for the removed codec, must fail.
   CodecInst ci;
   EXPECT_EQ(-1, receiver_->DecoderByPayloadType(payload_type, &ci));
@@ skipping 108 matching lines @@
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_PostdecodingVad DISABLED_PostdecodingVad
 #else
 #define MAYBE_PostdecodingVad PostdecodingVad
 #endif
 TEST_F(AcmReceiverTestOldApi, MAYBE_PostdecodingVad) {
   EXPECT_TRUE(config_.neteq_config.enable_post_decode_vad);
   const CodecIdInst codec(RentACodec::CodecId::kPCM16Bwb);
-  ASSERT_EQ(
-      0, receiver_->AddCodec(codec.id, codec.inst.pltype, codec.inst.channels,
-                             codec.inst.plfreq, nullptr, ""));
+  ASSERT_EQ(true,
+            receiver_->AddCodec(codec.inst.pltype, CodecInstToSdp(codec.inst)));
   const int kNumPackets = 5;
   const int num_10ms_frames = codec.inst.pacsize / (codec.inst.plfreq / 100);
   AudioFrame frame;
   for (int n = 0; n < kNumPackets; ++n) {
     InsertOnePacketOfSilence(codec.id);
     for (int k = 0; k < num_10ms_frames; ++k) {
       bool muted;
       ASSERT_EQ(0, receiver_->GetAudio(codec.inst.plfreq, &frame, &muted));
     }
   }
   EXPECT_EQ(AudioFrame::kVadPassive, frame.vad_activity_);
 }
 
 class AcmReceiverTestPostDecodeVadPassiveOldApi : public AcmReceiverTestOldApi {
  protected:
   AcmReceiverTestPostDecodeVadPassiveOldApi() {
     config_.neteq_config.enable_post_decode_vad = false;
   }
 };
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_PostdecodingVad DISABLED_PostdecodingVad
 #else
 #define MAYBE_PostdecodingVad PostdecodingVad
 #endif
 TEST_F(AcmReceiverTestPostDecodeVadPassiveOldApi, MAYBE_PostdecodingVad) {
   EXPECT_FALSE(config_.neteq_config.enable_post_decode_vad);
   const CodecIdInst codec(RentACodec::CodecId::kPCM16Bwb);
-  ASSERT_EQ(
-      0, receiver_->AddCodec(codec.id, codec.inst.pltype, codec.inst.channels,
-                             codec.inst.plfreq, nullptr, ""));
+  ASSERT_EQ(true,
+            receiver_->AddCodec(codec.inst.pltype, CodecInstToSdp(codec.inst)));
   const int kNumPackets = 5;
   const int num_10ms_frames = codec.inst.pacsize / (codec.inst.plfreq / 100);
   AudioFrame frame;
   for (int n = 0; n < kNumPackets; ++n) {
     InsertOnePacketOfSilence(codec.id);
     for (int k = 0; k < num_10ms_frames; ++k) {
       bool muted;
       ASSERT_EQ(0, receiver_->GetAudio(codec.inst.plfreq, &frame, &muted));
     }
   }
@@ skipping 67 matching lines @@
               receiver_->last_packet_sample_rate_hz());
     EXPECT_EQ(0, receiver_->LastAudioCodec(&codec));
     EXPECT_TRUE(CodecsEqual(c.inst, codec));
   }
 }
 #endif
 
 }  // namespace acm2
 
 }  // namespace webrtc