Pass a real audio codec pair ID to decoders that we create

Bug: webrtc:8941
Change-Id: Ic2aed2ca759eb378164f3f65465e23fd7c13a9f8
Reviewed-on: https://webrtc-review.googlesource.com/63261
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22538}
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 8a1fbed..00b745b 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -70,13 +70,12 @@
   RTC_DCHECK(audio_state);
   internal::AudioState* internal_audio_state =
       static_cast<internal::AudioState*>(audio_state);
-  return std::unique_ptr<voe::ChannelProxy>(new voe::ChannelProxy(
-      std::unique_ptr<voe::Channel>(new voe::Channel(
-              module_process_thread,
-              internal_audio_state->audio_device_module(),
-              config.jitter_buffer_max_packets,
-              config.jitter_buffer_fast_accelerate,
-              config.decoder_factory))));
+  return std::unique_ptr<voe::ChannelProxy>(
+      new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
+          module_process_thread, internal_audio_state->audio_device_module(),
+          config.jitter_buffer_max_packets,
+          config.jitter_buffer_fast_accelerate, config.decoder_factory,
+          config.codec_pair_id))));
 }
 }  // namespace
 
diff --git a/audio/channel.cc b/audio/channel.cc
index d50c161..986476c 100644
--- a/audio/channel.cc
+++ b/audio/channel.cc
@@ -557,7 +557,8 @@
               audio_device_module,
               0,
               false,
-              rtc::scoped_refptr<AudioDecoderFactory>()) {
+              rtc::scoped_refptr<AudioDecoderFactory>(),
+              rtc::nullopt) {
   RTC_DCHECK(encoder_queue);
   encoder_queue_ = encoder_queue;
 }
@@ -566,7 +567,8 @@
                  AudioDeviceModule* audio_device_module,
                  size_t jitter_buffer_max_packets,
                  bool jitter_buffer_fast_playout,
-                 rtc::scoped_refptr<AudioDecoderFactory> decoder_factory)
+                 rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
+                 rtc::Optional<AudioCodecPairId> codec_pair_id)
     : event_log_proxy_(new RtcEventLogProxy()),
       rtcp_rtt_stats_proxy_(new RtcpRttStatsProxy()),
       rtp_payload_registry_(new RTPPayloadRegistry()),
@@ -610,6 +612,7 @@
   RTC_DCHECK(audio_device_module);
   AudioCodingModule::Config acm_config;
   acm_config.decoder_factory = decoder_factory;
+  acm_config.neteq_config.codec_pair_id = codec_pair_id;
   acm_config.neteq_config.max_packets_in_buffer = jitter_buffer_max_packets;
   acm_config.neteq_config.enable_fast_accelerate = jitter_buffer_fast_playout;
   acm_config.neteq_config.enable_muted_state = true;
diff --git a/audio/channel.h b/audio/channel.h
index e59cae1..9d5bfa4 100644
--- a/audio/channel.h
+++ b/audio/channel.h
@@ -157,7 +157,8 @@
           AudioDeviceModule* audio_device_module,
           size_t jitter_buffer_max_packets,
           bool jitter_buffer_fast_playout,
-          rtc::scoped_refptr<AudioDecoderFactory> decoder_factory);
+          rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
+          rtc::Optional<AudioCodecPairId> codec_pair_id);
   virtual ~Channel();
 
   void SetSink(AudioSinkInterface* sink);
diff --git a/call/audio_receive_stream.h b/call/audio_receive_stream.h
index 9b5eef0..54a4d9b 100644
--- a/call/audio_receive_stream.h
+++ b/call/audio_receive_stream.h
@@ -111,6 +111,8 @@
     std::map<int, SdpAudioFormat> decoder_map;
 
     rtc::scoped_refptr<AudioDecoderFactory> decoder_factory;
+
+    rtc::Optional<AudioCodecPairId> codec_pair_id;
   };
 
   // Reconfigure the stream according to the Configuration.
diff --git a/media/engine/webrtcvoiceengine.cc b/media/engine/webrtcvoiceengine.cc
index 3a530ab..809ea54 100644
--- a/media/engine/webrtcvoiceengine.cc
+++ b/media/engine/webrtcvoiceengine.cc
@@ -19,6 +19,7 @@
 #include <utility>
 #include <vector>
 
