henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 2 | * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef MEDIA_ENGINE_WEBRTCVOICEENGINE_H_ |
| 12 | #define MEDIA_ENGINE_WEBRTCVOICEENGINE_H_ |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 13 | |
| 14 | #include <map> |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 15 | #include <memory> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 16 | #include <string> |
| 17 | #include <vector> |
| 18 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "api/audio_codecs/audio_encoder_factory.h" |
| 20 | #include "api/rtpreceiverinterface.h" |
| 21 | #include "call/audio_state.h" |
| 22 | #include "call/call.h" |
| 23 | #include "media/base/rtputils.h" |
| 24 | #include "media/engine/apm_helpers.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 25 | #include "media/engine/webrtcvoe.h" |
| 26 | #include "modules/audio_processing/include/audio_processing.h" |
| 27 | #include "pc/channel.h" |
| 28 | #include "rtc_base/buffer.h" |
| 29 | #include "rtc_base/constructormagic.h" |
| 30 | #include "rtc_base/networkroute.h" |
| 31 | #include "rtc_base/scoped_ref_ptr.h" |
| 32 | #include "rtc_base/task_queue.h" |
| 33 | #include "rtc_base/thread_checker.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 34 | |
solenberg | 76377c5 | 2017-02-21 00:54:31 -0800 | [diff] [blame] | 35 | namespace webrtc { |
| 36 | namespace voe { |
| 37 | class TransmitMixer; |
| 38 | } // namespace voe |
| 39 | } // namespace webrtc |
| 40 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 41 | namespace cricket { |
| 42 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 43 | class AudioDeviceModule; |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 44 | class AudioMixer; |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 45 | class AudioSource; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 46 | class VoEWrapper; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 47 | class WebRtcVoiceMediaChannel; |
| 48 | |
| 49 | // WebRtcVoiceEngine is a class to be used with CompositeMediaEngine. |
| 50 | // It uses the WebRtc VoiceEngine library for audio handling. |
Fredrik Solenberg | 4332d09 | 2017-10-04 09:53:35 +0200 | [diff] [blame^] | 51 | class WebRtcVoiceEngine final { |
Jelena Marusic | c28a896 | 2015-05-29 15:05:44 +0200 | [diff] [blame] | 52 | friend class WebRtcVoiceMediaChannel; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 53 | public: |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 54 | WebRtcVoiceEngine( |
| 55 | webrtc::AudioDeviceModule* adm, |
ossu | eb1fde4 | 2017-05-02 06:46:30 -0700 | [diff] [blame] | 56 | const rtc::scoped_refptr<webrtc::AudioEncoderFactory>& encoder_factory, |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 57 | const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory, |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 58 | rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer, |
| 59 | rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 60 | // Dependency injection for testing. |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 61 | WebRtcVoiceEngine( |
| 62 | webrtc::AudioDeviceModule* adm, |
ossu | eb1fde4 | 2017-05-02 06:46:30 -0700 | [diff] [blame] | 63 | const rtc::scoped_refptr<webrtc::AudioEncoderFactory>& encoder_factory, |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 64 | const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory, |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 65 | rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer, |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 66 | rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing, |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 67 | VoEWrapper* voe_wrapper); |
Fredrik Solenberg | 4332d09 | 2017-10-04 09:53:35 +0200 | [diff] [blame^] | 68 | ~WebRtcVoiceEngine(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 69 | |
deadbeef | eb02c03 | 2017-06-15 08:29:25 -0700 | [diff] [blame] | 70 | // Does initialization that needs to occur on the worker thread. |
| 71 | void Init(); |
| 72 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 73 | rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const; |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 74 | VoiceMediaChannel* CreateChannel(webrtc::Call* call, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 75 | const MediaConfig& config, |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 76 | const AudioOptions& options); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 77 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 78 | int GetInputLevel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 79 | |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 80 | const std::vector<AudioCodec>& send_codecs() const; |
| 81 | const std::vector<AudioCodec>& recv_codecs() const; |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 82 | RtpCapabilities GetCapabilities() const; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 83 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 84 | // For tracking WebRtc channels. Needed because we have to pause them |
| 85 | // all when switching devices. |
| 86 | // May only be called by WebRtcVoiceMediaChannel. |
solenberg | 63b3454 | 2015-09-29 06:06:31 -0700 | [diff] [blame] | 87 | void RegisterChannel(WebRtcVoiceMediaChannel* channel); |
| 88 | void UnregisterChannel(WebRtcVoiceMediaChannel* channel); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 89 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 90 | VoEWrapper* voe() { return voe_wrapper_.get(); } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 91 | |
ivoc | d66b44d | 2016-01-15 03:06:36 -0800 | [diff] [blame] | 92 | // Starts AEC dump using an existing file. A maximum file size in bytes can be |
| 93 | // specified. When the maximum file size is reached, logging is stopped and |
| 94 | // the file is closed. If max_size_bytes is set to <= 0, no limit will be |
| 95 | // used. |
| 96 | bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes); |
wu@webrtc.org | a989080 | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 97 | |
ivoc | 797ef12 | 2015-10-22 03:25:41 -0700 | [diff] [blame] | 98 | // Stops AEC dump. |
| 99 | void StopAecDump(); |
| 100 | |
peah | b1c9d1d | 2017-07-25 15:45:24 -0700 | [diff] [blame] | 101 | const webrtc::AudioProcessing::Config GetApmConfigForTest() const { |
| 102 | return apm()->GetConfig(); |
peah | 8271d04 | 2016-11-22 07:24:52 -0800 | [diff] [blame] | 103 | } |
| 104 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 105 | private: |
solenberg | 63b3454 | 2015-09-29 06:06:31 -0700 | [diff] [blame] | 106 | // Every option that is "set" will be applied. Every option not "set" will be |
| 107 | // ignored. This allows us to selectively turn on and off different options |
| 108 | // easily at any time. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 109 | bool ApplyOptions(const AudioOptions& options); |
xians@webrtc.org | 3cefbc9 | 2014-10-10 09:42:53 +0000 | [diff] [blame] | 110 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 111 | void StartAecDump(const std::string& filename); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 112 | int CreateVoEChannel(); |
aleloi | 048cbdd | 2017-05-29 02:56:27 -0700 | [diff] [blame] | 113 | |
deadbeef | eb02c03 | 2017-06-15 08:29:25 -0700 | [diff] [blame] | 114 | std::unique_ptr<rtc::TaskQueue> low_priority_worker_queue_; |
aleloi | 048cbdd | 2017-05-29 02:56:27 -0700 | [diff] [blame] | 115 | |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 116 | webrtc::AudioDeviceModule* adm(); |
peah | b1c9d1d | 2017-07-25 15:45:24 -0700 | [diff] [blame] | 117 | webrtc::AudioProcessing* apm() const; |
solenberg | 76377c5 | 2017-02-21 00:54:31 -0800 | [diff] [blame] | 118 | webrtc::voe::TransmitMixer* transmit_mixer(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 119 | |
ossu | 20a4b3f | 2017-04-27 02:08:52 -0700 | [diff] [blame] | 120 | AudioCodecs CollectCodecs( |
| 121 | const std::vector<webrtc::AudioCodecSpec>& specs) const; |
ossu | c54071d | 2016-08-17 02:45:41 -0700 | [diff] [blame] | 122 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 123 | rtc::ThreadChecker signal_thread_checker_; |
| 124 | rtc::ThreadChecker worker_thread_checker_; |
| 125 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 126 | // The audio device manager. |
| 127 | rtc::scoped_refptr<webrtc::AudioDeviceModule> adm_; |
ossu | 20a4b3f | 2017-04-27 02:08:52 -0700 | [diff] [blame] | 128 | rtc::scoped_refptr<webrtc::AudioEncoderFactory> encoder_factory_; |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 129 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory_; |
deadbeef | eb02c03 | 2017-06-15 08:29:25 -0700 | [diff] [blame] | 130 | rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer_; |
solenberg | 059fb44 | 2016-10-26 05:12:24 -0700 | [diff] [blame] | 131 | // Reference to the APM, owned by VoE. |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 132 | rtc::scoped_refptr<webrtc::AudioProcessing> apm_; |
solenberg | 76377c5 | 2017-02-21 00:54:31 -0800 | [diff] [blame] | 133 | // Reference to the TransmitMixer, owned by VoE. |
| 134 | webrtc::voe::TransmitMixer* transmit_mixer_ = nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 135 | // The primary instance of WebRtc VoiceEngine. |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 136 | std::unique_ptr<VoEWrapper> voe_wrapper_; |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 137 | rtc::scoped_refptr<webrtc::AudioState> audio_state_; |
ossu | c54071d | 2016-08-17 02:45:41 -0700 | [diff] [blame] | 138 | std::vector<AudioCodec> send_codecs_; |
| 139 | std::vector<AudioCodec> recv_codecs_; |
solenberg | 63b3454 | 2015-09-29 06:06:31 -0700 | [diff] [blame] | 140 | std::vector<WebRtcVoiceMediaChannel*> channels_; |
solenberg | 88499ec | 2016-09-07 07:34:41 -0700 | [diff] [blame] | 141 | webrtc::VoEBase::ChannelConfig channel_config_; |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 142 | bool is_dumping_aec_ = false; |
deadbeef | eb02c03 | 2017-06-15 08:29:25 -0700 | [diff] [blame] | 143 | bool initialized_ = false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 144 | |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 145 | webrtc::AgcConfig default_agc_config_; |
peah | a3333bf | 2016-06-30 00:02:34 -0700 | [diff] [blame] | 146 | // Cache received extended_filter_aec, delay_agnostic_aec, experimental_ns |
| 147 | // level controller, and intelligibility_enhancer values, and apply them |
| 148 | // in case they are missing in the audio options. We need to do this because |
| 149 | // SetExtraOptions() will revert to defaults for options which are not |
| 150 | // provided. |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 151 | rtc::Optional<bool> extended_filter_aec_; |
| 152 | rtc::Optional<bool> delay_agnostic_aec_; |
| 153 | rtc::Optional<bool> experimental_ns_; |
Alejandro Luebs | c9b0c26 | 2016-05-16 15:32:38 -0700 | [diff] [blame] | 154 | rtc::Optional<bool> intelligibility_enhancer_; |
peah | a3333bf | 2016-06-30 00:02:34 -0700 | [diff] [blame] | 155 | rtc::Optional<bool> level_control_; |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 156 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 157 | RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceEngine); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 158 | }; |
| 159 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 160 | // WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses |
| 161 | // WebRtc Voice Engine. |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 162 | class WebRtcVoiceMediaChannel final : public VoiceMediaChannel, |
| 163 | public webrtc::Transport { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 164 | public: |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 165 | WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 166 | const MediaConfig& config, |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 167 | const AudioOptions& options, |
| 168 | webrtc::Call* call); |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 169 | ~WebRtcVoiceMediaChannel() override; |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 170 | |
solenberg | 66f4339 | 2015-09-09 01:36:22 -0700 | [diff] [blame] | 171 | const AudioOptions& options() const { return options_; } |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 172 | |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 173 | rtc::DiffServCodePoint PreferredDscp() const override; |
| 174 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 175 | bool SetSendParameters(const AudioSendParameters& params) override; |
| 176 | bool SetRecvParameters(const AudioRecvParameters& params) override; |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 177 | webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override; |
| 178 | bool SetRtpSendParameters(uint32_t ssrc, |
| 179 | const webrtc::RtpParameters& parameters) override; |
| 180 | webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; |
| 181 | bool SetRtpReceiveParameters( |
| 182 | uint32_t ssrc, |
| 183 | const webrtc::RtpParameters& parameters) override; |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 184 | |
aleloi | 84ef615 | 2016-08-04 05:28:21 -0700 | [diff] [blame] | 185 | void SetPlayout(bool playout) override; |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 186 | void SetSend(bool send) override; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 187 | bool SetAudioSend(uint32_t ssrc, |
| 188 | bool enable, |
| 189 | const AudioOptions* options, |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 190 | AudioSource* source) override; |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 191 | bool AddSendStream(const StreamParams& sp) override; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 192 | bool RemoveSendStream(uint32_t ssrc) override; |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 193 | bool AddRecvStream(const StreamParams& sp) override; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 194 | bool RemoveRecvStream(uint32_t ssrc) override; |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 195 | bool GetActiveStreams(AudioInfo::StreamList* actives) override; |
| 196 | int GetOutputLevel() override; |
solenberg | 2100c0b | 2017-03-01 11:29:29 -0800 | [diff] [blame] | 197 | // SSRC=0 will apply the new volume to current and future unsignaled streams. |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 198 | bool SetOutputVolume(uint32_t ssrc, double volume) override; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 199 | |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 200 | bool CanInsertDtmf() override; |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 201 | bool InsertDtmf(uint32_t ssrc, int event, int duration) override; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 202 | |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 203 | void OnPacketReceived(rtc::CopyOnWriteBuffer* packet, |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 204 | const rtc::PacketTime& packet_time) override; |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 205 | void OnRtcpReceived(rtc::CopyOnWriteBuffer* packet, |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 206 | const rtc::PacketTime& packet_time) override; |
Honghai Zhang | cc411c0 | 2016-03-29 17:27:21 -0700 | [diff] [blame] | 207 | void OnNetworkRouteChanged(const std::string& transport_name, |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 208 | const rtc::NetworkRoute& network_route) override; |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 209 | void OnReadyToSend(bool ready) override; |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 210 | void OnTransportOverheadChanged(int transport_overhead_per_packet) override; |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 211 | bool GetStats(VoiceMediaInfo* info) override; |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 212 | |
solenberg | 2100c0b | 2017-03-01 11:29:29 -0800 | [diff] [blame] | 213 | // SSRC=0 will set the audio sink on the latest unsignaled stream, future or |
| 214 | // current. Only one stream at a time will use the sink. |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 215 | void SetRawAudioSink( |
| 216 | uint32_t ssrc, |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 217 | std::unique_ptr<webrtc::AudioSinkInterface> sink) override; |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 218 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 219 | std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override; |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 220 | |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 221 | // implements Transport interface |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 222 | bool SendRtp(const uint8_t* data, |
| 223 | size_t len, |
| 224 | const webrtc::PacketOptions& options) override { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 225 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 226 | rtc::PacketOptions rtc_options; |
| 227 | rtc_options.packet_id = options.packet_id; |
| 228 | return VoiceMediaChannel::SendPacket(&packet, rtc_options); |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 229 | } |
| 230 | |
pbos | 2d56668 | 2015-09-28 09:59:31 -0700 | [diff] [blame] | 231 | bool SendRtcp(const uint8_t* data, size_t len) override { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 232 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 233 | return VoiceMediaChannel::SendRtcp(&packet, rtc::PacketOptions()); |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 234 | } |
| 235 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 236 | int GetReceiveChannelId(uint32_t ssrc) const; |
| 237 | int GetSendChannelId(uint32_t ssrc) const; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 238 | |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 239 | private: |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 240 | bool SetOptions(const AudioOptions& options); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 241 | bool SetRecvCodecs(const std::vector<AudioCodec>& codecs); |
solenberg | 72e29d2 | 2016-03-08 06:35:16 -0800 | [diff] [blame] | 242 | bool SetSendCodecs(const std::vector<AudioCodec>& codecs); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 243 | bool SetLocalSource(uint32_t ssrc, AudioSource* source); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 244 | bool MuteStream(uint32_t ssrc, bool mute); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 245 | |
Fredrik Solenberg | e444a3d | 2015-05-07 16:42:08 +0200 | [diff] [blame] | 246 | WebRtcVoiceEngine* engine() { return engine_; } |
kwiberg | 37b8b11 | 2016-11-03 02:46:53 -0700 | [diff] [blame] | 247 | void ChangePlayout(bool playout); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 248 | int CreateVoEChannel(); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 249 | bool DeleteVoEChannel(int channel); |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 250 | bool SetMaxSendBitrate(int bps); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 251 | bool ValidateRtpParameters(const webrtc::RtpParameters& parameters); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 252 | void SetupRecording(); |
solenberg | 2100c0b | 2017-03-01 11:29:29 -0800 | [diff] [blame] | 253 | // Check if 'ssrc' is an unsignaled stream, and if so mark it as not being |
| 254 | // unsignaled anymore (i.e. it is now removed, or signaled), and return true. |
| 255 | bool MaybeDeregisterUnsignaledRecvStream(uint32_t ssrc); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 256 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 257 | rtc::ThreadChecker worker_thread_checker_; |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 258 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 259 | WebRtcVoiceEngine* const engine_ = nullptr; |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 260 | std::vector<AudioCodec> send_codecs_; |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 261 | |
| 262 | // TODO(kwiberg): decoder_map_ and recv_codecs_ store the exact same |
| 263 | // information, in slightly different formats. Eliminate recv_codecs_. |
| 264 | std::map<int, webrtc::SdpAudioFormat> decoder_map_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 265 | std::vector<AudioCodec> recv_codecs_; |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 266 | |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 267 | int max_send_bitrate_bps_ = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 268 | AudioOptions options_; |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 269 | rtc::Optional<int> dtmf_payload_type_; |
solenberg | ffbbcac | 2016-11-17 05:25:37 -0800 | [diff] [blame] | 270 | int dtmf_payload_freq_ = -1; |
solenberg | 72e29d2 | 2016-03-08 06:35:16 -0800 | [diff] [blame] | 271 | bool recv_transport_cc_enabled_ = false; |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 272 | bool recv_nack_enabled_ = false; |
solenberg | ffbbcac | 2016-11-17 05:25:37 -0800 | [diff] [blame] | 273 | bool desired_playout_ = false; |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 274 | bool playout_ = false; |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 275 | bool send_ = false; |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 276 | webrtc::Call* const call_ = nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 277 | |
solenberg | 2100c0b | 2017-03-01 11:29:29 -0800 | [diff] [blame] | 278 | // Queue of unsignaled SSRCs; oldest at the beginning. |
| 279 | std::vector<uint32_t> unsignaled_recv_ssrcs_; |
| 280 | |
| 281 | // Volume for unsignaled streams, which may be set before the stream exists. |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 282 | double default_recv_volume_ = 1.0; |
solenberg | 2100c0b | 2017-03-01 11:29:29 -0800 | [diff] [blame] | 283 | // Sink for latest unsignaled stream - may be set before the stream exists. |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 284 | std::unique_ptr<webrtc::AudioSinkInterface> default_sink_; |
solenberg | 8093d54 | 2015-11-12 06:02:30 -0800 | [diff] [blame] | 285 | // Default SSRC to use for RTCP receiver reports in case of no signaled |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 286 | // send streams. See: https://code.google.com/p/webrtc/issues/detail?id=4740 |
solenberg | 8093d54 | 2015-11-12 06:02:30 -0800 | [diff] [blame] | 287 | // and https://code.google.com/p/chromium/issues/detail?id=547661 |
| 288 | uint32_t receiver_reports_ssrc_ = 0xFA17FA17u; |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 289 | |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 290 | class WebRtcAudioSendStream; |
| 291 | std::map<uint32_t, WebRtcAudioSendStream*> send_streams_; |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 292 | std::vector<webrtc::RtpExtension> send_rtp_extensions_; |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 293 | |
| 294 | class WebRtcAudioReceiveStream; |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 295 | std::map<uint32_t, WebRtcAudioReceiveStream*> recv_streams_; |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 296 | std::vector<webrtc::RtpExtension> recv_rtp_extensions_; |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 297 | |
ossu | 20a4b3f | 2017-04-27 02:08:52 -0700 | [diff] [blame] | 298 | rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec> |
| 299 | send_codec_spec_; |
solenberg | 72e29d2 | 2016-03-08 06:35:16 -0800 | [diff] [blame] | 300 | |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 301 | RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceMediaChannel); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 302 | }; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 303 | } // namespace cricket |
| 304 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 305 | #endif // MEDIA_ENGINE_WEBRTCVOICEENGINE_H_ |