Adding a config struct to NetEq

With this change, the parameters sent to the NetEq::Create method are
collected in one NetEq::Config struct. The benefit is that it is easier
to set, change and override default values, and easier to expand with
more parameters in the future.

BUG=3083
R=turaj@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/11949004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@5902 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/audio_coding/main/acm2/acm_receiver.cc

@@ -35,7 +35,6 @@ namespace acm2 {
 
 namespace {
 
-const int kNeteqInitSampleRateHz = 16000;
 const int kNackThresholdPackets = 2;
 
 // |vad_activity_| field of |audio_frame| is set to |previous_audio_activity_|
@@ -119,13 +118,14 @@ bool IsCng(int codec_id) {
 
 AcmReceiver::AcmReceiver()
     : id_(0),
-      neteq_(NetEq::Create(kNeteqInitSampleRateHz)),
+      neteq_config_(),
+      neteq_(NetEq::Create(neteq_config_)),
       last_audio_decoder_(-1),  // Invalid value.
       decode_lock_(RWLockWrapper::CreateRWLock()),
       neteq_crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       vad_enabled_(true),
       previous_audio_activity_(AudioFrame::kVadPassive),
-      current_sample_rate_hz_(kNeteqInitSampleRateHz),
+      current_sample_rate_hz_(neteq_config_.sample_rate_hz),
       nack_(),
       nack_enabled_(false),
       av_sync_(false),
@@ -774,7 +774,7 @@ bool AcmReceiver::GetSilence(int desired_sample_rate_hz, AudioFrame* frame) {
     current_sample_rate_hz_ = ACMCodecDB::database_[last_audio_decoder_].plfreq;
     frame->num_channels_ = decoders_[last_audio_decoder_].channels;
   } else {
-    current_sample_rate_hz_ = kNeteqInitSampleRateHz;
+    current_sample_rate_hz_ = neteq_config_.sample_rate_hz;
     frame->num_channels_ = 1;
   }
 

webrtc/modules/audio_coding/main/acm2/acm_receiver.h

@@ -340,6 +340,7 @@ class AcmReceiver {
   void InsertStreamOfSyncPackets(InitialDelayManager::SyncStream* sync_stream);
 
   int id_;
+  NetEq::Config neteq_config_;
   NetEq* neteq_;
   Decoder decoders_[ACMCodecDB::kMaxNumCodecs];
   int last_audio_decoder_;

webrtc/modules/audio_coding/neteq4/interface/neteq.h

@@ -67,6 +67,15 @@ enum NetEqBackgroundNoiseMode {
 // This is the interface class for NetEq.
 class NetEq {
  public:
+  struct Config {
+    Config()
+        : sample_rate_hz(16000),
+          enable_audio_classifier(false) {}
+
+    int sample_rate_hz;  // Initial vale. Will change with input data.
+    bool enable_audio_classifier;
+  };
+
   enum ReturnCodes {
     kOK = 0,
     kFail = -1,
@@ -105,11 +114,10 @@ class NetEq {
   static const int kMaxNumPacketsInBuffer = 50;  // TODO(hlundin): Remove.
   static const int kMaxBytesInBuffer = 113280;  // TODO(hlundin): Remove.
 
-  // Creates a new NetEq object, starting at the sample rate |sample_rate_hz|.
+  // Creates a new NetEq object, with parameters set in |config|. The |config|
-  // (Note that it will still change the sample rate depending on what payloads
+  // object will only have to be valid for the duration of the call to this
-  // are being inserted; |sample_rate_hz| is just for startup configuration.)
+  // method.
-  static NetEq* Create(int sample_rate_hz,
+  static NetEq* Create(const NetEq::Config& config);
-                       bool enable_audio_classifier = false);
 
   virtual ~NetEq() {}
 

webrtc/modules/audio_coding/neteq4/neteq.cc

@@ -28,13 +28,13 @@ namespace webrtc {
 
 // Creates all classes needed and inject them into a new NetEqImpl object.
 // Return the new object.
-NetEq* NetEq::Create(int sample_rate_hz, bool enable_audio_classifier) {
+NetEq* NetEq::Create(const NetEq::Config& config) {
   BufferLevelFilter* buffer_level_filter = new BufferLevelFilter;
   DecoderDatabase* decoder_database = new DecoderDatabase;
   DelayPeakDetector* delay_peak_detector = new DelayPeakDetector;
   DelayManager* delay_manager = new DelayManager(kMaxNumPacketsInBuffer,
                                                  delay_peak_detector);
-  DtmfBuffer* dtmf_buffer = new DtmfBuffer(sample_rate_hz);
+  DtmfBuffer* dtmf_buffer = new DtmfBuffer(config.sample_rate_hz);
   DtmfToneGenerator* dtmf_tone_generator = new DtmfToneGenerator;
   PacketBuffer* packet_buffer = new PacketBuffer(kMaxNumPacketsInBuffer,
                                                  kMaxBytesInBuffer);
@@ -44,7 +44,7 @@ NetEq* NetEq::Create(int sample_rate_hz, bool enable_audio_classifier) {
   ExpandFactory* expand_factory = new ExpandFactory;
   PreemptiveExpandFactory* preemptive_expand_factory =
       new PreemptiveExpandFactory;
-  return new NetEqImpl(sample_rate_hz,
+  return new NetEqImpl(config.sample_rate_hz,
                        buffer_level_filter,
                        decoder_database,
                        delay_manager,

webrtc/modules/audio_coding/neteq4/neteq_external_decoder_unittest.cc

@@ -45,13 +45,15 @@ class NetEqExternalDecoderTest : public ::testing::Test {
         frame_size_ms_(10),
         frame_size_samples_(frame_size_ms_ * samples_per_ms_),
         output_size_samples_(frame_size_ms_ * samples_per_ms_),
-        neteq_external_(NetEq::Create(sample_rate_hz_)),
-        neteq_(NetEq::Create(sample_rate_hz_)),
         external_decoder_(new MockExternalPcm16B(kDecoderPCM16Bswb32kHz)),
         rtp_generator_(samples_per_ms_),
         payload_size_bytes_(0),
         last_send_time_(0),
         last_arrival_time_(0) {
+    NetEq::Config config;
+    config.sample_rate_hz = sample_rate_hz_;
+    neteq_external_ = NetEq::Create(config);
+    neteq_ = NetEq::Create(config);
     input_ = new int16_t[frame_size_samples_];
     encoded_ = new uint8_t[2 * frame_size_samples_];
   }

webrtc/modules/audio_coding/neteq4/neteq_impl_unittest.cc

@@ -48,9 +48,9 @@ int DeletePacketsAndReturnOk(PacketList* packet_list) {
 
 class NetEqImplTest : public ::testing::Test {
  protected:
-  static const int kInitSampleRateHz = 8000;
   NetEqImplTest()
       : neteq_(NULL),
+        config_(),
         mock_buffer_level_filter_(NULL),
         buffer_level_filter_(NULL),
         use_mock_buffer_level_filter_(true),
@@ -75,7 +75,9 @@ class NetEqImplTest : public ::testing::Test {
         mock_payload_splitter_(NULL),
         payload_splitter_(NULL),
         use_mock_payload_splitter_(true),
-        timestamp_scaler_(NULL) {}
+        timestamp_scaler_(NULL) {
+    config_.sample_rate_hz = 8000;
+  }
 
   void CreateInstance() {
     if (use_mock_buffer_level_filter_) {
@@ -109,10 +111,10 @@ class NetEqImplTest : public ::testing::Test {
           new DelayManager(NetEq::kMaxNumPacketsInBuffer, delay_peak_detector_);
     }
     if (use_mock_dtmf_buffer_) {
-      mock_dtmf_buffer_ = new MockDtmfBuffer(kInitSampleRateHz);
+      mock_dtmf_buffer_ = new MockDtmfBuffer(config_.sample_rate_hz);
       dtmf_buffer_ = mock_dtmf_buffer_;
     } else {
-      dtmf_buffer_ = new DtmfBuffer(kInitSampleRateHz);
+      dtmf_buffer_ = new DtmfBuffer(config_.sample_rate_hz);
     }
     if (use_mock_dtmf_tone_generator_) {
       mock_dtmf_tone_generator_ = new MockDtmfToneGenerator;
@@ -140,7 +142,7 @@ class NetEqImplTest : public ::testing::Test {
     PreemptiveExpandFactory* preemptive_expand_factory =
         new PreemptiveExpandFactory;
 
-    neteq_ = new NetEqImpl(kInitSampleRateHz,
+    neteq_ = new NetEqImpl(config_.sample_rate_hz,
                            buffer_level_filter_,
                            decoder_database_,
                            delay_manager_,
@@ -194,6 +196,7 @@ class NetEqImplTest : public ::testing::Test {
   }
 
   NetEqImpl* neteq_;
+  NetEq::Config config_;
   MockBufferLevelFilter* mock_buffer_level_filter_;
   BufferLevelFilter* buffer_level_filter_;
   bool use_mock_buffer_level_filter_;
@@ -225,7 +228,8 @@ class NetEqImplTest : public ::testing::Test {
 // This tests the interface class NetEq.
 // TODO(hlundin): Move to separate file?
 TEST(NetEq, CreateAndDestroy) {
-  NetEq* neteq = NetEq::Create(8000);
+  NetEq::Config config;
+  NetEq* neteq = NetEq::Create(config);
   delete neteq;
 }
 

webrtc/modules/audio_coding/neteq4/neteq_stereo_unittest.cc

@@ -54,14 +54,16 @@ class NetEqStereoTest : public ::testing::TestWithParam<TestParameters> {
         frame_size_ms_(GetParam().frame_size),
         frame_size_samples_(frame_size_ms_ * samples_per_ms_),
         output_size_samples_(10 * samples_per_ms_),
-        neteq_mono_(NetEq::Create(sample_rate_hz_)),
-        neteq_(NetEq::Create(sample_rate_hz_)),
         rtp_generator_mono_(samples_per_ms_),
         rtp_generator_(samples_per_ms_),
         payload_size_bytes_(0),
         multi_payload_size_bytes_(0),
         last_send_time_(0),
         last_arrival_time_(0) {
+    NetEq::Config config;
+    config.sample_rate_hz = sample_rate_hz_;
+    neteq_mono_ = NetEq::Create(config);
+    neteq_ = NetEq::Create(config);
     input_ = new int16_t[frame_size_samples_];
     encoded_ = new uint8_t[2 * frame_size_samples_];
     input_multi_channel_ = new int16_t[frame_size_samples_ * num_channels_];

webrtc/modules/audio_coding/neteq4/neteq_unittest.cc

@@ -254,7 +254,9 @@ NetEqDecodingTest::NetEqDecodingTest()
 }
 
 void NetEqDecodingTest::SetUp() {
-  neteq_ = NetEq::Create(kInitSampleRateHz);
+  NetEq::Config config;
+  config.sample_rate_hz = kInitSampleRateHz;
+  neteq_ = NetEq::Create(config);
   NetEqNetworkStatistics stat;
   ASSERT_EQ(0, neteq_->NetworkStatistics(&stat));
   algorithmic_delay_ms_ = stat.current_buffer_size_ms;

webrtc/modules/audio_coding/neteq4/tools/neteq_performance_test.cc

@@ -36,7 +36,9 @@ int64_t NetEqPerformanceTest::Run(int runtime_ms,
   const int kPayloadType = 95;
 
   // Initialize NetEq instance.
-  NetEq* neteq = NetEq::Create(kSampRateHz);
+  NetEq::Config config;
+  config.sample_rate_hz = kSampRateHz;
+  NetEq* neteq = NetEq::Create(config);
   // Register decoder in |neteq|.
   if (neteq->RegisterPayloadType(kDecoderType, kPayloadType) != 0)
     return -1;

webrtc/modules/audio_coding/neteq4/tools/neteq_quality_test.cc

@@ -42,8 +42,10 @@ NetEqQualityTest::NetEqQualityTest(int block_duration_ms,
       in_file_(new InputAudioFile(in_filename_)),
       out_file_(NULL),
       rtp_generator_(new RtpGenerator(in_sampling_khz_, 0, 0,
-                                      decodable_time_ms_)),
+                                      decodable_time_ms_)) {
-      neteq_(NetEq::Create(out_sampling_khz_ * 1000)) {
+  NetEq::Config config;
+  config.sample_rate_hz = out_sampling_khz_ * 1000;
+  neteq_.reset(NetEq::Create(config));
   max_payload_bytes_ = in_size_samples_ * channels_ * sizeof(int16_t);
   in_data_.reset(new int16_t[in_size_samples_ * channels_]);
   payload_.reset(new uint8_t[max_payload_bytes_]);

webrtc/modules/audio_coding/neteq4/tools/neteq_rtpplay.cc

@@ -176,7 +176,9 @@ int main(int argc, char* argv[]) {
 
   // Initialize NetEq instance.
   int sample_rate_hz = 16000;
-  NetEq* neteq = NetEq::Create(sample_rate_hz);
+  NetEq::Config config;
+  config.sample_rate_hz = sample_rate_hz;
+  NetEq* neteq = NetEq::Create(config);
   RegisterPayloadTypes(neteq);
 
   // Read first packet.