Using AudioOption to enable audio network adaptor.

webrtc/media/base/mediachannel.h

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 150 matching lines @@
     SetFrom(&experimental_ns, change.experimental_ns);
     SetFrom(&intelligibility_enhancer, change.intelligibility_enhancer);
     SetFrom(&level_control, change.level_control);
     SetFrom(&tx_agc_target_dbov, change.tx_agc_target_dbov);
     SetFrom(&tx_agc_digital_compression_gain,
             change.tx_agc_digital_compression_gain);
     SetFrom(&tx_agc_limiter, change.tx_agc_limiter);
     SetFrom(&recording_sample_rate, change.recording_sample_rate);
     SetFrom(&playout_sample_rate, change.playout_sample_rate);
     SetFrom(&combined_audio_video_bwe, change.combined_audio_video_bwe);
+    SetFrom(&audio_network_adaptor, change.audio_network_adaptor);
+    SetFrom(&audio_network_adaptor_config, change.audio_network_adaptor_config);
   }
 
   bool operator==(const AudioOptions& o) const {
     return echo_cancellation == o.echo_cancellation &&
            auto_gain_control == o.auto_gain_control &&
            noise_suppression == o.noise_suppression &&
            highpass_filter == o.highpass_filter &&
            stereo_swapping == o.stereo_swapping &&
            audio_jitter_buffer_max_packets ==
                o.audio_jitter_buffer_max_packets &&
            audio_jitter_buffer_fast_accelerate ==
                o.audio_jitter_buffer_fast_accelerate &&
            typing_detection == o.typing_detection &&
            aecm_generate_comfort_noise == o.aecm_generate_comfort_noise &&
            experimental_agc == o.experimental_agc &&
            extended_filter_aec == o.extended_filter_aec &&
            delay_agnostic_aec == o.delay_agnostic_aec &&
            experimental_ns == o.experimental_ns &&
            intelligibility_enhancer == o.intelligibility_enhancer &&
            level_control == o.level_control &&
            adjust_agc_delta == o.adjust_agc_delta &&
            tx_agc_target_dbov == o.tx_agc_target_dbov &&
            tx_agc_digital_compression_gain ==
                o.tx_agc_digital_compression_gain &&
            tx_agc_limiter == o.tx_agc_limiter &&
            recording_sample_rate == o.recording_sample_rate &&
            playout_sample_rate == o.playout_sample_rate &&
-           combined_audio_video_bwe == o.combined_audio_video_bwe;
+           combined_audio_video_bwe == o.combined_audio_video_bwe &&
+           audio_network_adaptor == o.audio_network_adaptor &&
+           audio_network_adaptor_config == o.audio_network_adaptor_config;
   }
   bool operator!=(const AudioOptions& o) const { return !(*this == o); }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "AudioOptions {";
     ost << ToStringIfSet("aec", echo_cancellation);
     ost << ToStringIfSet("agc", auto_gain_control);
     ost << ToStringIfSet("ns", noise_suppression);
     ost << ToStringIfSet("hf", highpass_filter);
@@ skipping 11 matching lines @@
     ost << ToStringIfSet("experimental_ns", experimental_ns);
     ost << ToStringIfSet("intelligibility_enhancer", intelligibility_enhancer);
     ost << ToStringIfSet("level_control", level_control);
     ost << ToStringIfSet("tx_agc_target_dbov", tx_agc_target_dbov);
     ost << ToStringIfSet("tx_agc_digital_compression_gain",
         tx_agc_digital_compression_gain);
     ost << ToStringIfSet("tx_agc_limiter", tx_agc_limiter);
     ost << ToStringIfSet("recording_sample_rate", recording_sample_rate);
     ost << ToStringIfSet("playout_sample_rate", playout_sample_rate);
     ost << ToStringIfSet("combined_audio_video_bwe", combined_audio_video_bwe);
+    ost << ToStringIfSet("audio_network_adaptor", audio_network_adaptor);

[the sun, 2016/10/25 09:25:46]

