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

webrtc/modules/audio_processing/audio_processing_impl.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 176 matching lines @@
       echo_control_mobile_(NULL),
       gain_control_(NULL),
       high_pass_filter_(NULL),
       level_estimator_(NULL),
       noise_suppression_(NULL),
       voice_detection_(NULL),
       crit_(CriticalSectionWrapper::CreateCriticalSection()),
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
       debug_file_(FileWrapper::Create()),
       event_msg_(new audioproc::Event()),
+      nr_bytes_left_for_log(-1),
 #endif
       api_format_({{{kSampleRate16kHz, 1, false},
                     {kSampleRate16kHz, 1, false},
                     {kSampleRate16kHz, 1, false},
                     {kSampleRate16kHz, 1, false}}}),
       fwd_proc_format_(kSampleRate16kHz),
       rev_proc_format_(kSampleRate16kHz, 1),
       split_rate_(kSampleRate16kHz),
       stream_delay_ms_(0),
       delay_offset_ms_(0),
@@ skipping 716 matching lines @@
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
+int AudioProcessingImpl::StartDebugRecording(
+    const char filename[AudioProcessing::kMaxFilenameSize],
+    int max_log_size_bytes) {
+#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
+  nr_bytes_left_for_log = max_log_size_bytes;
+  int ret_val = StartDebugRecording(filename);
+  if (ret_val != kNoError) {
+    nr_bytes_left_for_log = -1;

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

Is it important to reset to -1 when an error happens?

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

I did this because there was also the other version of this function that does
not have a max size, however, I reimplemented that one in terms of this
function, so this is no longer needed.

+  }
+  return ret_val;
+#else
+  return kUnsupportedFunctionError;
+#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
+}
+
 int AudioProcessingImpl::StartDebugRecording(FILE* handle) {
   CriticalSectionScoped crit_scoped(crit_);
 
   if (handle == NULL) {
     return kNullPointerError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stop any ongoing recording.
   if (debug_file_->Open()) {
     if (debug_file_->CloseFile() == -1) {
       return kFileError;
     }
   }
 
   if (debug_file_->OpenFromFileHandle(handle, true, false) == -1) {
     return kFileError;
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
+int AudioProcessingImpl::StartDebugRecording(FILE* handle,
+                                             int max_log_size_bytes) {
+#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
+  RTC_DCHECK_GT(max_log_size_bytes, 0);
+  nr_bytes_left_for_log = max_log_size_bytes;
+  int ret_val = StartDebugRecording(handle);
+  if (ret_val != kNoError) {
+    nr_bytes_left_for_log = -1;
+  }
+  return ret_val;
+#else
+  return kUnsupportedFunctionError;
+#endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
+}
+
 int AudioProcessingImpl::StartDebugRecordingForPlatformFile(
     rtc::PlatformFile handle) {
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
   return StartDebugRecording(stream);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
   CriticalSectionScoped crit_scoped(crit_);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
@@ skipping 217 matching lines @@
   }
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
 // TODO(ajm): Use little-endian "on the wire". For the moment, we can be
 //            pretty safe in assuming little-endian.
 #endif
 
   if (!event_msg_->SerializeToString(&event_str_)) {
     return kUnspecifiedError;
   }
 
+  if (nr_bytes_left_for_log >= 0) {
+    nr_bytes_left_for_log -= (sizeof(int32_t) + event_str_.size());

[kwiberg-webrtc, 2015/10/25 02:29:12]

You use event_str_.length() below. Are they the same? You should probably
standardize on one of them even if they are.

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

for std::string, .size() and .length() are exactly the same. I personally like
.size() because it's the same across all of the STL containers, but since the
old code below already used .length() I will change this code to also use it.

+    if (nr_bytes_left_for_log < 0) {
+      // Not enough bytes are left to write this message, so stop logging.
+      nr_bytes_left_for_log = -1;
+      debug_file_->CloseFile();

[the sun, 2015/10/26 10:37:20]

Can you add:
RTC_DCHECK(debug_file_->Open());
at the start of this function?

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

I agree. I'm also a bit uneasy about setting nr_bytes_left_for_log = -1 after
having written the allowed file size. To the casual reader, this looks like
removing the limit once the limit was removed.

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

I added the RTC_DCHECK. I removed the code setting the nr_bytes_left_for_log to
-1, since it is no longer necessary now.

+      return kUnspecifiedError;
+    }
+  }
+
   // Write message preceded by its size.
   if (!debug_file_->Write(&size, sizeof(int32_t))) {
     return kFileError;
   }
   if (!debug_file_->Write(event_str_.data(), event_str_.length())) {
     return kFileError;
   }
 
   event_msg_->Clear();
 
@@ skipping 57 matching lines @@
 
   event_msg_->set_type(audioproc::Event::CONFIG);
   event_msg_->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile());
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc