AecDump interface

webrtc/modules/audio_processing/include/audio_processing.h

 /*
  *  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 11 matching lines @@
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/platform_file.h"
 #include "webrtc/modules/audio_processing/beamformer/array_util.h"
 #include "webrtc/modules/audio_processing/include/config.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 struct AecCore;
 
+class AecDump;
 class AudioFrame;
 
 class NonlinearBeamformer;
 
 class StreamConfig;
 class ProcessingConfig;
 
 class EchoCancellation;
 class EchoControlMobile;
 class GainControl;
@@ skipping 398 matching lines @@
   virtual void set_stream_key_pressed(bool key_pressed) = 0;
 
   // Sets a delay |offset| in ms to add to the values passed in through
   // set_stream_delay_ms(). May be positive or negative.
   //
   // Note that this could cause an otherwise valid value passed to
   // set_stream_delay_ms() to return an error.
   virtual void set_delay_offset_ms(int offset) = 0;
   virtual int delay_offset_ms() const = 0;
 
+  // Starts recording debugging information through the provided
+  // webrtc::AecDump. Log file and maximum file size logic is supposed
+  // to be handled by implementing instance of AecDump. Calling this
+  // method when logging is active resets the active AecDump with a
+  // new one. This causes the d-tor of the earlier AecDump to be
+  // called. The d-tor call may block until all pending logging tasks

[peah-webrtc, 2017/04/07 12:57:16]

Is the blocking needed because the taskqueue must be destroyed as well?

[aleloi, 2017/04/12 11:05:30]

The destructor of the AecDump impl uses this pattern:

rtc::Event thread_sync_event(false /* manual_reset */, false);
worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); });
thread_sync_event.Wait(rtc::Event::kForever);

The 3rd line blocks the task in the 2nd line has been run. The queue is FIFO, so
all pending tasks must be done first. 

This pattern is used in other places, e.g. AudioSendStream::Stop(),
VideoSendStream(). It simplifies resource handling with task queues: the member
variables of AecDump may only be deallocated when there are no queued tasks with
pointers to them.

The task queue itself is not destroyed.

+  // are completed.
+  virtual void StartDebugRecording(std::unique_ptr<AecDump> aec_dump) = 0;
+
   // Starts recording debugging information to a file specified by |filename|,
   // a NULL-terminated string. If there is an ongoing recording, the old file
   // will be closed, and recording will continue in the newly specified file.
   // An already existing file will be overwritten without warning. A maximum
   // file size (in bytes) for the log can be specified. The logging is stopped
   // once the limit has been reached. If max_log_size_bytes is set to a value
   // <= 0, no limit will be used.
   static const size_t kMaxFilenameSize = 1024;
   virtual int StartDebugRecording(const char filename[kMaxFilenameSize],
                                   int64_t max_log_size_bytes) = 0;
@@ skipping 616 matching lines @@
   // This does not impact the size of frames passed to |ProcessStream()|.
   virtual int set_frame_size_ms(int size) = 0;
   virtual int frame_size_ms() const = 0;
 
  protected:
   virtual ~VoiceDetection() {}
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_