Adding APM configuration in AEC dump.

webrtc/modules/audio_processing/test/unpack.cc

 /*
  *  Copyright (c) 2011 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 22 matching lines @@
 DEFINE_string(level_file, "level.int32", "The name of the level file.");
 DEFINE_string(keypress_file, "keypress.bool", "The name of the keypress file.");
 DEFINE_string(settings_file, "settings.txt", "The name of the settings file.");
 DEFINE_bool(full, false,
             "Unpack the full set of files (normally not needed).");
 DEFINE_bool(raw, false, "Write raw data instead of a WAV file.");
 DEFINE_bool(text,
             false,
             "Write non-audio files as text files instead of binary files.");
 
+inline void print_config(FILE* settings_file,

[peah-webrtc, 2015/10/02 08:34:28]

Is this really a proper filename according to the style guideline?
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Function_Names)

[minyue-webrtc, 2015/10/02 09:01:42]

This part has been changed back to Andrew's early suggestion (a macro). You may
still concern about macro vs. inline function. To be honest, I don't know what
is best, but I think Andrew's idea is not bad.

[peah-webrtc, 2015/10/02 09:18:29]

Acknowledged.

+                         bool config_exist,
+                         int config_value,
+                         const std::string& config_descriptor) {
+  if (config_exist) {
+    fprintf(settings_file, "  %s: %d\n", config_descriptor.c_str(),
+            config_value);
+  }
+}
+
 namespace webrtc {
 
 using audioproc::Event;
 using audioproc::ReverseStream;
 using audioproc::Stream;
 using audioproc::Init;
 
 void WriteData(const void* data, size_t size, FILE* file,
                const std::string& filename) {
   if (fwrite(data, size, 1, file) != 1) {
@@ skipping 23 matching lines @@
   int output_samples_per_channel = 0;
   int num_reverse_channels = 0;
   int num_input_channels = 0;
   int num_output_channels = 0;
   rtc::scoped_ptr<WavWriter> reverse_wav_file;
   rtc::scoped_ptr<WavWriter> input_wav_file;
   rtc::scoped_ptr<WavWriter> output_wav_file;
   rtc::scoped_ptr<RawFile> reverse_raw_file;
   rtc::scoped_ptr<RawFile> input_raw_file;
   rtc::scoped_ptr<RawFile> output_raw_file;
+
+  FILE* settings_file = OpenFile(FLAGS_settings_file, "wb");

[peah-webrtc, 2015/10/02 08:34:27]

This is something that holds for the version currently in master as well, but
should we not close the file? I cannot find any corresponding file close?

[minyue-webrtc, 2015/10/02 09:01:42]

Yes, could you help me find a place to add a close (since I am OOO and have
limited spectrum)? or maybe make a CL or it is easier to merge.

[peah-webrtc, 2015/10/02 09:18:29]

I'd just add a close of the settings_file and debug_file at the end of the
do_main function, just before the return 0. This should be fine as the
while-statement encompasses the whole file.

I guess, however, that it should be fine to have it in a separate CL as well as
it was designed like that before. Not sure about how that typically is best
handled. You know more about that than me.

In case you others think it is fine to keep it as it is, I'm happy with that.

+
   while (ReadMessageFromFile(debug_file, &event_msg)) {
     if (event_msg.type() == Event::REVERSE_STREAM) {
       if (!event_msg.has_reverse_stream()) {
         printf("Corrupt input file: ReverseStream missing.\n");
         return 1;
       }
 
       const ReverseStream msg = event_msg.reverse_stream();
       if (msg.has_data()) {
         if (FLAGS_raw && !reverse_raw_file) {
@@ skipping 114 matching lines @@
           static FILE* keypress_file = OpenFile(FLAGS_keypress_file, "wb");
           bool keypress = msg.keypress();
           if (FLAGS_text) {
             fprintf(keypress_file, "%d\n", keypress);
           } else {
             WriteData(&keypress, sizeof(keypress), keypress_file,
                       FLAGS_keypress_file);
           }
         }
       }
+    } else if (event_msg.type() == Event::CONFIG) {
+      if (!event_msg.has_config()) {
+        printf("Corrupt input file: Config missing.\n");
+        return 1;
+      }
+      const audioproc::Config msg = event_msg.config();
+
+      fprintf(settings_file, "APM re-config at frame: %d\n", frame_count);
+      // AEC.
+      print_config(settings_file, msg.has_aec_enabled(), msg.aec_enabled(),
+                   "AEC enabled");
+      print_config(settings_file, msg.has_aec_delay_agnostic(),
+                   msg.aec_delay_agnostic(), "AEC delay agnostic enabled");
+      print_config(settings_file, msg.has_aec_drift_compensation(),
+                   msg.aec_drift_compensation(),
+                   "AEC drift compensation enabled");
+      print_config(settings_file, msg.has_aec_extended_filter(),
+                   msg.aec_extended_filter(), "AEC extended filter enabled");
+      print_config(settings_file, msg.has_aec_suppression_level(),
+                   msg.aec_suppression_level(), "AEC suppression level");
+      // AECM.
+      print_config(settings_file, msg.has_aecm_enabled(), msg.aecm_enabled(),
+                   "AECM enabled");
+      print_config(settings_file, msg.has_aecm_comfort_noise(),
+                   msg.aecm_comfort_noise(), "AECM comfort noise enabled");
+      print_config(settings_file, msg.has_aecm_routing_mode(),
+                   msg.aecm_routing_mode(), "AECM routing mode");
+      // AGC.
+      print_config(settings_file, msg.has_agc_enabled(), msg.agc_enabled(),
+                   "AGC enabled");
+      print_config(settings_file, msg.has_agc_experiment(),
+                   msg.agc_experiment(), "AGC experiment enabled");
+      print_config(settings_file, msg.has_agc_mode(), msg.agc_mode(),
+                   "AGC mode");
+      print_config(settings_file, msg.has_agc_limiter(), msg.agc_limiter(),
+                   "AGC limiter enabled");
+      // HPF.
+      print_config(settings_file, msg.has_hpf_enabled(), msg.hpf_enabled(),
+                   "HPF enabled");
+      // NS.
+      print_config(settings_file, msg.has_ns_enabled(), msg.ns_enabled(),
+                   "NS enabled");
+      print_config(settings_file, msg.has_ns_experiment(), msg.ns_experiment(),
+                   "NS experiment enabled");
+      print_config(settings_file, msg.has_ns_level(), msg.ns_level(),
+                   "NS Level");
     } else if (event_msg.type() == Event::INIT) {
       if (!event_msg.has_init()) {
         printf("Corrupt input file: Init missing.\n");
         return 1;
       }
 
-      static FILE* settings_file = OpenFile(FLAGS_settings_file, "wb");
       const Init msg = event_msg.init();
       // These should print out zeros if they're missing.
       fprintf(settings_file, "Init at frame: %d\n", frame_count);
       int input_sample_rate = msg.sample_rate();
       fprintf(settings_file, "  Input sample rate: %d\n", input_sample_rate);
       int output_sample_rate = msg.output_sample_rate();
       fprintf(settings_file, "  Output sample rate: %d\n", output_sample_rate);
       int reverse_sample_rate = msg.reverse_sample_rate();
       fprintf(settings_file,
               "  Reverse sample rate: %d\n",
@@ skipping 35 matching lines @@
   }
 
   return 0;
 }
 
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   return webrtc::do_main(argc, argv);
 }