+#include "api/audio_codecs/audio_codec_pair_id.h"
 #include "api/call/audio_sink.h"
 #include "media/base/audiosource.h"
 #include "media/base/mediaconstants.h"
@@ -1104,6 +1105,7 @@
       webrtc::Transport* rtcp_send_transport,
       const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory,
       const std::map<int, webrtc::SdpAudioFormat>& decoder_map,
+      rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id,
       size_t jitter_buffer_max_packets,
       bool jitter_buffer_fast_accelerate)
       : call_(call), config_() {
@@ -1121,6 +1123,7 @@
     }
     config_.decoder_factory = decoder_factory;
     config_.decoder_map = decoder_map;
+    config_.codec_pair_id = codec_pair_id;
     RecreateAudioReceiveStream();
   }
 
@@ -1850,7 +1853,7 @@
                 ssrc, receiver_reports_ssrc_, recv_transport_cc_enabled_,
                 recv_nack_enabled_, sp.stream_ids(), recv_rtp_extensions_,
                 call_, this, engine()->decoder_factory_, decoder_map_,
-                engine()->audio_jitter_buffer_max_packets_,
+                codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
                 engine()->audio_jitter_buffer_fast_accelerate_)));
   recv_streams_[ssrc]->SetPlayout(playout_);
 
diff --git a/media/engine/webrtcvoiceengine.h b/media/engine/webrtcvoiceengine.h
index fbf7953..950b72b 100644
--- a/media/engine/webrtcvoiceengine.h
+++ b/media/engine/webrtcvoiceengine.h
@@ -272,6 +272,10 @@
   rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>
       send_codec_spec_;
 
+  // TODO(kwiberg): Per-SSRC codec pair IDs?
+  const webrtc::AudioCodecPairId codec_pair_id_ =
+      webrtc::AudioCodecPairId::Create();
+
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceMediaChannel);
 };
 }  // namespace cricket
diff --git a/modules/audio_coding/neteq/decision_logic_unittest.cc b/modules/audio_coding/neteq/decision_logic_unittest.cc
index 1a7bab9..be1b854 100644
--- a/modules/audio_coding/neteq/decision_logic_unittest.cc
+++ b/modules/audio_coding/neteq/decision_logic_unittest.cc
@@ -26,7 +26,7 @@
   int fs_hz = 8000;
   int output_size_samples = fs_hz / 100;  // Samples per 10 ms.
   DecoderDatabase decoder_database(
-      new rtc::RefCountedObject<MockAudioDecoderFactory>);
+      new rtc::RefCountedObject<MockAudioDecoderFactory>, rtc::nullopt);
   TickTimer tick_timer;
   PacketBuffer packet_buffer(10, &tick_timer);
   DelayPeakDetector delay_peak_detector(&tick_timer);
diff --git a/modules/audio_coding/neteq/decoder_database.cc b/modules/audio_coding/neteq/decoder_database.cc
index 5ddaf04..7244c8d 100644
--- a/modules/audio_coding/neteq/decoder_database.cc
+++ b/modules/audio_coding/neteq/decoder_database.cc
@@ -19,36 +19,46 @@
 namespace webrtc {
 
 DecoderDatabase::DecoderDatabase(
-    const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory)
+    const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory,
+    rtc::Optional<AudioCodecPairId> codec_pair_id)
     : active_decoder_type_(-1),
       active_cng_decoder_type_(-1),
-      decoder_factory_(decoder_factory) {}
+      decoder_factory_(decoder_factory),
+      codec_pair_id_(codec_pair_id) {}
 
 DecoderDatabase::~DecoderDatabase() = default;
 
-DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
-                                          AudioDecoderFactory* factory,
-                                          const std::string& codec_name)
+DecoderDatabase::DecoderInfo::DecoderInfo(
+    const SdpAudioFormat& audio_format,
+    rtc::Optional<AudioCodecPairId> codec_pair_id,
+    AudioDecoderFactory* factory,
+    const std::string& codec_name)
     : name_(codec_name),
       audio_format_(audio_format),
+      codec_pair_id_(codec_pair_id),
       factory_(factory),
       external_decoder_(nullptr),
       cng_decoder_(CngDecoder::Create(audio_format)),
       subtype_(SubtypeFromFormat(audio_format)) {}
 
-DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
-                                          AudioDecoderFactory* factory)
-    : DecoderInfo(audio_format, factory, audio_format.name) {}
+DecoderDatabase::DecoderInfo::DecoderInfo(
+    const SdpAudioFormat& audio_format,
+    rtc::Optional<AudioCodecPairId> codec_pair_id,
+    AudioDecoderFactory* factory)
+    : DecoderInfo(audio_format, codec_pair_id, factory, audio_format.name) {}
 
-DecoderDatabase::DecoderInfo::DecoderInfo(NetEqDecoder ct,
-                                          AudioDecoderFactory* factory)
-    : DecoderInfo(*NetEqDecoderToSdpAudioFormat(ct), factory) {}
+DecoderDatabase::DecoderInfo::DecoderInfo(
+    NetEqDecoder ct,
+    rtc::Optional<AudioCodecPairId> codec_pair_id,
+    AudioDecoderFactory* factory)
+    : DecoderInfo(*NetEqDecoderToSdpAudioFormat(ct), codec_pair_id, factory) {}
 
 DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
                                           AudioDecoder* ext_dec,
                                           const std::string& codec_name)
     : name_(codec_name),
       audio_format_(audio_format),
+      codec_pair_id_(rtc::nullopt),
       factory_(nullptr),
       external_decoder_(ext_dec),
       subtype_(Subtype::kNormal) {
@@ -83,7 +93,7 @@
     // TODO(ossu): Keep a check here for now, since a number of tests create
     // DecoderInfos without factories.
     RTC_DCHECK(factory_);
-    decoder_ = factory_->MakeAudioDecoder(audio_format_, rtc::nullopt);
+    decoder_ = factory_->MakeAudioDecoder(audio_format_, codec_pair_id_);
   }
   RTC_DCHECK(decoder_) << "Failed to create: " << audio_format_;
   return decoder_.get();
@@ -156,7 +166,8 @@
     RTC_DCHECK_LE(rtp_payload_type, 0x7f);
     if (decoders_.count(rtp_payload_type) == 0) {
       decoders_.insert(std::make_pair(
-          rtp_payload_type, DecoderInfo(audio_format, decoder_factory_.get())));
+          rtp_payload_type,
+          DecoderInfo(audio_format, codec_pair_id_, decoder_factory_.get())));
     } else {
       // The mapping for this payload type hasn't changed.
     }
@@ -178,7 +189,7 @@
   if (!opt_format) {
     return kCodecNotSupported;
   }
-  DecoderInfo info(*opt_format, decoder_factory_, name);
+  DecoderInfo info(*opt_format, codec_pair_id_, decoder_factory_, name);
   if (!info.CanGetDecoder()) {
     return kCodecNotSupported;
   }
@@ -197,7 +208,8 @@
     return kInvalidRtpPayloadType;
   }
   const auto ret = decoders_.insert(std::make_pair(
-      rtp_payload_type, DecoderInfo(audio_format, decoder_factory_.get())));
+      rtp_payload_type,
+      DecoderInfo(audio_format, codec_pair_id_, decoder_factory_.get())));
   if (ret.second == false) {
     // Database already contains a decoder with type |rtp_payload_type|.
     return kDecoderExists;
diff --git a/modules/audio_coding/neteq/decoder_database.h b/modules/audio_coding/neteq/decoder_database.h
index 5f0d173..f769e39 100644
--- a/modules/audio_coding/neteq/decoder_database.h
+++ b/modules/audio_coding/neteq/decoder_database.h
@@ -43,11 +43,14 @@
   class DecoderInfo {
    public:
     DecoderInfo(const SdpAudioFormat& audio_format,
+                rtc::Optional<AudioCodecPairId> codec_pair_id,
                 AudioDecoderFactory* factory,
                 const std::string& codec_name);
     explicit DecoderInfo(const SdpAudioFormat& audio_format,
+                         rtc::Optional<AudioCodecPairId> codec_pair_id,
                          AudioDecoderFactory* factory = nullptr);
     explicit DecoderInfo(NetEqDecoder ct,
+                         rtc::Optional<AudioCodecPairId> codec_pair_id,
                          AudioDecoderFactory* factory = nullptr);
     DecoderInfo(const SdpAudioFormat& audio_format,
                 AudioDecoder* ext_dec,
@@ -108,6 +111,7 @@
     const std::string name_;
 
     const SdpAudioFormat audio_format_;
+    const rtc::Optional<AudioCodecPairId> codec_pair_id_;
     AudioDecoderFactory* const factory_;
     mutable std::unique_ptr<AudioDecoder> decoder_;
 
@@ -138,7 +142,8 @@
   static const uint8_t kRtpPayloadTypeError = 0xFF;
 
   DecoderDatabase(
-      const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory);
+      const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory,
+      rtc::Optional<AudioCodecPairId> codec_pair_id);
 
   virtual ~DecoderDatabase();
 
@@ -242,6 +247,7 @@
   int active_cng_decoder_type_;
   mutable std::unique_ptr<ComfortNoiseDecoder> active_cng_decoder_;
   rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
+  const rtc::Optional<AudioCodecPairId> codec_pair_id_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DecoderDatabase);
 };
