Revert of Implement AudioReceiveStream::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 47 matching lines @@
 #else
 static const int kFakeDeviceId = 1;
 #endif
 
 static const int kOpusBandwidthNb = 4000;
 static const int kOpusBandwidthMb = 6000;
 static const int kOpusBandwidthWb = 8000;
 static const int kOpusBandwidthSwb = 12000;
 static const int kOpusBandwidthFb = 20000;
 
+static const webrtc::NetworkStatistics kNetStats = {
+    1,  // uint16_t currentBufferSize;
+    2,  // uint16_t preferredBufferSize;
+    true,  // bool jitterPeaksFound;
+    1234,  // uint16_t currentPacketLossRate;
+    567,   // uint16_t currentDiscardRate;
+    8901,  // uint16_t currentExpandRate;
+    234,  // uint16_t currentSpeechExpandRate;
+    5678, // uint16_t currentPreemptiveRate;
+    9012, // uint16_t currentAccelerateRate;
+    3456, // uint16_t currentSecondaryDecodedRate;
+    7890, // int32_t clockDriftPPM;
+    54,  // meanWaitingTimeMs;
+    32,  // int medianWaitingTimeMs;
+    1,  // int minWaitingTimeMs;
+    98, // int maxWaitingTimeMs;
+    7654,  // int addedSamples;
+};  // These random but non-trivial numbers are used for testing.
+
 #define WEBRTC_CHECK_CHANNEL(channel) \
   if (channels_.find(channel) == channels_.end()) return -1;
 
 #define WEBRTC_ASSERT_CHANNEL(channel) \
   RTC_DCHECK(channels_.find(channel) != channels_.end());
 
 // Verify the header extension ID, if enabled, is within the bounds specified in
 // [RFC5285]: 1-14 inclusive.
 #define WEBRTC_CHECK_HEADER_EXTENSION_ID(enable, id) \
   do { \
@@ skipping 77 matching lines @@
     return experimental_ns_enabled_;
   }
 
  private:
   bool experimental_ns_enabled_;
 };
 
 class FakeWebRtcVoiceEngine
     : public webrtc::VoEAudioProcessing,
       public webrtc::VoEBase, public webrtc::VoECodec, public webrtc::VoEDtmf,
-      public webrtc::VoEHardware,
+      public webrtc::VoEHardware, public webrtc::VoENetEqStats,
       public webrtc::VoENetwork, public webrtc::VoERTP_RTCP,
