Full impl of NnChannel::SetSendParameters and NnChannel::SetRecvParameters

talk/media/webrtc/webrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2004 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 264 matching lines @@
   Settable<bool> extended_filter_aec_;
   Settable<bool> delay_agnostic_aec_;
   Settable<bool> experimental_ns_;
 };
 
 // WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses
 // WebRtc Voice Engine.
 class WebRtcVoiceMediaChannel : public VoiceMediaChannel,
                                 public webrtc::Transport {
  public:
-  explicit WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
-                                   webrtc::Call* call);
+  WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
+                          const AudioOptions& options,
+                          webrtc::Call* call);
   ~WebRtcVoiceMediaChannel() override;
 
   int voe_channel() const { return voe_channel_; }
   bool valid() const { return voe_channel_ != -1; }
   const AudioOptions& options() const { return options_; }
 
   bool SetSendParameters(const AudioSendParameters& params) override;
   bool SetRecvParameters(const AudioRecvParameters& params) override;
-  bool SetOptions(const AudioOptions& options) override;
-  bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) override;
-  bool SetSendCodecs(const std::vector<AudioCodec>& codecs) override;
-  bool SetRecvRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) override;
-  bool SetSendRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) override;
   bool SetPlayout(bool playout) override;
   bool PausePlayout();
   bool ResumePlayout();
   bool SetSend(SendFlags send) override;
   bool PauseSend();
   bool ResumeSend();
   bool SetAudioSend(uint32 ssrc, bool mute, const AudioOptions* options,
                     AudioRenderer* renderer) override;
   bool AddSendStream(const StreamParams& sp) override;
   bool RemoveSendStream(uint32 ssrc) override;
@@ skipping 13 matching lines @@
   bool SetRingbackTone(const char* buf, int len) override;
   bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) override;
   bool CanInsertDtmf() override;
   bool InsertDtmf(uint32 ssrc, int event, int duration, int flags) override;
 
   void OnPacketReceived(rtc::Buffer* packet,
                         const rtc::PacketTime& packet_time) override;
   void OnRtcpReceived(rtc::Buffer* packet,
                       const rtc::PacketTime& packet_time) override;
   void OnReadyToSend(bool ready) override {}
-  bool SetMaxSendBandwidth(int bps) override;
   bool GetStats(VoiceMediaInfo* info) override;
   // Gets last reported error from WebRtc voice engine.  This should be only
   // called in response a failure.
   void GetLastMediaError(uint32* ssrc,
                          VoiceMediaChannel::Error* error) override;
 
   // implements Transport interface
   int SendPacket(int channel, const void* data, size_t len) override {
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len,
                        kMaxRtpPacketLen);
     return VoiceMediaChannel::SendPacket(&packet) ? static_cast<int>(len) : -1;
   }
 
   int SendRTCPPacket(int channel, const void* data, size_t len) override {
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len,
                        kMaxRtpPacketLen);
     return VoiceMediaChannel::SendRtcp(&packet) ? static_cast<int>(len) : -1;
   }
 
   bool FindSsrc(int channel_num, uint32* ssrc);
   void OnError(uint32 ssrc, int error);
 
   bool sending() const { return send_ != SEND_NOTHING; }
   int GetReceiveChannelNum(uint32 ssrc) const;
   int GetSendChannelNum(uint32 ssrc) const;
 
  private:
+  bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetSendRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions);
+  bool SetOptions(const AudioOptions& options);
+  bool SetMaxSendBandwidth(int bps);
+  bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
+  bool SetRecvRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions);
   bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer);
   bool MuteStream(uint32 ssrc, bool mute);
+
   WebRtcVoiceEngine* engine() { return engine_; }
   int GetLastEngineError() { return engine()->GetLastEngineError(); }
   int GetOutputLevel(int channel);
   bool GetRedSendCodec(const AudioCodec& red_codec,
                        const std::vector<AudioCodec>& all_codecs,
                        webrtc::CodecInst* send_codec);
   bool EnableRtcp(int channel);
   bool ResetRecvCodecs(int channel);
   bool SetPlayout(int channel, bool playout);
   static uint32 ParseSsrc(const void* data, size_t len, bool rtcp);
@@ skipping 80 matching lines @@
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
 
   // Do not lock this on the VoE media processor thread; potential for deadlock
   // exists.
   mutable rtc::CriticalSection receive_channels_cs_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTCVOICEENGINE_H_