diff --git a/modules/audio_coding/neteq/decoder_database_unittest.cc b/modules/audio_coding/neteq/decoder_database_unittest.cc
index 7f9b38e..a6b9689 100644
--- a/modules/audio_coding/neteq/decoder_database_unittest.cc
+++ b/modules/audio_coding/neteq/decoder_database_unittest.cc
@@ -28,7 +28,8 @@
 namespace webrtc {
 
 TEST(DecoderDatabase, CreateAndDestroy) {
-  DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>);
+  DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>,
+                     rtc::nullopt);
   EXPECT_EQ(0, db.Size());
   EXPECT_TRUE(db.Empty());
 }
@@ -41,7 +42,7 @@
         EXPECT_EQ("pcmu", format.name);
         return true;
       }));
-  DecoderDatabase db(factory);
+  DecoderDatabase db(factory, rtc::nullopt);
   const uint8_t kPayloadType = 0;
   const std::string kCodecName = "Robert\'); DROP TABLE Students;";
   EXPECT_EQ(
@@ -66,7 +67,7 @@
         EXPECT_EQ("pcma", format.name);
         return true;
       }));
-  DecoderDatabase db(factory);
+  DecoderDatabase db(factory, rtc::nullopt);
   const std::string kCodecName1 = "Robert\'); DROP TABLE Students;";
   const std::string kCodecName2 = "https://xkcd.com/327/";
   EXPECT_EQ(DecoderDatabase::kOK,
@@ -96,7 +97,7 @@
         EXPECT_EQ("pcmu", format.name);
         dec->reset(decoder);
       }));
-  DecoderDatabase db(factory);
+  DecoderDatabase db(factory, rtc::nullopt);
   const uint8_t kPayloadType = 0;
   const std::string kCodecName = "Robert\'); DROP TABLE Students;";
   EXPECT_EQ(
@@ -113,7 +114,7 @@
 }
 
 TEST(DecoderDatabase, GetDecoder) {
-  DecoderDatabase db(CreateBuiltinAudioDecoderFactory());
+  DecoderDatabase db(CreateBuiltinAudioDecoderFactory(), rtc::nullopt);
   const uint8_t kPayloadType = 0;
   const std::string kCodecName = "Robert\'); DROP TABLE Students;";
   EXPECT_EQ(DecoderDatabase::kOK,
@@ -131,7 +132,7 @@
         EXPECT_EQ("pcmu", format.name);
         return true;
       }));
-  DecoderDatabase db(factory);
+  DecoderDatabase db(factory, rtc::nullopt);
   const uint8_t kPayloadTypePcmU = 0;
   const uint8_t kPayloadTypeCng = 13;
   const uint8_t kPayloadTypeDtmf = 100;
@@ -166,7 +167,8 @@
 }
 
 TEST(DecoderDatabase, ExternalDecoder) {
-  DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>);
+  DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>,
+                     rtc::nullopt);
   const uint8_t kPayloadType = 0;
   const std::string kCodecName = "Robert\'); DROP TABLE Students;";
   MockAudioDecoder decoder;
@@ -203,7 +205,7 @@
         EXPECT_EQ("pcmu", format.name);
         return true;
       }));
-  DecoderDatabase db(factory);
+  DecoderDatabase db(factory, rtc::nullopt);
   // Load a number of payloads into the database. Payload types are 0, 1, ...,
   // while the decoder type is the same for all payload types (this does not
   // matter for the test).
