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

talk/media/base/mediachannel.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 548 matching lines @@
   // multiple SSRCs.
   virtual bool RemoveSendStream(uint32 ssrc) = 0;
   // Creates a new incoming media stream with SSRCs and CNAME as described
   // by sp.
   virtual bool AddRecvStream(const StreamParams& sp) = 0;
   // Removes an incoming media stream.
   // ssrc must be the first SSRC of the media stream if the stream uses
   // multiple SSRCs.
   virtual bool RemoveRecvStream(uint32 ssrc) = 0;
 
-  // Mutes the channel.
-  virtual bool MuteStream(uint32 ssrc, bool on) = 0;
-
-  // Sets the RTP extension headers and IDs to use when sending RTP.
-  virtual bool SetRecvRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) = 0;
-  virtual bool SetSendRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) = 0;
   // Returns the absoulte sendtime extension id value from media channel.
   virtual int GetRtpSendTimeExtnId() const {
     return -1;
   }
-  // Sets the maximum allowed bandwidth to use when sending data.
-  virtual bool SetMaxSendBandwidth(int bps) = 0;
 
   // Base method to send packet using NetworkInterface.
   bool SendPacket(rtc::Buffer* packet) {
     return DoSendPacket(packet, false);
   }
 
   bool SendRtcp(rtc::Buffer* packet) {
     return DoSendPacket(packet, true);
   }
 
@@ skipping 473 matching lines @@
     ERROR_PLAY_DEVICE_MUTED,              // Playout muted by OS.
     ERROR_PLAY_DEVICE_REMOVED,            // Playout removed while active.
     ERROR_PLAY_RUNTIME_ERROR,             // Errors in voice processing.
     ERROR_PLAY_SRTP_ERROR,                // Generic SRTP failure.
     ERROR_PLAY_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_PLAY_SRTP_REPLAY,               // Packet replay detected.
   };
 
   VoiceMediaChannel() {}
   virtual ~VoiceMediaChannel() {}
-  // TODO(pthatcher): Remove SetSendCodecs,
-  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
-  // once all implementations implement SetSendParameters.
-  virtual bool SetSendParameters(const AudioSendParameters& params) {
-    return (SetSendCodecs(params.codecs) &&
-            SetSendRtpHeaderExtensions(params.extensions) &&
-            SetMaxSendBandwidth(params.max_bandwidth_bps) &&
-            SetOptions(params.options));
-  }
-  // TODO(pthatcher): Remove SetRecvCodecs and
-  // SetRecvRtpHeaderExtensions once all implementations implement
-  // SetRecvParameters.
-  virtual bool SetRecvParameters(const AudioRecvParameters& params) {
-    return (SetRecvCodecs(params.codecs) &&
-            SetRecvRtpHeaderExtensions(params.extensions));
-  }
-  // Sets the codecs/payload types to be used for incoming media.
-  virtual bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) = 0;
-  // Sets the codecs/payload types to be used for outgoing media.
-  virtual bool SetSendCodecs(const std::vector<AudioCodec>& codecs) = 0;
+  virtual bool SetSendParameters(const AudioSendParameters& params) = 0;
+  virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0;
   // Starts or stops playout of received audio.
   virtual bool SetPlayout(bool playout) = 0;
   // Starts or stops sending (and potentially capture) of local audio.
   virtual bool SetSend(SendFlags flag) = 0;
+  // Mutes the channel.
+  virtual bool MuteStream(uint32 ssrc, bool on,
+                          const AudioOptions* options) = 0;
   // Sets the renderer object to be used for the specified remote audio stream.
   virtual bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) = 0;
   // Sets the renderer object to be used for the specified local audio stream.
   virtual bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) = 0;
   // Gets current energy levels for all incoming streams.
   virtual bool GetActiveStreams(AudioInfo::StreamList* actives) = 0;
   // Get the current energy level of the stream sent to the speaker.
   virtual int GetOutputLevel() = 0;
   // Get the time in milliseconds since last recorded keystroke, or negative.
   virtual int GetTimeSinceLastTyping() = 0;
@@ skipping 18 matching lines @@
   // DTMF event 0-9, *, #, A-D.
   virtual bool InsertDtmf(uint32 ssrc, int event, int duration, int flags) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VoiceMediaInfo* info) = 0;
   // Gets last reported error for this media channel.
   virtual void GetLastMediaError(uint32* ssrc,
                                  VoiceMediaChannel::Error* error) {
     ASSERT(error != NULL);
     *error = ERROR_NONE;
   }
-  // Sets the media options to use.
-  virtual bool SetOptions(const AudioOptions& options) = 0;
+  // Gets the media options to use.
   virtual bool GetOptions(AudioOptions* options) const = 0;
 
   // Signal errors from MediaChannel.  Arguments are:
   //     ssrc(uint32), and error(VoiceMediaChannel::Error).
   sigslot::signal2<uint32, VoiceMediaChannel::Error> SignalMediaError;
 };
 
 struct VideoSendParameters : RtpSendParameters<VideoCodec, VideoOptions> {
 };
 
