Implement AudioSendStream::GetStats().

webrtc/test/fake_voice_engine.h

 /*
  *  Copyright (c) 2015 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_AUDIO_FAKE_VOICE_ENGINE_H_
 #define WEBRTC_AUDIO_FAKE_VOICE_ENGINE_H_
 
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/voice_engine/voice_engine_impl.h"
 
 namespace webrtc {
 namespace test {
 
 // NOTE: This class inherits from VoiceEngineImpl so that its clients will be
 // able to get the various interfaces as usual, via T::GetInterface().
 class FakeVoiceEngine final : public VoiceEngineImpl {
  public:
   const int kSendChannelId = 1;
-  const int kReceiveChannelId = 2;
-
+  const int kRecvChannelId = 2;

[tommi, 2015/10/23 12:50:37]

I think these should all be static and be referenced via the class name (not an
instance).

[the sun, 2015/10/23 15:14:17]

Ok, you get the .cc :)

+  const uint32_t kSendSsrc = 665;
+  const uint32_t kRecvSsrc = 667;
+  const int kSendEchoDelayMedian = 254;
+  const int kSendEchoDelayStdDev = -3;
+  const int kSendEchoReturnLoss = -65;
+  const int kSendEchoReturnLossEnhancement = 101;
   const int kRecvJitterBufferDelay = -7;
   const int kRecvPlayoutBufferDelay = 302;
+  const unsigned int kSendSpeechInputLevel = 96;
   const unsigned int kRecvSpeechOutputLevel = 99;
 
   FakeVoiceEngine() : VoiceEngineImpl(new Config(), true) {
     // Increase ref count so this object isn't automatically deleted whenever
     // interfaces are Release():d.
     ++_ref_count;
   }
   ~FakeVoiceEngine() override {
     // Decrease ref count before base class d-tor is called; otherwise it will
     // trigger an assertion.
     --_ref_count;
   }
 
+  const CallStatistics& GetSendCallStats() const {
+    static const CallStatistics kStats = {

[tommi, 2015/10/23 12:50:37]

I'm a bit on the fence whether using statics like this is a good idea.  I don't
think this really needs to be optimized, so can we have a const stats_ member
variable instead?  The thing I'm worried about is not so much exactly this
particular use of the pattern but the pattern itself.

It has the potential to cause unwanted side effects if more than one instance of
the class attempts to initialize the static on different threads.  We could
either have a race if static initialization is not thread safe (current default
build config) or contention.
If we use this pattern then with a non-const static variable, one test touching
the static variable could affect the outcome of another test (i.e. singleton
anti pattern).

Actually, why do these methods need to return a reference?  (they're not
overrides, right?)

[the sun, 2015/10/23 15:14:17]

I've made this static const structs and moved them to the .cc.

[kwiberg-webrtc, 2015/10/25 02:07:43]

CallStatistics looks like a POD to me (if I'm looking at the right
definition). If it is, shouldn't this just be stored in the read-only
data segment, with no dynamic initialization at all? (I made a toy
example to make sure, and that's exactly what happens.)

I guess it's problematic that it can be hard to tell, though. If I add
a std::string member to the struct, dynamic initialization starts
happening without the source code at the call site having to change at
all. Once we have the C++11 standard library, I presume we could prove
safety with something like

  static_assert(std::is_trivial<CallStatistics>::value);
  static const CallStatistics kStats = {
    1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123
  };

(Caveat: I just made this up. Check with a C++ expert before relying on
std::is_trivial to imply that the compiler can always put the
constructed object in the rodata segment.)

[the sun, 2015/10/26 09:11:02]

So now that the structs are static const members of the class, initialization
and any allocations happen before they're used.

+      1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123
+    };
+    return kStats;
+  }
+
+  const CodecInst& GetSendCodecInst() const {
+    static const CodecInst kStats = {
+      -121, "codec_name_send", 48000, -231, -451, -671
+    };
+    return kStats;
+  }
+
+  const ReportBlock& GetSendReportBlock() const {
+    static const ReportBlock kBlock = {
+      456, 780, 123, 567, 890, 132, 143, 13354
+    };
+    return kBlock;
+  }
+
   const CallStatistics& GetRecvCallStats() const {
     static const CallStatistics kStats = {
-      345, 678, 901, 234, -1, 0, 0, 567, 890, 123
+      345, 678, 901, 234, -12, 3456, 7890, 567, 890, 123
     };
     return kStats;
   }
 
-  const CodecInst& GetRecvRecCodecInst() const {
+  const CodecInst& GetRecvCodecInst() const {
     static const CodecInst kStats = {
-      123, "codec_name", 96000, -1, -1, -1
+      123, "codec_name_recv", 96000, -187, -198, -103
     };
     return kStats;
   }
 
   const NetworkStatistics& GetRecvNetworkStats() const {
     static const NetworkStatistics kStats = {
       123, 456, false, 0, 0, 789, 12, 345, 678, 901, -1, -1, -1, -1, -1, 0
     };
     return kStats;
   }
 
   const AudioDecodingCallStats& GetRecvAudioDecodingCallStats() const {
     static AudioDecodingCallStats stats;
     if (stats.calls_to_silence_generator == 0) {
       stats.calls_to_silence_generator = 234;
       stats.calls_to_neteq = 567;
       stats.decoded_normal = 890;
       stats.decoded_plc = 123;
       stats.decoded_cng = 456;
       stats.decoded_plc_cng = 789;
     }
     return stats;
   }
 
+  // VoEAudioProcessing
+  int SetNsStatus(bool enable, NsModes mode = kNsUnchanged) override {
+    return -1;
+  }
+  int GetNsStatus(bool& enabled, NsModes& mode) override { return -1; }
+  int SetAgcStatus(bool enable, AgcModes mode = kAgcUnchanged) override {
+    return -1;
+  }
+  int GetAgcStatus(bool& enabled, AgcModes& mode) override { return -1; }
+  int SetAgcConfig(AgcConfig config) override { return -1; }
+  int GetAgcConfig(AgcConfig& config) override { return -1; }
+  int SetEcStatus(bool enable, EcModes mode = kEcUnchanged) override {
+    return -1;
+  }
+  int GetEcStatus(bool& enabled, EcModes& mode) override { return -1; }
+  int EnableDriftCompensation(bool enable) override { return -1; }
+  bool DriftCompensationEnabled() override { return false; }
+  void SetDelayOffsetMs(int offset) override {}
+  int DelayOffsetMs() override { return -1; }
+  int SetAecmMode(AecmModes mode = kAecmSpeakerphone,
+                  bool enableCNG = true) override { return -1; }
+  int GetAecmMode(AecmModes& mode, bool& enabledCNG) override { return -1; }
+  int EnableHighPassFilter(bool enable) override { return -1; }
+  bool IsHighPassFilterEnabled() override { return false; }
+  int SetRxNsStatus(int channel,
+                    bool enable,
+                    NsModes mode = kNsUnchanged) override { return -1; }
+  int GetRxNsStatus(int channel, bool& enabled, NsModes& mode) override {
+    return -1;
+  }
+  int SetRxAgcStatus(int channel,
+                     bool enable,
+                     AgcModes mode = kAgcUnchanged) override { return -1; }
+  int GetRxAgcStatus(int channel, bool& enabled, AgcModes& mode) override {
+    return -1;
+  }
+  int SetRxAgcConfig(int channel, AgcConfig config) override { return -1; }
+  int GetRxAgcConfig(int channel, AgcConfig& config) override { return -1; }
+  int RegisterRxVadObserver(int channel,
+                            VoERxVadCallback& observer) override { return -1; }
+  int DeRegisterRxVadObserver(int channel) override { return -1; }
+  int VoiceActivityIndicator(int channel) override { return -1; }
+  int SetEcMetricsStatus(bool enable) override { return -1; }
+  int GetEcMetricsStatus(bool& enabled) override {
+    enabled = true;
+    return 0;
+  }
+  int GetEchoMetrics(int& ERL, int& ERLE, int& RERL, int& A_NLP) override {
+    ERL = kSendEchoReturnLoss;
+    ERLE = kSendEchoReturnLossEnhancement;
+    RERL = -123456789;
+    A_NLP = 123456789;
+    return 0;
+  }
+  int GetEcDelayMetrics(int& delay_median,
+                        int& delay_std,
+                        float& fraction_poor_delays) override {
+    delay_median = kSendEchoDelayMedian;
+    delay_std = kSendEchoDelayStdDev;
+    fraction_poor_delays = -12345.7890;
+    return 0;
+  }
+  int StartDebugRecording(const char* fileNameUTF8) override { return -1; }
+  int StartDebugRecording(FILE* file_handle) override { return -1; }
+  int StopDebugRecording() override { return -1; }
+  int SetTypingDetectionStatus(bool enable) override { return -1; }
+  int GetTypingDetectionStatus(bool& enabled) override { return -1; }
+  int TimeSinceLastTyping(int& seconds) override { return -1; }
+  int SetTypingDetectionParameters(int timeWindow,
+                                   int costPerTyping,
+                                   int reportingThreshold,
+                                   int penaltyDecay,
+                                   int typeEventDelay = 0) override {
+    return -1;
+  }
+  void EnableStereoChannelSwapping(bool enable) override {}
+  bool IsStereoChannelSwappingEnabled() override { return false; }
+
   // VoEBase
   int RegisterVoiceEngineObserver(VoiceEngineObserver& observer) override {
     return -1;
   }
   int DeRegisterVoiceEngineObserver() override { return -1; }
   int Init(AudioDeviceModule* external_adm = NULL,
            AudioProcessing* audioproc = NULL) override { return -1; }
   AudioProcessing* audio_processing() override { return nullptr; }
   int Terminate() override { return -1; }
   int CreateChannel() override { return -1; }
   int CreateChannel(const Config& config) override { return -1; }
   int DeleteChannel(int channel) override { return -1; }
   int StartReceive(int channel) override { return -1; }
   int StopReceive(int channel) override { return -1; }
   int StartPlayout(int channel) override { return -1; }
   int StopPlayout(int channel) override { return -1; }
   int StartSend(int channel) override { return -1; }
   int StopSend(int channel) override { return -1; }
   int GetVersion(char version[1024]) override { return -1; }
   int LastError() override { return -1; }
   AudioTransport* audio_transport() { return nullptr; }
   int AssociateSendChannel(int channel, int accociate_send_channel) override {
     return -1;
   }
 
   // VoECodec
   int NumOfCodecs() override { return -1; }
   int GetCodec(int index, CodecInst& codec) override { return -1; }
   int SetSendCodec(int channel, const CodecInst& codec) override { return -1; }
-  int GetSendCodec(int channel, CodecInst& codec) override { return -1; }
+  int GetSendCodec(int channel, CodecInst& codec) override {
+    EXPECT_EQ(channel, kSendChannelId);
+    codec = GetSendCodecInst();
+    return 0;
+  }
   int SetBitRate(int channel, int bitrate_bps) override { return -1; }
   int GetRecCodec(int channel, CodecInst& codec) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
-    codec = GetRecvRecCodecInst();
+    EXPECT_EQ(channel, kRecvChannelId);
+    codec = GetRecvCodecInst();
     return 0;
   }
   int SetRecPayloadType(int channel, const CodecInst& codec) override {
     return -1;
   }
   int GetRecPayloadType(int channel, CodecInst& codec) override { return -1; }
   int SetSendCNPayloadType(int channel, int type,
       PayloadFrequencies frequency = kFreq16000Hz) override { return -1; }
   int SetVADStatus(int channel,
                    bool enable,
@@ skipping 165 matching lines @@
   int ReceivedRTPPacket(int channel,
                         const void* data,
                         size_t length,
                         const PacketTime& packet_time) override { return -1; }
   int ReceivedRTCPPacket(int channel,
                          const void* data,
                          size_t length) { return -1; }
 
   // VoENetEqStats
   int GetNetworkStatistics(int channel, NetworkStatistics& stats) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
+    EXPECT_EQ(channel, kRecvChannelId);
     stats = GetRecvNetworkStats();
     return 0;
   }
   int GetDecodingCallStatistics(int channel,
                                 AudioDecodingCallStats* stats) const override {
-    EXPECT_EQ(channel, kReceiveChannelId);
+    EXPECT_EQ(channel, kRecvChannelId);
     EXPECT_NE(nullptr, stats);
     *stats = GetRecvAudioDecodingCallStats();
     return 0;
   }
 
   // VoERTP_RTCP
   int SetLocalSSRC(int channel, unsigned int ssrc) override { return -1; }
-  int GetLocalSSRC(int channel, unsigned int& ssrc) override { return -1; }
-  int GetRemoteSSRC(int channel, unsigned int& ssrc) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
+  int GetLocalSSRC(int channel, unsigned int& ssrc) override {
+    EXPECT_EQ(channel, kSendChannelId);
     ssrc = 0;
     return 0;
   }
+  int GetRemoteSSRC(int channel, unsigned int& ssrc) override {
+    EXPECT_EQ(channel, kRecvChannelId);
+    ssrc = 0;
+    return 0;
+  }
   int SetSendAudioLevelIndicationStatus(int channel,
                                         bool enable,
                                         unsigned char id = 1) override {
     return -1;
   }
   int SetSendAbsoluteSenderTimeStatus(int channel,
                                       bool enable,
                                       unsigned char id) override { return -1; }
   int SetReceiveAbsoluteSenderTimeStatus(int channel,
                                          bool enable,
@@ skipping 12 matching lines @@
                         unsigned int& playoutTimestamp,
                         unsigned int* jitter = NULL,
                         unsigned short* fractionLost = NULL) override {
     return -1;
   }
   int GetRTPStatistics(int channel,
                        unsigned int& averageJitterMs,
                        unsigned int& maxJitterMs,
                        unsigned int& discardedPackets) override { return -1; }
   int GetRTCPStatistics(int channel, CallStatistics& stats) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
-    stats = GetRecvCallStats();
+    if (channel == kSendChannelId) {
+      stats = GetSendCallStats();
+    } else {
+      EXPECT_EQ(channel, kRecvChannelId);
+      stats = GetRecvCallStats();
+    }
     return 0;
   }
   int GetRemoteRTCPReportBlocks(
       int channel,
-      std::vector<ReportBlock>* receive_blocks) override { return -1; }
+      std::vector<ReportBlock>* receive_blocks) override {
+    EXPECT_EQ(channel, kSendChannelId);
+    EXPECT_NE(receive_blocks, nullptr);
+    EXPECT_EQ(receive_blocks->size(), 0u);
+    webrtc::ReportBlock block = GetSendReportBlock();
+    receive_blocks->push_back(block);   // Has wrong SSRC.
+    block.source_SSRC = kSendSsrc;
+    receive_blocks->push_back(block);   // Correct block.
+    block.fraction_lost = 0;
+    receive_blocks->push_back(block);   // Duplicate SSRC, bad fraction_lost.
+    return 0;
+  }
   int SetNACKStatus(int channel, bool enable, int maxNoPackets) override {
     return -1;
   }
 
   // VoEVideoSync
   int GetPlayoutBufferSize(int& buffer_ms) override { return -1; }
   int SetMinimumPlayoutDelay(int channel, int delay_ms) override { return -1; }
   int SetInitialPlayoutDelay(int channel, int delay_ms) override { return -1; }
   int GetDelayEstimate(int channel,
                        int* jitter_buffer_delay_ms,
                        int* playout_buffer_delay_ms) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
+    EXPECT_EQ(channel, kRecvChannelId);
     *jitter_buffer_delay_ms = kRecvJitterBufferDelay;
     *playout_buffer_delay_ms = kRecvPlayoutBufferDelay;
     return 0;
   }
   int GetLeastRequiredDelayMs(int channel) const override { return -1; }
   int SetInitTimestamp(int channel, unsigned int timestamp) override {
     return -1;
   }
   int SetInitSequenceNumber(int channel, short sequenceNumber) override {
     return -1;
   }
   int GetPlayoutTimestamp(int channel, unsigned int& timestamp) override {
     return -1;
   }
   int GetRtpRtcp(int channel,
                  RtpRtcp** rtpRtcpModule,
                  RtpReceiver** rtp_receiver) override { return -1; }
 
   // VoEVolumeControl
   int SetSpeakerVolume(unsigned int volume) override { return -1; }
   int GetSpeakerVolume(unsigned int& volume) override { return -1; }
   int SetMicVolume(unsigned int volume) override { return -1; }
   int GetMicVolume(unsigned int& volume) override { return -1; }
   int SetInputMute(int channel, bool enable) override { return -1; }
   int GetInputMute(int channel, bool& enabled) override { return -1; }
   int GetSpeechInputLevel(unsigned int& level) override { return -1; }
   int GetSpeechOutputLevel(int channel, unsigned int& level) override {
     return -1;
   }
-  int GetSpeechInputLevelFullRange(unsigned int& level) override { return -1; }
+  int GetSpeechInputLevelFullRange(unsigned int& level) override {
+    level = kSendSpeechInputLevel;
+    return 0;
+  }
   int GetSpeechOutputLevelFullRange(int channel,
                                     unsigned int& level) override {
-    EXPECT_EQ(channel, kReceiveChannelId);
+    EXPECT_EQ(channel, kRecvChannelId);
     level = kRecvSpeechOutputLevel;
     return 0;
   }
   int SetChannelOutputVolumeScaling(int channel, float scaling) override {
     return -1;
   }
   int GetChannelOutputVolumeScaling(int channel, float& scaling) override {
     return -1;
   }
   int SetOutputVolumePan(int channel, float left, float right) override {
     return -1;
   }
   int GetOutputVolumePan(int channel, float& left, float& right) override {
     return -1;
   }
 };
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_AUDIO_FAKE_VOICE_ENGINE_H_