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

talk/session/media/channel.cc

 /*
  * 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 305 matching lines @@
   tc->SignalReadyToSend.disconnect(this);
 }
 
 bool BaseChannel::Enable(bool enable) {
   worker_thread_->Invoke<void>(Bind(
       enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
       this));
   return true;
 }
 
-bool BaseChannel::MuteStream(uint32 ssrc, bool mute) {
-  return InvokeOnWorker(Bind(&BaseChannel::MuteStream_w, this, ssrc, mute));
-}
-
-bool BaseChannel::IsStreamMuted(uint32 ssrc) {
-  return InvokeOnWorker(Bind(&BaseChannel::IsStreamMuted_w, this, ssrc));
-}
-
 bool BaseChannel::AddRecvStream(const StreamParams& sp) {
   return InvokeOnWorker(Bind(&BaseChannel::AddRecvStream_w, this, sp));
 }
 
 bool BaseChannel::RemoveRecvStream(uint32 ssrc) {
   return InvokeOnWorker(Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
 }
 
 bool BaseChannel::AddSendStream(const StreamParams& sp) {
   return InvokeOnWorker(
@@ skipping 373 matching lines @@
 void BaseChannel::DisableMedia_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (!enabled_)
     return;
 
   LOG(LS_INFO) << "Channel disabled";
   enabled_ = false;
   ChangeState();
 }
 
-bool BaseChannel::MuteStream_w(uint32 ssrc, bool mute) {
-  ASSERT(worker_thread_ == rtc::Thread::Current());
-  bool ret = media_channel()->MuteStream(ssrc, mute);
-  if (ret) {
-    if (mute)
-      muted_streams_.insert(ssrc);
-    else
-      muted_streams_.erase(ssrc);
-  }
-  return ret;
-}
-
-bool BaseChannel::IsStreamMuted_w(uint32 ssrc) {
-  ASSERT(worker_thread_ == rtc::Thread::Current());
-  return muted_streams_.find(ssrc) != muted_streams_.end();
-}
-
 void BaseChannel::ChannelWritable_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (writable_)
     return;
 
   LOG(LS_INFO) << "Channel socket writable ("
                << transport_channel_->content_name() << ", "
                << transport_channel_->component() << ")"
                << (was_ever_writable_ ? "" : " for the first time");
 
@@ skipping 534 matching lines @@
 bool VoiceChannel::SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetRemoteRenderer,
                              media_channel(), ssrc, renderer));
 }
 
 bool VoiceChannel::SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetLocalRenderer,
                              media_channel(), ssrc, renderer));
 }
 
+bool VoiceChannel::MuteStream(uint32 ssrc, bool mute,
+                              const AudioOptions* options) {
+  return InvokeOnWorker(
+      Bind(&VoiceChannel::MuteStream_w, this, ssrc, mute, options));
+}
+
+bool VoiceChannel::IsStreamMuted(uint32 ssrc) {
+  return InvokeOnWorker(Bind(&VoiceChannel::IsStreamMuted_w, this, ssrc));
+}
+
 bool VoiceChannel::SetRingbackTone(const void* buf, int len) {
   return InvokeOnWorker(Bind(&VoiceChannel::SetRingbackTone_w, this, buf, len));
 }
 
 // TODO(juberti): Handle early media the right way. We should get an explicit
 // ringing message telling us to start playing local ringback, which we cancel
 // if any early media actually arrives. For now, we do the opposite, which is
 // to wait 1 second for early media, and start playing local ringback if none
 // arrives.
 void VoiceChannel::SetEarlyMedia(bool enable) {
@@ skipping 82 matching lines @@
 }
 
 void VoiceChannel::StopTypingMonitor() {
   typing_monitor_.reset();
 }
 
 bool VoiceChannel::IsTypingMonitorRunning() const {
   return typing_monitor_;
 }
 
-bool VoiceChannel::MuteStream_w(uint32 ssrc, bool mute) {
-  bool ret = BaseChannel::MuteStream_w(ssrc, mute);
-  if (typing_monitor_ && mute)
+bool VoiceChannel::MuteStream_w(uint32 ssrc, bool mute,
+                                const AudioOptions* options) {
+  ASSERT(worker_thread()->IsCurrent());
+  bool ret = media_channel()->MuteStream(ssrc, mute, options);
+  if (ret) {
+    if (mute)
+      muted_streams_.insert(ssrc);
+    else
+      muted_streams_.erase(ssrc);
+  }
+  if (typing_monitor_ && mute) {
     typing_monitor_->OnChannelMuted();
+  }
   return ret;
 }
 
+bool VoiceChannel::IsStreamMuted_w(uint32 ssrc) {
+  ASSERT(worker_thread()->IsCurrent());
+  return muted_streams_.find(ssrc) != muted_streams_.end();
+}
+
 int VoiceChannel::GetInputLevel_w() {
   return media_engine_->GetInputLevel();
 }
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
   media_channel()->GetActiveStreams(actives);
@@ skipping 157 matching lines @@
 
 bool VoiceChannel::InsertDtmf_w(uint32 ssrc, int event, int duration,
                                 int flags) {
   if (!enabled()) {
     return false;
   }
 
   return media_channel()->InsertDtmf(ssrc, event, duration, flags);
 }
 
-bool VoiceChannel::SetChannelOptions(const AudioOptions& options) {
-  return InvokeOnWorker(Bind(&VoiceMediaChannel::SetOptions,
-                             media_channel(), options));
-}
-
 void VoiceChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_EARLYMEDIATIMEOUT:
       HandleEarlyMediaTimeout();
       break;
     case MSG_CHANNEL_ERROR: {
       VoiceChannelErrorMessageData* data =
           static_cast<VoiceChannelErrorMessageData*>(pmsg->pdata);
       SignalMediaError(this, data->ssrc, data->error);
       delete data;
@@ skipping 150 matching lines @@
       &VideoMediaChannel::SendIntraFrame, media_channel()));
   return true;
 }
 
 bool VideoChannel::RequestIntraFrame() {
   worker_thread()->Invoke<void>(Bind(
       &VideoMediaChannel::RequestIntraFrame, media_channel()));
   return true;
 }
 
+bool VideoChannel::MuteStream(uint32 ssrc, bool mute,
+                              const VideoOptions* options) {
+  return InvokeOnWorker(
+      Bind(&VideoChannel::MuteStream_w, this, ssrc, mute, options));
+}
+
 void VideoChannel::ChangeState() {
   // Render incoming data if we're the active call, and we have the local
   // content. We receive data on the default channel and multiplexed streams.
   bool recv = IsReadyToReceive();
   if (!media_channel()->SetRender(recv)) {
     LOG(LS_ERROR) << "Failed to SetRender on video channel";
     // TODO(gangji): Report error back to server.
   }
 
   // Send outgoing data if we're the active call, we have the remote content,
@@ skipping 197 matching lines @@
   data->fps = VideoFormat::IntervalToFps(video_format->interval);
   data->screencast_max_pixels = capturer->screencast_max_pixels();
 }
 
 void VideoChannel::OnScreencastWindowEvent_s(uint32 ssrc,
                                              rtc::WindowEvent we) {
   ASSERT(signaling_thread() == rtc::Thread::Current());
   SignalScreencastWindowEvent(ssrc, we);
 }
 
-bool VideoChannel::SetChannelOptions(const VideoOptions &options) {
-  return InvokeOnWorker(Bind(&VideoMediaChannel::SetOptions,
-                             media_channel(), options));
-}
-
 void VideoChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SCREENCASTWINDOWEVENT: {
       const ScreencastEventMessageData* data =
           static_cast<ScreencastEventMessageData*>(pmsg->pdata);
       OnScreencastWindowEvent_s(data->ssrc, data->event);
       delete data;
       break;
     }
     case MSG_CHANNEL_ERROR: {
@@ skipping 89 matching lines @@
       ASSERT(mode == SrtpFilter::UNPROTECT);
       // TODO(gangji): Turn on the signaling of replay error once we have
       // switched to the new mechanism for doing video retransmissions.
       // OnVideoChannelError(ssrc, VideoMediaChannel::ERROR_PLAY_SRTP_REPLAY);
       break;
     default:
       break;
   }
 }
 
-
 void VideoChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const {
   GetSupportedVideoCryptoSuites(ciphers);
 }
 
+bool VideoChannel::MuteStream_w(uint32 ssrc, bool mute,
+                                const VideoOptions* options) {
+  ASSERT(worker_thread()->IsCurrent());
+  return media_channel()->MuteStream(ssrc, mute, options);
+}
+
 DataChannel::DataChannel(rtc::Thread* thread,
                          DataMediaChannel* media_channel,
                          BaseSession* session,
                          const std::string& content_name,
                          bool rtcp)
     : BaseChannel(thread, media_channel, session, content_name, rtcp),
       data_channel_type_(cricket::DCT_NONE),
       ready_to_send_data_(false) {
 }
 
@@ skipping 323 matching lines @@
   return (data_channel_type_ == DCT_RTP);
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32 sid) {
   rtc::TypedMessageData<uint32>* message =
       new rtc::TypedMessageData<uint32>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket