Implement AudioSendStream::GetStats().

talk/media/webrtc/fakewebrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 27 matching lines @@
 #include "talk/media/webrtc/webrtcvoe.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 
 namespace cricket {
 
-// Function returning stats will return these values
-// for all values based on type.
-const int kIntStatValue = 123;
-const float kFractionLostStatValue = 0.5;
-
 static const char kFakeDefaultDeviceName[] = "Fake Default";
 static const int kFakeDefaultDeviceId = -1;
 static const char kFakeDeviceName[] = "Fake Device";
 #ifdef WIN32
 static const int kFakeDeviceId = 0;
 #else
 static const int kFakeDeviceId = 1;
 #endif
 
 static const int kOpusBandwidthNb = 4000;
@@ skipping 198 matching lines @@
   }
   ~FakeWebRtcVoiceEngine() {
     // Ought to have all been deleted by the WebRtcVoiceMediaChannel
     // destructors, but just in case ...
     for (std::map<int, Channel*>::const_iterator i = channels_.begin();
          i != channels_.end(); ++i) {
       delete i->second;
     }
   }
 
+  bool ec_metrics_enabled() { return ec_metrics_enabled_; }

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

nit: const?

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

Yeah!

+
   bool IsInited() const { return inited_; }
   int GetLastChannel() const { return last_channel_; }
   int GetChannelFromLocalSsrc(uint32_t local_ssrc) const {
     for (std::map<int, Channel*>::const_iterator iter = channels_.begin();
          iter != channels_.end(); ++iter) {
       if (local_ssrc == iter->second->send_ssrc)
         return iter->first;
     }
     return -1;
   }
   int GetNumChannels() const { return static_cast<int>(channels_.size()); }
