Add PeerConnection::GetAudioLevels (#64)

api/peer_connection_interface.cc

@@ -84,6 +84,17 @@ bool PeerConnectionInterface::ReceiveRtp(uint8_t pt) {
   return false;
 }
 
+// RingRTC change to get audio levels
+void PeerConnectionInterface::GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out) {
+  RTC_LOG(LS_ERROR) << "No GetAudioLevels in dummy implementation";
+  *received_size_out = 0;
+  *captured_out = 0;
+}
+
 PeerConnectionDependencies::PeerConnectionDependencies(
     PeerConnectionObserver* observer_in)
     : observer(observer_in) {}

api/peer_connection_interface.h

@@ -1143,6 +1143,11 @@ class RTC_EXPORT PeerConnectionInterface : public rtc::RefCountInterface {
     RTC_LOG(LS_WARNING) << "Default PeerConnectionInterface::ConfigureAudioEncoders(...) does nothing!";
   }
 
+  virtual void GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out);
 
   // SetBitrate limits the bandwidth allocated for all RTP streams sent by
   // this PeerConnection. Other limitations might affect these limits and

audio/audio_receive_stream.cc

@@ -191,6 +191,11 @@ void AudioReceiveStream::ReconfigureForTesting(
   config_ = config;
 }
 
+// RingRTC change to get recv audio levels
+uint16_t AudioReceiveStream::GetAudioLevel() {
+  return channel_receive_->GetSpeechOutputLevelFullRange();
+}
+
 void AudioReceiveStream::Start() {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   if (playing_) {

audio/audio_receive_stream.h

@@ -141,6 +141,9 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
   // TODO(tommi): Remove this method.
   void ReconfigureForTesting(const webrtc::AudioReceiveStream::Config& config);
 
+  // RingRTC change to get recv audio levels
+  uint16_t GetAudioLevel() override;
+
  private:
   AudioState* audio_state() const;
 

audio/audio_send_stream.h

@@ -112,6 +112,12 @@ class AudioSendStream final : public webrtc::AudioSendStream,
   // RingRTC change to configure opus
   void ConfigureEncoder(const webrtc::AudioEncoder::Config& config) override;
 
+  // RingRTC change to get send/capture audio level
+  uint16_t GetAudioLevel() override {
+    MutexLock lock(&audio_level_lock_);
+    return audio_level_.LevelFullRange();
+  }
+
  private:
   class TimedTransport;
   // Constraints including overhead.

call/audio_receive_stream.h

@@ -194,6 +194,9 @@ class AudioReceiveStream : public MediaReceiveStream {
   // Returns current value of base minimum delay in milliseconds.
   virtual int GetBaseMinimumPlayoutDelayMs() const = 0;
 
+  // RingRTC change to get recv audio levels
+  virtual uint16_t GetAudioLevel() = 0;
+
  protected:
   virtual ~AudioReceiveStream() {}
 };

call/audio_send_stream.h

@@ -196,6 +196,12 @@ class AudioSendStream : public AudioSender {
   virtual void ConfigureEncoder(const webrtc::AudioEncoder::Config& config) {
     RTC_LOG(LS_WARNING) << "Default AudioSendStream::ConfigureEncoder(...) does nothing!";
   }
+
+  // RingRTC change to configure opus to get audio levels
+  virtual uint16_t GetAudioLevel() {
+    RTC_LOG(LS_WARNING) << "Default AudioSendStream::GetAudioLevel() does nothing!";
+    return 0;
+  }
 };
 
 }  // namespace webrtc

media/base/media_channel.h

@@ -155,6 +155,16 @@ struct VideoOptions {
   }
 };
 
+
+// RingRTC change for audio level methods
+// Higher is louder.
+typedef uint16_t AudioLevel;
+
+typedef struct {
+  uint32_t ssrc;
+  AudioLevel level;
+} ReceivedAudioLevel;
+
 class MediaChannel {
  public:
   class NetworkInterface {
@@ -824,6 +834,17 @@ class VoiceMediaChannel : public MediaChannel, public Delayable {
   virtual void ConfigureEncoders(const webrtc::AudioEncoder::Config& config) {
     RTC_LOG(LS_WARNING) << "Default VoiceMediaChannel::ConfigureEncoders(...) does nothing!";
   }
+
+  // RingRTC change to get audio levels
+  virtual void GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out) {
+    RTC_LOG(LS_WARNING) << "Default VoiceMediaChannel::GetAudioLevels does nothing!";
+    *captured_out = 0;
+    *received_size_out = 0;
+  }
 };
 
 // TODO(deadbeef): Rename to VideoSenderParameters, since they're intended to

media/engine/webrtc_voice_engine.cc

@@ -1095,6 +1095,11 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     stream_->ConfigureEncoder(config);
   }
 
+  uint16_t GetAudioLevel() {
+    return stream_->GetAudioLevel();
+  }
+
+
  private:
   void UpdateSendState() {
     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
@@ -1330,6 +1335,11 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
     stream_->SetDepacketizerToDecoderFrameTransformer(frame_transformer);
   }
 
+  // RingRTC change to get audio level
+  uint16_t GetAudioLevel() {
+    return stream_->GetAudioLevel();
+  }
+
  private:
   webrtc::SequenceChecker worker_thread_checker_;
   webrtc::Call* call_ = nullptr;
@@ -2582,4 +2592,30 @@ void WebRtcVoiceMediaChannel::ConfigureEncoders(const webrtc::AudioEncoder::Conf
   }
 }
 