@@ skipping 14 matching lines @@
     ERROR_REC_CPU_MAX_CANT_DOWNGRADE,     // Can't downgrade capture anymore.
     ERROR_PLAY_SRTP_ERROR = 200,          // Generic receiver SRTP failure.
     ERROR_PLAY_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_PLAY_SRTP_REPLAY,               // Packet replay detected.
   };
 
   VideoMediaChannel() : renderer_(NULL) {}
   virtual ~VideoMediaChannel() {}
   // Allow video channel to unhook itself from an associated voice channel.
   virtual void DetachVoiceChannel() = 0;
-  // TODO(pthatcher): Remove SetSendCodecs,
-  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
-  // once all implementations implement SetSendParameters.
-  virtual bool SetSendParameters(const VideoSendParameters& params) {
-    return (SetSendCodecs(params.codecs) &&
-            SetSendRtpHeaderExtensions(params.extensions) &&
-            SetMaxSendBandwidth(params.max_bandwidth_bps) &&
-            SetOptions(params.options));
-  }
-  // TODO(pthatcher): Remove SetRecvCodecs and
-  // SetRecvRtpHeaderExtensions once all implementations implement
-  // SetRecvParameters.
-  virtual bool SetRecvParameters(const VideoRecvParameters& params) {
-    return (SetRecvCodecs(params.codecs) &&
-            SetRecvRtpHeaderExtensions(params.extensions));
-  }
-  // Sets the codecs/payload types to be used for incoming media.
-  virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) = 0;
-  // Sets the codecs/payload types to be used for outgoing media.
-  virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs) = 0;
+  virtual bool SetSendParameters(const VideoSendParameters& params) = 0;
+  virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0;
   // Gets the currently set codecs/payload types to be used for outgoing media.
   virtual bool GetSendCodec(VideoCodec* send_codec) = 0;
   // Sets the format of a specified outgoing stream.
   virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) = 0;
   // Starts or stops playout of received video.
   virtual bool SetRender(bool render) = 0;
   // Starts or stops transmission (and potentially capture) of local video.
   virtual bool SetSend(bool send) = 0;
+  // Mutes the channel.
+  virtual bool MuteStream(uint32 ssrc, bool on,
+                          const VideoOptions* options) = 0;
   // Sets the renderer object to be used for the specified stream.
   // If SSRC is 0, the renderer is used for the 'default' stream.
   virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) = 0;
   // If |ssrc| is 0, replace the default capturer (engine capturer) with
   // |capturer|. If |ssrc| is non zero create a new stream with |ssrc| as SSRC.
   virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VideoMediaInfo* info) = 0;
   // Send an intra frame to the receivers.
   virtual bool SendIntraFrame() = 0;
   // Reuqest each of the remote senders to send an intra frame.
   virtual bool RequestIntraFrame() = 0;
-  // Sets the media options to use.
-  virtual bool SetOptions(const VideoOptions& options) = 0;
+  // Gets the media options to use.
   virtual bool GetOptions(VideoOptions* options) const = 0;
   virtual void UpdateAspectRatio(int ratio_w, int ratio_h) = 0;
 
   // Signal errors from MediaChannel.  Arguments are:
   //     ssrc(uint32), and error(VideoMediaChannel::Error).
   sigslot::signal2<uint32, Error> SignalMediaError;
 
  protected:
   VideoRenderer *renderer_;
 };
@@ skipping 92 matching lines @@
     ERROR_OTHER,                          // Other errors.
     ERROR_SEND_SRTP_ERROR = 200,          // Generic SRTP failure.
     ERROR_SEND_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_RECV_SRTP_ERROR,                // Generic SRTP failure.
     ERROR_RECV_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_RECV_SRTP_REPLAY,               // Packet replay detected.
   };
 
   virtual ~DataMediaChannel() {}
 
-  // TODO(pthatcher): Remove SetSendCodecs,
-  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
-  // once all implementations implement SetSendParameters.
-  virtual bool SetSendParameters(const DataSendParameters& params) {
-    return (SetSendCodecs(params.codecs) &&
-            SetMaxSendBandwidth(params.max_bandwidth_bps));
-  }
-  // TODO(pthatcher): Remove SetRecvCodecs and
-  // SetRecvRtpHeaderExtensions once all implementations implement
-  // SetRecvParameters.
-  virtual bool SetRecvParameters(const DataRecvParameters& params) {
-    return SetRecvCodecs(params.codecs);
-  }
-  virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs) = 0;
-  virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs) = 0;
+  virtual bool SetSendParameters(const DataSendParameters& params) = 0;
+  virtual bool SetRecvParameters(const DataRecvParameters& params) = 0;
 
-  virtual bool MuteStream(uint32 ssrc, bool on) { return false; }
   // TODO(pthatcher): Implement this.
   virtual bool GetStats(DataMediaInfo* info) { return true; }
 
   virtual bool SetSend(bool send) = 0;
   virtual bool SetReceive(bool receive) = 0;
 
   virtual bool SendData(
       const SendDataParams& params,
       const rtc::Buffer& payload,
       SendDataResult* result = NULL) = 0;
   // Signals when data is received (params, data, len)
   sigslot::signal3<const ReceiveDataParams&,
                    const char*,
                    size_t> SignalDataReceived;
   // Signal errors from MediaChannel.  Arguments are:
   //     ssrc(uint32), and error(DataMediaChannel::Error).
   sigslot::signal2<uint32, DataMediaChannel::Error> SignalMediaError;
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_