Avoid calling PostTask in audio callbacks

webrtc/modules/audio_device/audio_device_buffer.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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_DEVICE_AUDIO_DEVICE_BUFFER_H_
 #define WEBRTC_MODULES_AUDIO_DEVICE_AUDIO_DEVICE_BUFFER_H_
 
 #include "webrtc/base/buffer.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 // Delta times between two successive playout callbacks are limited to this
 // value before added to an internal array.
 const size_t kMaxDeltaTimeInMs = 500;
 // TODO(henrika): remove when no longer used by external client.
 const size_t kMaxBufferSizeBytes = 3840;  // 10ms in stereo @ 96kHz
 
 class AudioDeviceObserver;
 
 class AudioDeviceBuffer {
  public:
   enum LogState {
     LOG_START = 0,
     LOG_STOP,
     LOG_ACTIVE,
   };
 
+  struct Stats {
+    Stats()
+        : rec_callbacks(0),

[the sun, 2017/02/02 19:38:38]

nit: please use inline class member initialization instead. Less code and less
error prone.

[henrika_webrtc, 2017/02/03 09:00:54]

Done.

+          play_callbacks(0),
+          rec_samples(0),
+          play_samples(0),
+          max_rec_level(0),
+          max_play_level(0) {}
+
+    void ResetRecStats() {
+      rec_callbacks = 0;
+      rec_samples = 0;
+      max_rec_level = 0;
+    }
+
+    void ResetPlayStats() {
+      play_callbacks = 0;
+      play_samples = 0;
+      max_play_level = 0;
+    }
+
+    // Total number of recording callbacks where the source provides 10ms audio
+    // data each time.
+    uint64_t rec_callbacks;
+
+    // Total number of playback callbacks where the sink asks for 10ms audio
+    // data each time.
+    uint64_t play_callbacks;
+
+    // Total number of recorded audio samples.
+    uint64_t rec_samples;
+
+    // Total number of played audio samples.
+    uint64_t play_samples;
+
+    // Contains max level (max(abs(x))) of recorded audio packets over the last
+    // 10 seconds where a new measurement is done twice per second. The level
+    // is reset to zero at each call to LogStats().
+    int16_t max_rec_level;
+
+    // Contains max level of recorded audio packets over the last 10 seconds
+    // where a new measurement is done twice per second.
+    int16_t max_play_level;
+  };
+
   AudioDeviceBuffer();
   virtual ~AudioDeviceBuffer();
 
   void SetId(uint32_t id) {};
   int32_t RegisterAudioCallback(AudioTransport* audio_callback);
 
   void StartPlayout();
   void StartRecording();
   void StopPlayout();
   void StopRecording();
@@ skipping 36 matching lines @@
   void StopPeriodicLogging();
 
   // Called periodically on the internal thread created by the TaskQueue.
   // Updates some stats but dooes it on the task queue to ensure that access of
   // members is serialized hence avoiding usage of locks.
   // state = LOG_START => members are initialized and the timer starts.
   // state = LOG_STOP => no logs are printed and the timer stops.
   // state = LOG_ACTIVE => logs are printed and the timer is kept alive.
   void LogStats(LogState state);
 
-  // Updates counters in each play/record callback but does it on the task
-  // queue to ensure that they can be read by LogStats() without any locks since
-  // each task is serialized by the task queue.
+  // Updates counters in each play/record callback. These counters are later
+  // (periodically) read by LogStats() using a lock.
   void UpdateRecStats(int16_t max_abs, size_t samples_per_channel);
   void UpdatePlayStats(int16_t max_abs, size_t samples_per_channel);
 
   // Clears all members tracking stats for recording and playout.
   // These methods both run on the task queue.
   void ResetRecStats();
   void ResetPlayStats();
 
   // This object lives on the main (creating) thread and most methods are
   // called on that same thread. When audio has started some methods will be
   // called on either a native audio thread for playout or a native thread for
   // recording. Some members are not annotated since they are "protected by
   // design" and adding e.g. a race checker can cause failuries for very few
   // edge cases and it is IMHO not worth the risk to use them in this class.
   // TODO(henrika): see if it is possible to refactor and annotate all members.
 
   // Main thread on which this object is created.
   rtc::ThreadChecker main_thread_checker_;
 
   // Native (platform specific) audio thread driving the playout side.
   rtc::ThreadChecker playout_thread_checker_;
 
   // Native (platform specific) audio thread driving the recording side.
   rtc::ThreadChecker recording_thread_checker_;
 
+  rtc::CriticalSection lock_;
+
   // Task queue used to invoke LogStats() periodically. Tasks are executed on a
   // worker thread but it does not necessarily have to be the same thread for
   // each task.
   rtc::TaskQueue task_queue_;
 
   // Raw pointer to AudioTransport instance. Supplied to RegisterAudioCallback()
   // and it must outlive this object. It is not possible to change this member
   // while any media is active. It is possible to start media without calling
   // RegisterAudioCallback() but that will lead to ignored audio callbacks in
   // both directions where native audio will be acive but no audio samples will
@@ skipping 44 matching lines @@
   // Delay values used by the AEC.
   int play_delay_ms_ ACCESS_ON(recording_thread_checker_);
   int rec_delay_ms_ ACCESS_ON(recording_thread_checker_);
 
   // Contains a clock-drift measurement.
   int clock_drift_ ACCESS_ON(recording_thread_checker_);
 
   // Counts number of times LogStats() has been called.
   size_t num_stat_reports_ ACCESS_ON(task_queue_);
 
-  // Total number of recording callbacks where the source provides 10ms audio
-  // data each time.
-  uint64_t rec_callbacks_ ACCESS_ON(task_queue_);
-
-  // Total number of recording callbacks stored at the last timer task.
-  uint64_t last_rec_callbacks_ ACCESS_ON(task_queue_);
-
-  // Total number of playback callbacks where the sink asks for 10ms audio
-  // data each time.
-  uint64_t play_callbacks_ ACCESS_ON(task_queue_);
-
-  // Total number of playout callbacks stored at the last timer task.
-  uint64_t last_play_callbacks_ ACCESS_ON(task_queue_);
-
-  // Total number of recorded audio samples.
-  uint64_t rec_samples_ ACCESS_ON(task_queue_);
-
-  // Total number of recorded samples stored at the previous timer task.
-  uint64_t last_rec_samples_ ACCESS_ON(task_queue_);
-
-  // Total number of played audio samples.
-  uint64_t play_samples_ ACCESS_ON(task_queue_);
-
-  // Total number of played samples stored at the previous timer task.
-  uint64_t last_play_samples_ ACCESS_ON(task_queue_);
-
-  // Contains max level (max(abs(x))) of recorded audio packets over the last
-  // 10 seconds where a new measurement is done twice per second. The level
-  // is reset to zero at each call to LogStats().
-  int16_t max_rec_level_ ACCESS_ON(task_queue_);
-
-  // Contains max level of recorded audio packets over the last 10 seconds
-  // where a new measurement is done twice per second.
-  int16_t max_play_level_ ACCESS_ON(task_queue_);
-
   // Time stamp of last timer task (drives logging).
   int64_t last_timer_task_time_ ACCESS_ON(task_queue_);
 
   // Counts number of audio callbacks modulo 50 to create a signal when
   // a new storage of audio stats shall be done.
   int16_t rec_stat_count_ ACCESS_ON(recording_thread_checker_);
   int16_t play_stat_count_ ACCESS_ON(playout_thread_checker_);
 
   // Time stamps of when playout and recording starts.
   int64_t play_start_time_ ACCESS_ON(main_thread_checker_);
   int64_t rec_start_time_ ACCESS_ON(main_thread_checker_);
 
+  // Contains counters for playout and recording statistics.
+  Stats stats_ GUARDED_BY(lock_);
+
+  // Stores current stats at each timer task. Used to calculate differences
+  // between two successive timer events.
+  Stats last_stats_ ACCESS_ON(task_queue_);
+
   // Set to true at construction and modified to false as soon as one audio-
   // level estimate larger than zero is detected.
   bool only_silence_recorded_;
 
   // Set to true when logging of audio stats is enabled for the first time in
   // StartPeriodicLogging() and set to false by StopPeriodicLogging().
   // Setting this member to false prevents (possiby invalid) log messages from
   // being printed in the LogStats() task.
   bool log_stats_ ACCESS_ON(task_queue_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_DEVICE_AUDIO_DEVICE_BUFFER_H_