@@ -243,7 +245,7 @@
 
 // Test the methods for setting and getting active speech and CNG decoders.
 TEST(DecoderDatabase, IF_ISAC(ActiveDecoders)) {
-  DecoderDatabase db(CreateBuiltinAudioDecoderFactory());
+  DecoderDatabase db(CreateBuiltinAudioDecoderFactory(), rtc::nullopt);
   // Load payload types.
   ASSERT_EQ(DecoderDatabase::kOK,
             db.RegisterPayload(0, NetEqDecoder::kDecoderPCMu, "pcmu"));
diff --git a/modules/audio_coding/neteq/include/neteq.h b/modules/audio_coding/neteq/include/neteq.h
index f5bd8cd..a3648e8 100644
--- a/modules/audio_coding/neteq/include/neteq.h
+++ b/modules/audio_coding/neteq/include/neteq.h
@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "api/audio_codecs/audio_codec_pair_id.h"
 #include "api/audio_codecs/audio_decoder.h"
 #include "api/optional.h"
 #include "api/rtp_headers.h"
@@ -90,26 +91,24 @@
   };
 
   struct Config {
-    Config()
-        : sample_rate_hz(16000),
-          enable_post_decode_vad(false),
-          max_packets_in_buffer(50),
-          // |max_delay_ms| has the same effect as calling SetMaximumDelay().
-          max_delay_ms(2000),
-          background_noise_mode(kBgnOff),
-          playout_mode(kPlayoutOn),
-          enable_fast_accelerate(false) {}
+    Config();
+    Config(const Config&);
+    Config(Config&&);
+    ~Config();
+    Config& operator=(const Config&);
+    Config& operator=(Config&&);
 
     std::string ToString() const;
 
-    int sample_rate_hz;  // Initial value. Will change with input data.
-    bool enable_post_decode_vad;
-    size_t max_packets_in_buffer;
-    int max_delay_ms;
-    BackgroundNoiseMode background_noise_mode;
-    NetEqPlayoutMode playout_mode;
-    bool enable_fast_accelerate;
+    int sample_rate_hz = 16000;  // Initial value. Will change with input data.
+    bool enable_post_decode_vad = false;
+    size_t max_packets_in_buffer = 50;
+    int max_delay_ms = 2000;
+    BackgroundNoiseMode background_noise_mode = kBgnOff;
+    NetEqPlayoutMode playout_mode = kPlayoutOn;
+    bool enable_fast_accelerate = false;
     bool enable_muted_state = false;
+    rtc::Optional<AudioCodecPairId> codec_pair_id;
   };
 
   enum ReturnCodes {
diff --git a/modules/audio_coding/neteq/mock/mock_decoder_database.h b/modules/audio_coding/neteq/mock/mock_decoder_database.h
index 049b693..a4240ce 100644
--- a/modules/audio_coding/neteq/mock/mock_decoder_database.h
+++ b/modules/audio_coding/neteq/mock/mock_decoder_database.h
@@ -23,7 +23,7 @@
  public:
   explicit MockDecoderDatabase(
       rtc::scoped_refptr<AudioDecoderFactory> factory = nullptr)
-      : DecoderDatabase(factory) {}
+      : DecoderDatabase(factory, rtc::nullopt) {}
   virtual ~MockDecoderDatabase() { Die(); }
   MOCK_METHOD0(Die, void());
   MOCK_CONST_METHOD0(Empty,
diff --git a/modules/audio_coding/neteq/neteq.cc b/modules/audio_coding/neteq/neteq.cc
index 8b74973..534c474 100644
--- a/modules/audio_coding/neteq/neteq.cc
+++ b/modules/audio_coding/neteq/neteq.cc
@@ -17,6 +17,13 @@
 
 namespace webrtc {
 
+NetEq::Config::Config() = default;
+NetEq::Config::Config(const Config&) = default;
+NetEq::Config::Config(Config&&) = default;
+NetEq::Config::~Config() = default;
+NetEq::Config& NetEq::Config::operator=(const Config&) = default;
+NetEq::Config& NetEq::Config::operator=(Config&&) = default;
+
 std::string NetEq::Config::ToString() const {
   std::stringstream ss;
   ss << "sample_rate_hz=" << sample_rate_hz
diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc
index b107626..78015d9 100644
--- a/modules/audio_coding/neteq/neteq_impl.cc
+++ b/modules/audio_coding/neteq/neteq_impl.cc
@@ -57,7 +57,8 @@
     const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory)
     : tick_timer(new TickTimer),
       buffer_level_filter(new BufferLevelFilter),
-      decoder_database(new DecoderDatabase(decoder_factory)),
+      decoder_database(
+          new DecoderDatabase(decoder_factory, config.codec_pair_id)),
       delay_peak_detector(new DelayPeakDetector(tick_timer.get())),
       delay_manager(new DelayManager(config.max_packets_in_buffer,
                                      delay_peak_detector.get(),
diff --git a/modules/audio_coding/neteq/neteq_impl_unittest.cc b/modules/audio_coding/neteq/neteq_impl_unittest.cc
index 12eabfa..e163992 100644
--- a/modules/audio_coding/neteq/neteq_impl_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_impl_unittest.cc
@@ -335,7 +335,7 @@
 
         *dec = std::move(mock_decoder);
       }));
-  DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+  DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, rtc::nullopt,
                                     mock_decoder_factory);
 
   // Expectations for decoder database.
diff --git a/modules/audio_coding/neteq/packet_buffer_unittest.cc b/modules/audio_coding/neteq/packet_buffer_unittest.cc
index 0ddeb8a..1aaed8b 100644
--- a/modules/audio_coding/neteq/packet_buffer_unittest.cc
+++ b/modules/audio_coding/neteq/packet_buffer_unittest.cc
@@ -175,7 +175,8 @@
 
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+                                          rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(&info));
 