+  uint32_t GetLocalSSRC(int channel) {
+    return channels_[channel]->send_ssrc;
+  }
   bool GetPlayout(int channel) {
     return channels_[channel]->playout;
   }
   bool GetSend(int channel) {
     return channels_[channel]->send;
   }
   bool GetVAD(int channel) {
     return channels_[channel]->vad;
   }
   bool GetOpusDtx(int channel) {
@@ skipping 428 matching lines @@
 
   WEBRTC_STUB(ReceivedRTCPPacket, (int channel, const void* data,
                                    size_t length));
 
   // webrtc::VoERTP_RTCP
   WEBRTC_FUNC(SetLocalSSRC, (int channel, unsigned int ssrc)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->send_ssrc = ssrc;
     return 0;
   }
-  WEBRTC_FUNC(GetLocalSSRC, (int channel, unsigned int& ssrc)) {
-    WEBRTC_CHECK_CHANNEL(channel);
-    ssrc = channels_[channel]->send_ssrc;
-    return 0;
-  }
+  WEBRTC_STUB(GetLocalSSRC, (int channel, unsigned int& ssrc));
   WEBRTC_STUB(GetRemoteSSRC, (int channel, unsigned int& ssrc));
   WEBRTC_FUNC(SetSendAudioLevelIndicationStatus, (int channel, bool enable,
       unsigned char id)) {
     WEBRTC_CHECK_CHANNEL(channel);
     WEBRTC_CHECK_HEADER_EXTENSION_ID(enable, id);
     channels_[channel]->send_audio_level_ext_ = (enable) ? id : -1;
     return 0;
   }
   WEBRTC_FUNC(SetReceiveAudioLevelIndicationStatus, (int channel, bool enable,
       unsigned char id)) {
@@ skipping 21 matching lines @@
   WEBRTC_STUB(GetRTCPStatus, (int channel, bool& enabled));
   WEBRTC_STUB(SetRTCP_CNAME, (int channel, const char cname[256]));
   WEBRTC_STUB(GetRTCP_CNAME, (int channel, char cname[256]));
   WEBRTC_STUB(GetRemoteRTCP_CNAME, (int channel, char* cname));
   WEBRTC_STUB(GetRemoteRTCPData, (int channel, unsigned int& NTPHigh,
                                   unsigned int& NTPLow,
                                   unsigned int& timestamp,
                                   unsigned int& playoutTimestamp,
                                   unsigned int* jitter,
                                   unsigned short* fractionLost));
-  WEBRTC_FUNC(GetRemoteRTCPReportBlocks,
-              (int channel, std::vector<webrtc::ReportBlock>* receive_blocks)) {
-    WEBRTC_CHECK_CHANNEL(channel);
-    webrtc::ReportBlock block;
-    block.source_SSRC = channels_[channel]->send_ssrc;
-    webrtc::CodecInst send_codec = channels_[channel]->send_codec;
-    if (send_codec.pltype >= 0) {
-      block.fraction_lost = (unsigned char)(kFractionLostStatValue * 256);
-      if (send_codec.plfreq / 1000 > 0) {
-        block.interarrival_jitter = kIntStatValue * (send_codec.plfreq / 1000);
-      }
-      block.cumulative_num_packets_lost = kIntStatValue;
-      block.extended_highest_sequence_number = kIntStatValue;
-      receive_blocks->push_back(block);
-    }
-    return 0;
-  }
+  WEBRTC_STUB(GetRemoteRTCPReportBlocks,
+              (int channel, std::vector<webrtc::ReportBlock>* receive_blocks));
   WEBRTC_STUB(GetRTPStatistics, (int channel, unsigned int& averageJitterMs,
                                  unsigned int& maxJitterMs,
                                  unsigned int& discardedPackets));
-  WEBRTC_FUNC(GetRTCPStatistics, (int channel, webrtc::CallStatistics& stats)) {
-    WEBRTC_CHECK_CHANNEL(channel);
-    stats.fractionLost = static_cast<int16_t>(kIntStatValue);
-    stats.cumulativeLost = kIntStatValue;
-    stats.extendedMax = kIntStatValue;
-    stats.jitterSamples = kIntStatValue;
-    stats.rttMs = kIntStatValue;
-    stats.bytesSent = kIntStatValue;
-    stats.packetsSent = kIntStatValue;
-    stats.bytesReceived = kIntStatValue;
-    stats.packetsReceived = kIntStatValue;
-    return 0;
-  }
+  WEBRTC_STUB(GetRTCPStatistics, (int channel, webrtc::CallStatistics& stats));
   WEBRTC_FUNC(SetREDStatus, (int channel, bool enable, int redPayloadtype)) {
     return SetFECStatus(channel, enable, redPayloadtype);
   }
   // TODO(minyue): remove the below function when transition to SetREDStatus
   //               is finished.
   WEBRTC_FUNC(SetFECStatus, (int channel, bool enable, int redPayloadtype)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->red = enable;
     channels_[channel]->red_type = redPayloadtype;
     return 0;
@@ skipping 105 matching lines @@
   WEBRTC_STUB(SetRxAgcConfig, (int channel, webrtc::AgcConfig config));
   WEBRTC_STUB(GetRxAgcConfig, (int channel, webrtc::AgcConfig& config));
 
   WEBRTC_STUB(RegisterRxVadObserver, (int, webrtc::VoERxVadCallback&));
   WEBRTC_STUB(DeRegisterRxVadObserver, (int channel));
   WEBRTC_STUB(VoiceActivityIndicator, (int channel));
   WEBRTC_FUNC(SetEcMetricsStatus, (bool enable)) {
     ec_metrics_enabled_ = enable;
     return 0;
   }
-  WEBRTC_FUNC(GetEcMetricsStatus, (bool& enabled)) {
-    enabled = ec_metrics_enabled_;
-    return 0;
-  }
+  WEBRTC_STUB(GetEcMetricsStatus, (bool& enabled));
   WEBRTC_STUB(GetEchoMetrics, (int& ERL, int& ERLE, int& RERL, int& A_NLP));
   WEBRTC_STUB(GetEcDelayMetrics, (int& delay_median, int& delay_std,
       float& fraction_poor_delays));
 
   WEBRTC_STUB(StartDebugRecording, (const char* fileNameUTF8));
   WEBRTC_STUB(StartDebugRecording, (FILE* handle));
   WEBRTC_STUB(StopDebugRecording, ());
 
   WEBRTC_FUNC(SetTypingDetectionStatus, (bool enable)) {
     typing_detection_enabled_ = enable;
@@ skipping 106 matching lines @@
   int playout_sample_rate_;
   DtmfInfo dtmf_info_;
   FakeAudioProcessing audio_processing_;
 };
 
 #undef WEBRTC_CHECK_HEADER_EXTENSION_ID
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_