audio_network_adaptor_config missing?

[minyue-webrtc, 2016/10/27 14:33:10]

I don't know if to String will be useful for audio_network_adaptor_config
because it is not human readable. Do you think it is still good to add it?

[the sun, 2016/10/28 18:21:52]

Oh? What does it look like? Is it really not possible to understand anything
about the configuration by looking at the string? Then, why is it a string? :)

[minyue-webrtc, 2016/10/28 18:41:57]

It is a proto buffer serialized string. it is a std::string since proto buffer
c++ api uses it as default type.

[the sun, 2016/10/28 19:04:47]

Ah, in that case, just leave:
// The adaptor config is a serialized proto buffer and therefore not human
readable.
// ost << ToStringIfSet("audio_network_adaptor_config",
audio_network_adaptor_config);

     ost << "}";
     return ost.str();
   }
 
   // Audio processing that attempts to filter away the output signal from
   // later inbound pickup.
   rtc::Optional<bool> echo_cancellation;
   // Audio processing to adjust the sensitivity of the local mic dynamically.
   rtc::Optional<bool> auto_gain_control;
   // Audio processing to filter out background noise.
@@ skipping 20 matching lines @@
   rtc::Optional<uint16_t> tx_agc_target_dbov;
   rtc::Optional<uint16_t> tx_agc_digital_compression_gain;
   rtc::Optional<bool> tx_agc_limiter;
   rtc::Optional<uint32_t> recording_sample_rate;
   rtc::Optional<uint32_t> playout_sample_rate;
   // Enable combined audio+bandwidth BWE.
   // TODO(pthatcher): This flag is set from the
   // "googCombinedAudioVideoBwe", but not used anywhere. So delete it,
   // and check if any other AudioOptions members are unused.
   rtc::Optional<bool> combined_audio_video_bwe;
+  // Enable audio network adaptor.
+  rtc::Optional<bool> audio_network_adaptor;

[minyue-webrtc, 2016/10/24 10:57:11]

I initially wanted to let audio_network_adaptor_config.has_value to determine
whether audio network adaptor should be on or off. However, there is a normally
a third status for audio options (don't care / don't override). So I need to add
an optional<bool> here too.

[the sun, 2016/10/25 09:46:32]

How are you going to roll the feature out? If you're planning to use an
experiment (i.e. using the webrtc::field_trial:: API), could you just check that
in the WVoMC ctor? That would allow you to use just one field here.

[minyue-webrtc, 2016/10/27 14:33:10]

The feature is configured in a way that it is up to the application to decide
whether to turn it on and how to configure audio network adaptor.

[the sun, 2016/10/28 19:04:47]

Btw, what happened to your idea of only having the config string?

[minyue-webrtc, 2016/10/28 20:15:03]

I initially wanted to let audio_network_adaptor_config.has_value to determine
whether audio network adaptor should be on or off. However, there is a
a third status for audio options (don't care / don't override). So I need to add
an optional<bool> here too.

[the sun, 2016/10/28 20:33:08]

I probably misunderstood then - I thought you said since the config string is
always required when the adaptor is enabled, that you could use the empty string
("") as the third state. But I may be getting the logic wrong.

[minyue-webrtc, 2016/10/28 21:05:45]

If we use only a Option<string>, when a second set of options comes in, we may
not be easily distinguish between "don't care" and "turn off".  I cannot find
better solutions. In principle, Optional<bool> |audio_network_adaptor| must be
there, and string |audio_network_adaptor_config| is obligatory when
|audio_network_adaptor| is true.

But the obligatoriness of |audio_network_adaptor_config| can be changed in the
future, if a default config is introduced.

+  // Config string for audio network adaptor.
+  rtc::Optional<std::string> audio_network_adaptor_config;
 
  private:
   template <typename T>
   static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) {
     if (o) {
       *s = o;
     }
   }
 };
 
@@ skipping 854 matching lines @@
   // 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_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_MEDIACHANNEL_H_