+void WebRtcVoiceMediaChannel::GetAudioLevels(
+    cricket::AudioLevel* captured_out,
+    cricket::ReceivedAudioLevel* received_out,
+    size_t received_out_size,
+    size_t* received_size_out) {
+
+  cricket::AudioLevel captured = 0;
+  for (const auto& kv : send_streams_) {
+    captured = kv.second->GetAudioLevel();
+  }
+
+  size_t received_size = 0;
+  for (const auto& kv : recv_streams_) {
+    if (received_size >= received_out_size) {
+      break;
+    }
+    received_out[received_size++] = cricket::ReceivedAudioLevel {
+      kv.first,
+      kv.second->GetAudioLevel()
+    };
+  }
+
+  *captured_out = captured;
+  *received_size_out = received_size;
+}
+
 }  // namespace cricket

media/engine/webrtc_voice_engine.h

@@ -246,6 +246,13 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
   // RingRTC change to configure opus
   void ConfigureEncoders(const webrtc::AudioEncoder::Config& config) override;
 
+  // RingRTC change to get audio levels
+  void GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out) override;
+
  private:
   bool SetOptions(const AudioOptions& options);
   bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);

pc/channel.cc

@@ -944,6 +944,17 @@ void VoiceChannel::ConfigureEncoders(const webrtc::AudioEncoder::Config& config)
   });
 }
 
+// RingRTC change to get audio levels
+void VoiceChannel::GetAudioLevels(
+    cricket::AudioLevel* captured_out,
+    cricket::ReceivedAudioLevel* received_out,
+    size_t received_out_size,
+    size_t* received_size_out) {
+  worker_thread()->Invoke<void>(RTC_FROM_HERE, [this, captured_out, received_out, received_out_size, received_size_out] {
+    media_channel()->GetAudioLevels(captured_out, received_out, received_out_size, received_size_out);
+  });
+}
+
 VideoChannel::VideoChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
                            rtc::Thread* signaling_thread,

pc/channel.h

@@ -407,6 +407,13 @@ class VoiceChannel : public BaseChannel {
   // RingRTC change to configure OPUS
   void ConfigureEncoders(const webrtc::AudioEncoder::Config& config);
 
+  // RingRTC change to get audio levels
+  void GetAudioLevels(
+    cricket::AudioLevel* captured_out,
+    cricket::ReceivedAudioLevel* received_out,
+    size_t received_out_size,
+    size_t* received_size_out);
+
  private:
   // overrides from BaseChannel
   void UpdateMediaSendRecvState_w() override;

pc/peer_connection.cc

@@ -2967,4 +2967,17 @@ void PeerConnection::ConfigureAudioEncoders(const webrtc::AudioEncoder::Config&
   }
 }
 
+void PeerConnection::GetAudioLevels(cricket::AudioLevel* captured_out,
+                                    cricket::ReceivedAudioLevel* received_out,
+                                    size_t received_out_size,
+                                    size_t* received_size_out) {
+  auto* voice_channel = static_cast<cricket::VoiceChannel*>(rtp_manager()->GetAudioTransceiver()->internal()->channel());
+  if (voice_channel) {
+    voice_channel->GetAudioLevels(captured_out, received_out, received_out_size, received_size_out);
+  } else {
+    *captured_out = 0;
+    *received_size_out = 0;
+  }
+}
+
 }  // namespace webrtc

pc/peer_connection.h

@@ -250,6 +250,12 @@ class PeerConnection : public PeerConnectionInternal,
 
   void ConfigureAudioEncoders(const webrtc::AudioEncoder::Config& config) override;
 
+  void GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out) override;
+
   RTCError SetBitrate(const BitrateSettings& bitrate) override;
 
   void SetAudioPlayout(bool playout) override;

pc/peer_connection_proxy.h

@@ -144,6 +144,12 @@ PROXY_METHOD1(bool,
 PROXY_METHOD1(void,
               ConfigureAudioEncoders,
               const webrtc::AudioEncoder::Config&)
+PROXY_METHOD4(void, 
+              GetAudioLevels,
+              cricket::AudioLevel*,
+              cricket::ReceivedAudioLevel*,
+              size_t,
+              size_t*)
 PROXY_METHOD1(bool, SetIncomingRtpEnabled, bool)
 PROXY_METHOD1(RTCError, SetBitrate, const BitrateSettings&)
 PROXY_METHOD1(void, SetAudioPlayout, bool)

pc/peer_connection_wrapper.cc

@@ -301,6 +301,15 @@ bool PeerConnectionWrapper::ReceiveRtp(uint8_t pt) {
   return pc()->ReceiveRtp(pt);
 }
 
+void PeerConnectionWrapper::GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out) {
+  pc()->GetAudioLevels(captured_out, received_out, received_out_size, received_size_out);
+}
+
+
 rtc::scoped_refptr<AudioTrackInterface> PeerConnectionWrapper::CreateAudioTrack(
     const std::string& label) {
   return pc_factory()->CreateAudioTrack(label, nullptr);

pc/peer_connection_wrapper.h

@@ -149,6 +149,12 @@ class PeerConnectionWrapper {
   bool SendRtp(std::unique_ptr<RtpPacket> rtp_packet);
   bool ReceiveRtp(uint8_t pt);
 
+  void GetAudioLevels(
+      cricket::AudioLevel* captured_out,
+      cricket::ReceivedAudioLevel* received_out,
+      size_t received_out_size,
+      size_t* received_size_out);
+
   // Returns a new dummy audio track with the given label.
   rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
       const std::string& label);