@@ -219,10 +220,12 @@
 
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info0(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info0(NetEqDecoder::kDecoderPCMu,
+                                           rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(&info0));
-  const DecoderDatabase::DecoderInfo info1(NetEqDecoder::kDecoderPCMa, factory);
+  const DecoderDatabase::DecoderInfo info1(NetEqDecoder::kDecoderPCMa,
+                                           rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(&info1));
 
@@ -404,7 +407,8 @@
 
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+                                          rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(&info));
   rtc::Optional<uint8_t> current_pt;
@@ -444,11 +448,11 @@
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
   const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGnb,
-                                              factory);
+                                              rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(kCngPt))
       .WillRepeatedly(Return(&info_cng));
   const DecoderDatabase::DecoderInfo info_speech(NetEqDecoder::kDecoderPCM16Bwb,
-                                                 factory);
+                                                 rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(kSpeechPt))
       .WillRepeatedly(Return(&info_speech));
 
@@ -545,7 +549,8 @@
   list.push_back(gen.NextPacket(payload_len));  // Valid packet.
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+                                          rtc::nullopt, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(&info));
   rtc::Optional<uint8_t> current_pt;
diff --git a/modules/audio_coding/neteq/red_payload_splitter_unittest.cc b/modules/audio_coding/neteq/red_payload_splitter_unittest.cc
index 4f511ad..077c8ea 100644
--- a/modules/audio_coding/neteq/red_payload_splitter_unittest.cc
+++ b/modules/audio_coding/neteq/red_payload_splitter_unittest.cc
@@ -299,7 +299,7 @@
   // easier to just register the payload types and let the actual implementation
   // do its job.
   DecoderDatabase decoder_database(
-      new rtc::RefCountedObject<MockAudioDecoderFactory>);
+      new rtc::RefCountedObject<MockAudioDecoderFactory>, rtc::nullopt);
   decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderCNGnb, "cng-nb");
   decoder_database.RegisterPayload(1, NetEqDecoder::kDecoderPCMu, "pcmu");
   decoder_database.RegisterPayload(2, NetEqDecoder::kDecoderAVT, "avt");
diff --git a/modules/audio_coding/neteq/timestamp_scaler_unittest.cc b/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
index b3c1bb0..1a7b71a 100644
--- a/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
+++ b/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
@@ -25,7 +25,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use PCMu, because it doesn't use scaled timestamps.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 0;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -46,7 +47,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use PCMu, because it doesn't use scaled timestamps.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 0;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -72,7 +74,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -97,7 +100,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -127,9 +131,9 @@
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
   const DecoderDatabase::DecoderInfo info_g722(NetEqDecoder::kDecoderG722,
-                                               factory);
+                                               rtc::nullopt, factory);
   const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGwb,
-                                              factory);
+                                              rtc::nullopt, factory);
   static const uint8_t kRtpPayloadTypeG722 = 17;
   static const uint8_t kRtpPayloadTypeCng = 13;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadTypeG722))
@@ -170,7 +174,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -199,7 +204,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -232,7 +238,8 @@
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -272,7 +279,8 @@
 TEST(TimestampScaler, TestOpusLargeStep) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus, factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus,
+                                          rtc::nullopt, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));