-      public webrtc::VoEVolumeControl {
+      public webrtc::VoEVideoSync, public webrtc::VoEVolumeControl {
  public:
   struct DtmfInfo {
     DtmfInfo()
       : dtmf_event_code(-1),
         dtmf_out_of_band(false),
         dtmf_length_ms(-1) {}
     int dtmf_event_code;
     bool dtmf_out_of_band;
     int dtmf_length_ms;
   };
@@ skipping 323 matching lines @@
     channels_[channel]->send_codec = codec;
     ++num_set_send_codecs_;
     return 0;
   }
   WEBRTC_FUNC(GetSendCodec, (int channel, webrtc::CodecInst& codec)) {
     WEBRTC_CHECK_CHANNEL(channel);
     codec = channels_[channel]->send_codec;
     return 0;
   }
   WEBRTC_STUB(SetBitRate, (int channel, int bitrate_bps));
-  WEBRTC_STUB(GetRecCodec, (int channel, webrtc::CodecInst& codec));
+  WEBRTC_FUNC(GetRecCodec, (int channel, webrtc::CodecInst& codec)) {
+    WEBRTC_CHECK_CHANNEL(channel);
+    const Channel* c = channels_[channel];
+    for (std::list<std::string>::const_iterator it_packet = c->packets.begin();
+        it_packet != c->packets.end(); ++it_packet) {
+      int pltype;
+      if (!GetRtpPayloadType(it_packet->data(), it_packet->length(), &pltype)) {
+        continue;
+      }
+      for (std::vector<webrtc::CodecInst>::const_iterator it_codec =
+          c->recv_codecs.begin(); it_codec != c->recv_codecs.end();
+          ++it_codec) {
+        if (it_codec->pltype == pltype) {
+          codec = *it_codec;
+          return 0;
+        }
+      }
+    }
+    return -1;
+  }
   WEBRTC_FUNC(SetRecPayloadType, (int channel,
                                   const webrtc::CodecInst& codec)) {
     WEBRTC_CHECK_CHANNEL(channel);
     Channel* ch = channels_[channel];
     if (ch->playout)
       return -1;  // Channel is in use.
     // Check if something else already has this slot.
     if (codec.pltype != -1) {
       for (std::vector<webrtc::CodecInst>::iterator it =
           ch->recv_codecs.begin(); it != ch->recv_codecs.end(); ++it) {
@@ skipping 158 matching lines @@
     *samples_per_sec = playout_sample_rate_;
     return 0;
   }
   WEBRTC_STUB(EnableBuiltInAEC, (bool enable));
   virtual bool BuiltInAECIsAvailable() const { return false; }
   WEBRTC_STUB(EnableBuiltInAGC, (bool enable));
   virtual bool BuiltInAGCIsAvailable() const { return false; }
   WEBRTC_STUB(EnableBuiltInNS, (bool enable));
   virtual bool BuiltInNSIsAvailable() const { return false; }
 
+  // webrtc::VoENetEqStats
+  WEBRTC_FUNC(GetNetworkStatistics, (int channel,
+                                     webrtc::NetworkStatistics& ns)) {
+    WEBRTC_CHECK_CHANNEL(channel);
+    memcpy(&ns, &kNetStats, sizeof(webrtc::NetworkStatistics));
+    return 0;
+  }
+
+  WEBRTC_FUNC_CONST(GetDecodingCallStatistics, (int channel,
+      webrtc::AudioDecodingCallStats*)) {
+    WEBRTC_CHECK_CHANNEL(channel);
+    return 0;
+  }
+
   // webrtc::VoENetwork
   WEBRTC_FUNC(RegisterExternalTransport, (int channel,
                                           webrtc::Transport& transport)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->external_transport = true;
     return 0;
   }
   WEBRTC_FUNC(DeRegisterExternalTransport, (int channel)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->external_transport = false;
@@ skipping 128 matching lines @@
     redPayloadtype = channels_[channel]->red_type;
     return 0;
   }
   WEBRTC_FUNC(SetNACKStatus, (int channel, bool enable, int maxNoPackets)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->nack = enable;
     channels_[channel]->nack_max_packets = maxNoPackets;
     return 0;
   }
 
+  // webrtc::VoEVideoSync
+  WEBRTC_STUB(GetPlayoutBufferSize, (int& bufferMs));
+  WEBRTC_STUB(GetPlayoutTimestamp, (int channel, unsigned int& timestamp));
+  WEBRTC_STUB(GetRtpRtcp, (int, webrtc::RtpRtcp**, webrtc::RtpReceiver**));
+  WEBRTC_STUB(SetInitTimestamp, (int channel, unsigned int timestamp));
+  WEBRTC_STUB(SetInitSequenceNumber, (int channel, short sequenceNumber));
+  WEBRTC_STUB(SetMinimumPlayoutDelay, (int channel, int delayMs));
+  WEBRTC_STUB(SetInitialPlayoutDelay, (int channel, int delay_ms));
+  WEBRTC_STUB(GetDelayEstimate, (int channel, int* jitter_buffer_delay_ms,
+                                 int* playout_buffer_delay_ms));
+  WEBRTC_STUB_CONST(GetLeastRequiredDelayMs, (int channel));
+
   // webrtc::VoEVolumeControl
   WEBRTC_STUB(SetSpeakerVolume, (unsigned int));
   WEBRTC_STUB(GetSpeakerVolume, (unsigned int&));
   WEBRTC_STUB(SetMicVolume, (unsigned int));
   WEBRTC_STUB(GetMicVolume, (unsigned int&));
   WEBRTC_STUB(SetInputMute, (int, bool));
   WEBRTC_STUB(GetInputMute, (int, bool&));
   WEBRTC_STUB(GetSpeechInputLevel, (unsigned int&));
   WEBRTC_STUB(GetSpeechOutputLevel, (int, unsigned int&));
   WEBRTC_STUB(GetSpeechInputLevelFullRange, (unsigned int&));
@@ skipping 206 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_