Added option to specify a maximum file size when recording an AEC dump.

webrtc/modules/audio_processing/test/audio_processing_unittest.cc

 /*
  *  Copyright (c) 2012 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 370 matching lines @@
                                    AudioProcessing::Error expected_return);
   void TestChangingReverseChannels(int num_rev_channels,
                                    AudioProcessing::Error expected_return);
   void RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate);
   void RunManualVolumeChangeIsPossibleTest(int sample_rate);
   void StreamParametersTest(Format format);
   int ProcessStreamChooser(Format format);
   int AnalyzeReverseStreamChooser(Format format);
   void ProcessDebugDump(const std::string& in_filename,
                         const std::string& out_filename,
-                        Format format);
+                        Format format,
+                        int max_size_bytes);
   void VerifyDebugDumpTest(Format format);
 
   const std::string output_path_;
   const std::string ref_path_;
   const std::string ref_filename_;
   rtc::scoped_ptr<AudioProcessing> apm_;
   AudioFrame* frame_;
   AudioFrame* revframe_;
   rtc::scoped_ptr<ChannelBuffer<float> > float_cb_;
   rtc::scoped_ptr<ChannelBuffer<float> > revfloat_cb_;
@@ skipping 1302 matching lines @@
   frame_copy.CopyFrom(*frame_);
   EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));
   apm_->echo_cancellation()->set_stream_drift_samples(0);
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_FALSE(FrameDataAreEqual(*frame_, frame_copy));
 }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 void ApmTest::ProcessDebugDump(const std::string& in_filename,
                                const std::string& out_filename,
-                               Format format) {
+                               Format format,
+                               int max_size_bytes) {
   FILE* in_file = fopen(in_filename.c_str(), "rb");
   ASSERT_TRUE(in_file != NULL);
   audioproc::Event event_msg;
   bool first_init = true;
 
   while (ReadMessageFromFile(in_file, &event_msg)) {
     if (event_msg.type() == audioproc::Event::INIT) {
       const audioproc::Init msg = event_msg.init();
       int reverse_sample_rate = msg.sample_rate();
       if (msg.has_reverse_sample_rate()) {
         reverse_sample_rate = msg.reverse_sample_rate();
       }
       int output_sample_rate = msg.sample_rate();
       if (msg.has_output_sample_rate()) {
         output_sample_rate = msg.output_sample_rate();
       }
 
       Init(msg.sample_rate(),
            output_sample_rate,
            reverse_sample_rate,
            msg.num_input_channels(),
            msg.num_output_channels(),
            msg.num_reverse_channels(),
            false);
       if (first_init) {
         // StartDebugRecording() writes an additional init message. Don't start
         // recording until after the first init to avoid the extra message.
-        EXPECT_NOERR(apm_->StartDebugRecording(out_filename.c_str()));
+        if (max_size_bytes != -1) {
+          EXPECT_NOERR(
+              apm_->StartDebugRecording(out_filename.c_str(), max_size_bytes));
+        } else {
+          EXPECT_NOERR(apm_->StartDebugRecording(out_filename.c_str()));
+        }
         first_init = false;
       }
 
     } else if (event_msg.type() == audioproc::Event::REVERSE_STREAM) {
       const audioproc::ReverseStream msg = event_msg.reverse_stream();
 
       if (msg.channel_size() > 0) {
         ASSERT_EQ(revframe_->num_channels_, msg.channel_size());
         for (int i = 0; i < msg.channel_size(); ++i) {
            memcpy(revfloat_cb_->channels()[i],
@@ skipping 52 matching lines @@
       format_string = "_int";
       break;
     case kFloatFormat:
       format_string = "_float";
       break;
   }
   const std::string ref_filename = test::TempFilename(
       test::OutputPath(), std::string("ref") + format_string + "_aecdump");
   const std::string out_filename = test::TempFilename(
       test::OutputPath(), std::string("out") + format_string + "_aecdump");
+  const std::string limited_filename = test::TempFilename(
+      test::OutputPath(), std::string("limited") + format_string + "_aecdump");
+  const size_t logging_limit_bytes = 100000;
   EnableAllComponents();
-  ProcessDebugDump(in_filename, ref_filename, format);
-  ProcessDebugDump(ref_filename, out_filename, format);
+  ProcessDebugDump(in_filename, ref_filename, format, -1);
+  ProcessDebugDump(ref_filename, out_filename, format, -1);
+  ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes);
 
   FILE* ref_file = fopen(ref_filename.c_str(), "rb");
   FILE* out_file = fopen(out_filename.c_str(), "rb");
+  FILE* limited_file = fopen(limited_filename.c_str(), "rb");
   ASSERT_TRUE(ref_file != NULL);
   ASSERT_TRUE(out_file != NULL);
+  ASSERT_TRUE(limited_file != NULL);
   rtc::scoped_ptr<uint8_t[]> ref_bytes;
   rtc::scoped_ptr<uint8_t[]> out_bytes;
+  rtc::scoped_ptr<uint8_t[]> limited_bytes;
 
   size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
   size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
+  size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   size_t bytes_read = 0;
+  size_t bytes_read_limited = 0;
   while (ref_size > 0 && out_size > 0) {
     bytes_read += ref_size;
+    bytes_read_limited += limited_size;
     EXPECT_EQ(ref_size, out_size);
+    EXPECT_GE(ref_size, limited_size);
     EXPECT_EQ(0, memcmp(ref_bytes.get(), out_bytes.get(), ref_size));
+    EXPECT_EQ(0, memcmp(ref_bytes.get(), limited_bytes.get(), limited_size));
     ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
     out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
+    limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   }
   EXPECT_GT(bytes_read, 0u);
+  EXPECT_GT(bytes_read_limited, 0u);
+  EXPECT_LE(bytes_read_limited, logging_limit_bytes);

[hlundin-webrtc, 2015/10/30 08:02:21]

Should you maybe test that the actual file size ends up being somewhat close to
the target/limit?

[ivoc, 2015/11/05 13:14:46]

I added an appropriate lower bound.

   EXPECT_NE(0, feof(ref_file));
   EXPECT_NE(0, feof(out_file));
+  EXPECT_NE(0, feof(limited_file));
   ASSERT_EQ(0, fclose(ref_file));
   ASSERT_EQ(0, fclose(out_file));
+  ASSERT_EQ(0, fclose(limited_file));
   remove(ref_filename.c_str());
   remove(out_filename.c_str());
+  remove(limited_filename.c_str());
 }
 
 TEST_F(ApmTest, VerifyDebugDumpInt) {
   VerifyDebugDumpTest(kIntFormat);
 }
 
 TEST_F(ApmTest, VerifyDebugDumpFloat) {
   VerifyDebugDumpTest(kFloatFormat);
 }
 #endif
@@ skipping 894 matching lines @@
                     std::tr1::make_tuple(16000, 16000, 32000, 16000, 40, 20),
                     std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 #endif
 
 // TODO(henrike): re-implement functionality lost when removing the old main
 //                function. See
 //                https://code.google.com/p/webrtc/issues/detail?id=1981
 
 }  // namespace
 }  // namespace webrtc