1 /* 2 * libjingle 3 * Copyright 2004 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #ifndef TALK_MEDIA_BASE_MEDIACHANNEL_H_ 29 #define TALK_MEDIA_BASE_MEDIACHANNEL_H_ 30 31 #include <string> 32 #include <vector> 33 34 #include "talk/media/base/codec.h" 35 #include "talk/media/base/constants.h" 36 #include "talk/media/base/streamparams.h" 37 #include "webrtc/base/basictypes.h" 38 #include "webrtc/base/buffer.h" 39 #include "webrtc/base/dscp.h" 40 #include "webrtc/base/logging.h" 41 #include "webrtc/base/optional.h" 42 #include "webrtc/base/sigslot.h" 43 #include "webrtc/base/socket.h" 44 #include "webrtc/base/window.h" 45 // TODO(juberti): re-evaluate this include 46 #include "talk/session/media/audiomonitor.h" 47 48 namespace rtc { 49 class Buffer; 50 class RateLimiter; 51 class Timing; 52 } 53 54 namespace webrtc { 55 class AudioSinkInterface; 56 } 57 58 namespace cricket { 59 60 class AudioRenderer; 61 class ScreencastId; 62 class VideoCapturer; 63 class VideoRenderer; 64 struct RtpHeader; 65 struct VideoFormat; 66 67 const int kMinRtpHeaderExtensionId = 1; 68 const int kMaxRtpHeaderExtensionId = 255; 69 const int kScreencastDefaultFps = 5; 70 71 template <class T> 72 static std::string ToStringIfSet(const char* key, const rtc::Optional<T>& val) { 73 std::string str; 74 if (val) { 75 str = key; 76 str += ": "; 77 str += val ? rtc::ToString(*val) : ""; 78 str += ", "; 79 } 80 return str; 81 } 82 83 template <class T> 84 static std::string VectorToString(const std::vector<T>& vals) { 85 std::ostringstream ost; 86 ost << "["; 87 for (size_t i = 0; i < vals.size(); ++i) { 88 if (i > 0) { 89 ost << ", "; 90 } 91 ost << vals[i].ToString(); 92 } 93 ost << "]"; 94 return ost.str(); 95 } 96 97 // Options that can be applied to a VoiceMediaChannel or a VoiceMediaEngine. 98 // Used to be flags, but that makes it hard to selectively apply options. 99 // We are moving all of the setting of options to structs like this, 100 // but some things currently still use flags. 101 struct AudioOptions { 102 void SetAll(const AudioOptions& change) { 103 SetFrom(&echo_cancellation, change.echo_cancellation); 104 SetFrom(&auto_gain_control, change.auto_gain_control); 105 SetFrom(&noise_suppression, change.noise_suppression); 106 SetFrom(&highpass_filter, change.highpass_filter); 107 SetFrom(&stereo_swapping, change.stereo_swapping); 108 SetFrom(&audio_jitter_buffer_max_packets, 109 change.audio_jitter_buffer_max_packets); 110 SetFrom(&audio_jitter_buffer_fast_accelerate, 111 change.audio_jitter_buffer_fast_accelerate); 112 SetFrom(&typing_detection, change.typing_detection); 113 SetFrom(&aecm_generate_comfort_noise, change.aecm_generate_comfort_noise); 114 SetFrom(&conference_mode, change.conference_mode); 115 SetFrom(&adjust_agc_delta, change.adjust_agc_delta); 116 SetFrom(&experimental_agc, change.experimental_agc); 117 SetFrom(&extended_filter_aec, change.extended_filter_aec); 118 SetFrom(&delay_agnostic_aec, change.delay_agnostic_aec); 119 SetFrom(&experimental_ns, change.experimental_ns); 120 SetFrom(&aec_dump, change.aec_dump); 121 SetFrom(&tx_agc_target_dbov, change.tx_agc_target_dbov); 122 SetFrom(&tx_agc_digital_compression_gain, 123 change.tx_agc_digital_compression_gain); 124 SetFrom(&tx_agc_limiter, change.tx_agc_limiter); 125 SetFrom(&recording_sample_rate, change.recording_sample_rate); 126 SetFrom(&playout_sample_rate, change.playout_sample_rate); 127 SetFrom(&dscp, change.dscp); 128 SetFrom(&combined_audio_video_bwe, change.combined_audio_video_bwe); 129 } 130 131 bool operator==(const AudioOptions& o) const { 132 return echo_cancellation == o.echo_cancellation && 133 auto_gain_control == o.auto_gain_control && 134 noise_suppression == o.noise_suppression && 135 highpass_filter == o.highpass_filter && 136 stereo_swapping == o.stereo_swapping && 137 audio_jitter_buffer_max_packets == o.audio_jitter_buffer_max_packets && 138 audio_jitter_buffer_fast_accelerate == 139 o.audio_jitter_buffer_fast_accelerate && 140 typing_detection == o.typing_detection && 141 aecm_generate_comfort_noise == o.aecm_generate_comfort_noise && 142 conference_mode == o.conference_mode && 143 experimental_agc == o.experimental_agc && 144 extended_filter_aec == o.extended_filter_aec && 145 delay_agnostic_aec == o.delay_agnostic_aec && 146 experimental_ns == o.experimental_ns && 147 adjust_agc_delta == o.adjust_agc_delta && 148 aec_dump == o.aec_dump && 149 tx_agc_target_dbov == o.tx_agc_target_dbov && 150 tx_agc_digital_compression_gain == o.tx_agc_digital_compression_gain && 151 tx_agc_limiter == o.tx_agc_limiter && 152 recording_sample_rate == o.recording_sample_rate && 153 playout_sample_rate == o.playout_sample_rate && 154 dscp == o.dscp && 155 combined_audio_video_bwe == o.combined_audio_video_bwe; 156 } 157 158 std::string ToString() const { 159 std::ostringstream ost; 160 ost << "AudioOptions {"; 161 ost << ToStringIfSet("aec", echo_cancellation); 162 ost << ToStringIfSet("agc", auto_gain_control); 163 ost << ToStringIfSet("ns", noise_suppression); 164 ost << ToStringIfSet("hf", highpass_filter); 165 ost << ToStringIfSet("swap", stereo_swapping); 166 ost << ToStringIfSet("audio_jitter_buffer_max_packets", 167 audio_jitter_buffer_max_packets); 168 ost << ToStringIfSet("audio_jitter_buffer_fast_accelerate", 169 audio_jitter_buffer_fast_accelerate); 170 ost << ToStringIfSet("typing", typing_detection); 171 ost << ToStringIfSet("comfort_noise", aecm_generate_comfort_noise); 172 ost << ToStringIfSet("conference", conference_mode); 173 ost << ToStringIfSet("agc_delta", adjust_agc_delta); 174 ost << ToStringIfSet("experimental_agc", experimental_agc); 175 ost << ToStringIfSet("extended_filter_aec", extended_filter_aec); 176 ost << ToStringIfSet("delay_agnostic_aec", delay_agnostic_aec); 177 ost << ToStringIfSet("experimental_ns", experimental_ns); 178 ost << ToStringIfSet("aec_dump", aec_dump); 179 ost << ToStringIfSet("tx_agc_target_dbov", tx_agc_target_dbov); 180 ost << ToStringIfSet("tx_agc_digital_compression_gain", 181 tx_agc_digital_compression_gain); 182 ost << ToStringIfSet("tx_agc_limiter", tx_agc_limiter); 183 ost << ToStringIfSet("recording_sample_rate", recording_sample_rate); 184 ost << ToStringIfSet("playout_sample_rate", playout_sample_rate); 185 ost << ToStringIfSet("dscp", dscp); 186 ost << ToStringIfSet("combined_audio_video_bwe", combined_audio_video_bwe); 187 ost << "}"; 188 return ost.str(); 189 } 190 191 // Audio processing that attempts to filter away the output signal from 192 // later inbound pickup. 193 rtc::Optional<bool> echo_cancellation; 194 // Audio processing to adjust the sensitivity of the local mic dynamically. 195 rtc::Optional<bool> auto_gain_control; 196 // Audio processing to filter out background noise. 197 rtc::Optional<bool> noise_suppression; 198 // Audio processing to remove background noise of lower frequencies. 199 rtc::Optional<bool> highpass_filter; 200 // Audio processing to swap the left and right channels. 201 rtc::Optional<bool> stereo_swapping; 202 // Audio receiver jitter buffer (NetEq) max capacity in number of packets. 203 rtc::Optional<int> audio_jitter_buffer_max_packets; 204 // Audio receiver jitter buffer (NetEq) fast accelerate mode. 205 rtc::Optional<bool> audio_jitter_buffer_fast_accelerate; 206 // Audio processing to detect typing. 207 rtc::Optional<bool> typing_detection; 208 rtc::Optional<bool> aecm_generate_comfort_noise; 209 rtc::Optional<bool> conference_mode; 210 rtc::Optional<int> adjust_agc_delta; 211 rtc::Optional<bool> experimental_agc; 212 rtc::Optional<bool> extended_filter_aec; 213 rtc::Optional<bool> delay_agnostic_aec; 214 rtc::Optional<bool> experimental_ns; 215 rtc::Optional<bool> aec_dump; 216 // Note that tx_agc_* only applies to non-experimental AGC. 217 rtc::Optional<uint16_t> tx_agc_target_dbov; 218 rtc::Optional<uint16_t> tx_agc_digital_compression_gain; 219 rtc::Optional<bool> tx_agc_limiter; 220 rtc::Optional<uint32_t> recording_sample_rate; 221 rtc::Optional<uint32_t> playout_sample_rate; 222 // Set DSCP value for packet sent from audio channel. 223 rtc::Optional<bool> dscp; 224 // Enable combined audio+bandwidth BWE. 225 rtc::Optional<bool> combined_audio_video_bwe; 226 227 private: 228 template <typename T> 229 static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) { 230 if (o) { 231 *s = o; 232 } 233 } 234 }; 235 236 // Options that can be applied to a VideoMediaChannel or a VideoMediaEngine. 237 // Used to be flags, but that makes it hard to selectively apply options. 238 // We are moving all of the setting of options to structs like this, 239 // but some things currently still use flags. 240 struct VideoOptions { 241 VideoOptions() 242 : process_adaptation_threshhold(kProcessCpuThreshold), 243 system_low_adaptation_threshhold(kLowSystemCpuThreshold), 244 system_high_adaptation_threshhold(kHighSystemCpuThreshold), 245 unsignalled_recv_stream_limit(kNumDefaultUnsignalledVideoRecvStreams) {} 246 247 void SetAll(const VideoOptions& change) { 248 SetFrom(&adapt_input_to_cpu_usage, change.adapt_input_to_cpu_usage); 249 SetFrom(&adapt_cpu_with_smoothing, change.adapt_cpu_with_smoothing); 250 SetFrom(&video_adapt_third, change.video_adapt_third); 251 SetFrom(&video_noise_reduction, change.video_noise_reduction); 252 SetFrom(&video_start_bitrate, change.video_start_bitrate); 253 SetFrom(&cpu_overuse_detection, change.cpu_overuse_detection); 254 SetFrom(&cpu_underuse_threshold, change.cpu_underuse_threshold); 255 SetFrom(&cpu_overuse_threshold, change.cpu_overuse_threshold); 256 SetFrom(&cpu_underuse_encode_rsd_threshold, 257 change.cpu_underuse_encode_rsd_threshold); 258 SetFrom(&cpu_overuse_encode_rsd_threshold, 259 change.cpu_overuse_encode_rsd_threshold); 260 SetFrom(&cpu_overuse_encode_usage, change.cpu_overuse_encode_usage); 261 SetFrom(&conference_mode, change.conference_mode); 262 SetFrom(&process_adaptation_threshhold, 263 change.process_adaptation_threshhold); 264 SetFrom(&system_low_adaptation_threshhold, 265 change.system_low_adaptation_threshhold); 266 SetFrom(&system_high_adaptation_threshhold, 267 change.system_high_adaptation_threshhold); 268 SetFrom(&dscp, change.dscp); 269 SetFrom(&suspend_below_min_bitrate, change.suspend_below_min_bitrate); 270 SetFrom(&unsignalled_recv_stream_limit, 271 change.unsignalled_recv_stream_limit); 272 SetFrom(&use_simulcast_adapter, change.use_simulcast_adapter); 273 SetFrom(&screencast_min_bitrate, change.screencast_min_bitrate); 274 SetFrom(&disable_prerenderer_smoothing, 275 change.disable_prerenderer_smoothing); 276 } 277 278 bool operator==(const VideoOptions& o) const { 279 return adapt_input_to_cpu_usage == o.adapt_input_to_cpu_usage && 280 adapt_cpu_with_smoothing == o.adapt_cpu_with_smoothing && 281 video_adapt_third == o.video_adapt_third && 282 video_noise_reduction == o.video_noise_reduction && 283 video_start_bitrate == o.video_start_bitrate && 284 cpu_overuse_detection == o.cpu_overuse_detection && 285 cpu_underuse_threshold == o.cpu_underuse_threshold && 286 cpu_overuse_threshold == o.cpu_overuse_threshold && 287 cpu_underuse_encode_rsd_threshold == 288 o.cpu_underuse_encode_rsd_threshold && 289 cpu_overuse_encode_rsd_threshold == 290 o.cpu_overuse_encode_rsd_threshold && 291 cpu_overuse_encode_usage == o.cpu_overuse_encode_usage && 292 conference_mode == o.conference_mode && 293 process_adaptation_threshhold == o.process_adaptation_threshhold && 294 system_low_adaptation_threshhold == 295 o.system_low_adaptation_threshhold && 296 system_high_adaptation_threshhold == 297 o.system_high_adaptation_threshhold && 298 dscp == o.dscp && 299 suspend_below_min_bitrate == o.suspend_below_min_bitrate && 300 unsignalled_recv_stream_limit == o.unsignalled_recv_stream_limit && 301 use_simulcast_adapter == o.use_simulcast_adapter && 302 screencast_min_bitrate == o.screencast_min_bitrate && 303 disable_prerenderer_smoothing == o.disable_prerenderer_smoothing; 304 } 305 306 std::string ToString() const { 307 std::ostringstream ost; 308 ost << "VideoOptions {"; 309 ost << ToStringIfSet("cpu adaption", adapt_input_to_cpu_usage); 310 ost << ToStringIfSet("cpu adaptation smoothing", adapt_cpu_with_smoothing); 311 ost << ToStringIfSet("video adapt third", video_adapt_third); 312 ost << ToStringIfSet("noise reduction", video_noise_reduction); 313 ost << ToStringIfSet("start bitrate", video_start_bitrate); 314 ost << ToStringIfSet("cpu overuse detection", cpu_overuse_detection); 315 ost << ToStringIfSet("cpu underuse threshold", cpu_underuse_threshold); 316 ost << ToStringIfSet("cpu overuse threshold", cpu_overuse_threshold); 317 ost << ToStringIfSet("cpu underuse encode rsd threshold", 318 cpu_underuse_encode_rsd_threshold); 319 ost << ToStringIfSet("cpu overuse encode rsd threshold", 320 cpu_overuse_encode_rsd_threshold); 321 ost << ToStringIfSet("cpu overuse encode usage", 322 cpu_overuse_encode_usage); 323 ost << ToStringIfSet("conference mode", conference_mode); 324 ost << ToStringIfSet("process", process_adaptation_threshhold); 325 ost << ToStringIfSet("low", system_low_adaptation_threshhold); 326 ost << ToStringIfSet("high", system_high_adaptation_threshhold); 327 ost << ToStringIfSet("dscp", dscp); 328 ost << ToStringIfSet("suspend below min bitrate", 329 suspend_below_min_bitrate); 330 ost << ToStringIfSet("num channels for early receive", 331 unsignalled_recv_stream_limit); 332 ost << ToStringIfSet("use simulcast adapter", use_simulcast_adapter); 333 ost << ToStringIfSet("screencast min bitrate", screencast_min_bitrate); 334 ost << "}"; 335 return ost.str(); 336 } 337 338 // Enable CPU adaptation? 339 rtc::Optional<bool> adapt_input_to_cpu_usage; 340 // Enable CPU adaptation smoothing? 341 rtc::Optional<bool> adapt_cpu_with_smoothing; 342 // Enable video adapt third? 343 rtc::Optional<bool> video_adapt_third; 344 // Enable denoising? 345 rtc::Optional<bool> video_noise_reduction; 346 // Experimental: Enable WebRtc higher start bitrate? 347 rtc::Optional<int> video_start_bitrate; 348 // Enable WebRTC Cpu Overuse Detection, which is a new version of the CPU 349 // adaptation algorithm. So this option will override the 350 // |adapt_input_to_cpu_usage|. 351 rtc::Optional<bool> cpu_overuse_detection; 352 // Low threshold (t1) for cpu overuse adaptation. (Adapt up) 353 // Metric: encode usage (m1). m1 < t1 => underuse. 354 rtc::Optional<int> cpu_underuse_threshold; 355 // High threshold (t1) for cpu overuse adaptation. (Adapt down) 356 // Metric: encode usage (m1). m1 > t1 => overuse. 357 rtc::Optional<int> cpu_overuse_threshold; 358 // Low threshold (t2) for cpu overuse adaptation. (Adapt up) 359 // Metric: relative standard deviation of encode time (m2). 360 // Optional threshold. If set, (m1 < t1 && m2 < t2) => underuse. 361 // Note: t2 will have no effect if t1 is not set. 362 rtc::Optional<int> cpu_underuse_encode_rsd_threshold; 363 // High threshold (t2) for cpu overuse adaptation. (Adapt down) 364 // Metric: relative standard deviation of encode time (m2). 365 // Optional threshold. If set, (m1 > t1 || m2 > t2) => overuse. 366 // Note: t2 will have no effect if t1 is not set. 367 rtc::Optional<int> cpu_overuse_encode_rsd_threshold; 368 // Use encode usage for cpu detection. 369 rtc::Optional<bool> cpu_overuse_encode_usage; 370 // Use conference mode? 371 rtc::Optional<bool> conference_mode; 372 // Threshhold for process cpu adaptation. (Process limit) 373 rtc::Optional<float> process_adaptation_threshhold; 374 // Low threshhold for cpu adaptation. (Adapt up) 375 rtc::Optional<float> system_low_adaptation_threshhold; 376 // High threshhold for cpu adaptation. (Adapt down) 377 rtc::Optional<float> system_high_adaptation_threshhold; 378 // Set DSCP value for packet sent from video channel. 379 rtc::Optional<bool> dscp; 380 // Enable WebRTC suspension of video. No video frames will be sent when the 381 // bitrate is below the configured minimum bitrate. 382 rtc::Optional<bool> suspend_below_min_bitrate; 383 // Limit on the number of early receive channels that can be created. 384 rtc::Optional<int> unsignalled_recv_stream_limit; 385 // Enable use of simulcast adapter. 386 rtc::Optional<bool> use_simulcast_adapter; 387 // Force screencast to use a minimum bitrate 388 rtc::Optional<int> screencast_min_bitrate; 389 // Set to true if the renderer has an algorithm of frame selection. 390 // If the value is true, then WebRTC will hand over a frame as soon as 391 // possible without delay, and rendering smoothness is completely the duty 392 // of the renderer; 393 // If the value is false, then WebRTC is responsible to delay frame release 394 // in order to increase rendering smoothness. 395 rtc::Optional<bool> disable_prerenderer_smoothing; 396 397 private: 398 template <typename T> 399 static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) { 400 if (o) { 401 *s = o; 402 } 403 } 404 }; 405 406 struct RtpHeaderExtension { 407 RtpHeaderExtension() : id(0) {} 408 RtpHeaderExtension(const std::string& u, int i) : uri(u), id(i) {} 409 410 bool operator==(const RtpHeaderExtension& ext) const { 411 // id is a reserved word in objective-c. Therefore the id attribute has to 412 // be a fully qualified name in order to compile on IOS. 413 return this->id == ext.id && 414 uri == ext.uri; 415 } 416 417 std::string ToString() const { 418 std::ostringstream ost; 419 ost << "{"; 420 ost << "uri: " << uri; 421 ost << ", id: " << id; 422 ost << "}"; 423 return ost.str(); 424 } 425 426 std::string uri; 427 int id; 428 // TODO(juberti): SendRecv direction; 429 }; 430 431 // Returns the named header extension if found among all extensions, NULL 432 // otherwise. 433 inline const RtpHeaderExtension* FindHeaderExtension( 434 const std::vector<RtpHeaderExtension>& extensions, 435 const std::string& name) { 436 for (std::vector<RtpHeaderExtension>::const_iterator it = extensions.begin(); 437 it != extensions.end(); ++it) { 438 if (it->uri == name) 439 return &(*it); 440 } 441 return NULL; 442 } 443 444 enum MediaChannelOptions { 445 // Tune the stream for conference mode. 446 OPT_CONFERENCE = 0x0001 447 }; 448 449 enum VoiceMediaChannelOptions { 450 // Tune the audio stream for vcs with different target levels. 451 OPT_AGC_MINUS_10DB = 0x80000000 452 }; 453 454 class MediaChannel : public sigslot::has_slots<> { 455 public: 456 class NetworkInterface { 457 public: 458 enum SocketType { ST_RTP, ST_RTCP }; 459 virtual bool SendPacket(rtc::Buffer* packet, 460 const rtc::PacketOptions& options) = 0; 461 virtual bool SendRtcp(rtc::Buffer* packet, 462 const rtc::PacketOptions& options) = 0; 463 virtual int SetOption(SocketType type, rtc::Socket::Option opt, 464 int option) = 0; 465 virtual ~NetworkInterface() {} 466 }; 467 468 MediaChannel() : network_interface_(NULL) {} 469 virtual ~MediaChannel() {} 470 471 // Sets the abstract interface class for sending RTP/RTCP data. 472 virtual void SetInterface(NetworkInterface *iface) { 473 rtc::CritScope cs(&network_interface_crit_); 474 network_interface_ = iface; 475 } 476 477 // Called when a RTP packet is received. 478 virtual void OnPacketReceived(rtc::Buffer* packet, 479 const rtc::PacketTime& packet_time) = 0; 480 // Called when a RTCP packet is received. 481 virtual void OnRtcpReceived(rtc::Buffer* packet, 482 const rtc::PacketTime& packet_time) = 0; 483 // Called when the socket's ability to send has changed. 484 virtual void OnReadyToSend(bool ready) = 0; 485 // Creates a new outgoing media stream with SSRCs and CNAME as described 486 // by sp. 487 virtual bool AddSendStream(const StreamParams& sp) = 0; 488 // Removes an outgoing media stream. 489 // ssrc must be the first SSRC of the media stream if the stream uses 490 // multiple SSRCs. 491 virtual bool RemoveSendStream(uint32_t ssrc) = 0; 492 // Creates a new incoming media stream with SSRCs and CNAME as described 493 // by sp. 494 virtual bool AddRecvStream(const StreamParams& sp) = 0; 495 // Removes an incoming media stream. 496 // ssrc must be the first SSRC of the media stream if the stream uses 497 // multiple SSRCs. 498 virtual bool RemoveRecvStream(uint32_t ssrc) = 0; 499 500 // Returns the absoulte sendtime extension id value from media channel. 501 virtual int GetRtpSendTimeExtnId() const { 502 return -1; 503 } 504 505 // Base method to send packet using NetworkInterface. 506 bool SendPacket(rtc::Buffer* packet, const rtc::PacketOptions& options) { 507 return DoSendPacket(packet, false, options); 508 } 509 510 bool SendRtcp(rtc::Buffer* packet, const rtc::PacketOptions& options) { 511 return DoSendPacket(packet, true, options); 512 } 513 514 int SetOption(NetworkInterface::SocketType type, 515 rtc::Socket::Option opt, 516 int option) { 517 rtc::CritScope cs(&network_interface_crit_); 518 if (!network_interface_) 519 return -1; 520 521 return network_interface_->SetOption(type, opt, option); 522 } 523 524 protected: 525 // This method sets DSCP |value| on both RTP and RTCP channels. 526 int SetDscp(rtc::DiffServCodePoint value) { 527 int ret; 528 ret = SetOption(NetworkInterface::ST_RTP, 529 rtc::Socket::OPT_DSCP, 530 value); 531 if (ret == 0) { 532 ret = SetOption(NetworkInterface::ST_RTCP, 533 rtc::Socket::OPT_DSCP, 534 value); 535 } 536 return ret; 537 } 538 539 private: 540 bool DoSendPacket(rtc::Buffer* packet, 541 bool rtcp, 542 const rtc::PacketOptions& options) { 543 rtc::CritScope cs(&network_interface_crit_); 544 if (!network_interface_) 545 return false; 546 547 return (!rtcp) ? network_interface_->SendPacket(packet, options) 548 : network_interface_->SendRtcp(packet, options); 549 } 550 551 // |network_interface_| can be accessed from the worker_thread and 552 // from any MediaEngine threads. This critical section is to protect accessing 553 // of network_interface_ object. 554 rtc::CriticalSection network_interface_crit_; 555 NetworkInterface* network_interface_; 556 }; 557 558 enum SendFlags { 559 SEND_NOTHING, 560 SEND_MICROPHONE 561 }; 562 563 // The stats information is structured as follows: 564 // Media are represented by either MediaSenderInfo or MediaReceiverInfo. 565 // Media contains a vector of SSRC infos that are exclusively used by this 566 // media. (SSRCs shared between media streams can't be represented.) 567 568 // Information about an SSRC. 569 // This data may be locally recorded, or received in an RTCP SR or RR. 570 struct SsrcSenderInfo { 571 SsrcSenderInfo() 572 : ssrc(0), 573 timestamp(0) { 574 } 575 uint32_t ssrc; 576 double timestamp; // NTP timestamp, represented as seconds since epoch. 577 }; 578 579 struct SsrcReceiverInfo { 580 SsrcReceiverInfo() 581 : ssrc(0), 582 timestamp(0) { 583 } 584 uint32_t ssrc; 585 double timestamp; 586 }; 587 588 struct MediaSenderInfo { 589 MediaSenderInfo() 590 : bytes_sent(0), 591 packets_sent(0), 592 packets_lost(0), 593 fraction_lost(0.0), 594 rtt_ms(0) { 595 } 596 void add_ssrc(const SsrcSenderInfo& stat) { 597 local_stats.push_back(stat); 598 } 599 // Temporary utility function for call sites that only provide SSRC. 600 // As more info is added into SsrcSenderInfo, this function should go away. 601 void add_ssrc(uint32_t ssrc) { 602 SsrcSenderInfo stat; 603 stat.ssrc = ssrc; 604 add_ssrc(stat); 605 } 606 // Utility accessor for clients that are only interested in ssrc numbers. 607 std::vector<uint32_t> ssrcs() const { 608 std::vector<uint32_t> retval; 609 for (std::vector<SsrcSenderInfo>::const_iterator it = local_stats.begin(); 610 it != local_stats.end(); ++it) { 611 retval.push_back(it->ssrc); 612 } 613 return retval; 614 } 615 // Utility accessor for clients that make the assumption only one ssrc 616 // exists per media. 617 // This will eventually go away. 618 uint32_t ssrc() const { 619 if (local_stats.size() > 0) { 620 return local_stats[0].ssrc; 621 } else { 622 return 0; 623 } 624 } 625 int64_t bytes_sent; 626 int packets_sent; 627 int packets_lost; 628 float fraction_lost; 629 int64_t rtt_ms; 630 std::string codec_name; 631 std::vector<SsrcSenderInfo> local_stats; 632 std::vector<SsrcReceiverInfo> remote_stats; 633 }; 634 635 template<class T> 636 struct VariableInfo { 637 VariableInfo() 638 : min_val(), 639 mean(0.0), 640 max_val(), 641 variance(0.0) { 642 } 643 T min_val; 644 double mean; 645 T max_val; 646 double variance; 647 }; 648 649 struct MediaReceiverInfo { 650 MediaReceiverInfo() 651 : bytes_rcvd(0), 652 packets_rcvd(0), 653 packets_lost(0), 654 fraction_lost(0.0) { 655 } 656 void add_ssrc(const SsrcReceiverInfo& stat) { 657 local_stats.push_back(stat); 658 } 659 // Temporary utility function for call sites that only provide SSRC. 660 // As more info is added into SsrcSenderInfo, this function should go away. 661 void add_ssrc(uint32_t ssrc) { 662 SsrcReceiverInfo stat; 663 stat.ssrc = ssrc; 664 add_ssrc(stat); 665 } 666 std::vector<uint32_t> ssrcs() const { 667 std::vector<uint32_t> retval; 668 for (std::vector<SsrcReceiverInfo>::const_iterator it = local_stats.begin(); 669 it != local_stats.end(); ++it) { 670 retval.push_back(it->ssrc); 671 } 672 return retval; 673 } 674 // Utility accessor for clients that make the assumption only one ssrc 675 // exists per media. 676 // This will eventually go away. 677 uint32_t ssrc() const { 678 if (local_stats.size() > 0) { 679 return local_stats[0].ssrc; 680 } else { 681 return 0; 682 } 683 } 684 685 int64_t bytes_rcvd; 686 int packets_rcvd; 687 int packets_lost; 688 float fraction_lost; 689 std::string codec_name; 690 std::vector<SsrcReceiverInfo> local_stats; 691 std::vector<SsrcSenderInfo> remote_stats; 692 }; 693 694 struct VoiceSenderInfo : public MediaSenderInfo { 695 VoiceSenderInfo() 696 : ext_seqnum(0), 697 jitter_ms(0), 698 audio_level(0), 699 aec_quality_min(0.0), 700 echo_delay_median_ms(0), 701 echo_delay_std_ms(0), 702 echo_return_loss(0), 703 echo_return_loss_enhancement(0), 704 typing_noise_detected(false) { 705 } 706 707 int ext_seqnum; 708 int jitter_ms; 709 int audio_level; 710 float aec_quality_min; 711 int echo_delay_median_ms; 712 int echo_delay_std_ms; 713 int echo_return_loss; 714 int echo_return_loss_enhancement; 715 bool typing_noise_detected; 716 }; 717 718 struct VoiceReceiverInfo : public MediaReceiverInfo { 719 VoiceReceiverInfo() 720 : ext_seqnum(0), 721 jitter_ms(0), 722 jitter_buffer_ms(0), 723 jitter_buffer_preferred_ms(0), 724 delay_estimate_ms(0), 725 audio_level(0), 726 expand_rate(0), 727 speech_expand_rate(0), 728 secondary_decoded_rate(0), 729 accelerate_rate(0), 730 preemptive_expand_rate(0), 731 decoding_calls_to_silence_generator(0), 732 decoding_calls_to_neteq(0), 733 decoding_normal(0), 734 decoding_plc(0), 735 decoding_cng(0), 736 decoding_plc_cng(0), 737 capture_start_ntp_time_ms(-1) {} 738 739 int ext_seqnum; 740 int jitter_ms; 741 int jitter_buffer_ms; 742 int jitter_buffer_preferred_ms; 743 int delay_estimate_ms; 744 int audio_level; 745 // fraction of synthesized audio inserted through expansion. 746 float expand_rate; 747 // fraction of synthesized speech inserted through expansion. 748 float speech_expand_rate; 749 // fraction of data out of secondary decoding, including FEC and RED. 750 float secondary_decoded_rate; 751 // Fraction of data removed through time compression. 752 float accelerate_rate; 753 // Fraction of data inserted through time stretching. 754 float preemptive_expand_rate; 755 int decoding_calls_to_silence_generator; 756 int decoding_calls_to_neteq; 757 int decoding_normal; 758 int decoding_plc; 759 int decoding_cng; 760 int decoding_plc_cng; 761 // Estimated capture start time in NTP time in ms. 762 int64_t capture_start_ntp_time_ms; 763 }; 764 765 struct VideoSenderInfo : public MediaSenderInfo { 766 VideoSenderInfo() 767 : packets_cached(0), 768 firs_rcvd(0), 769 plis_rcvd(0), 770 nacks_rcvd(0), 771 input_frame_width(0), 772 input_frame_height(0), 773 send_frame_width(0), 774 send_frame_height(0), 775 framerate_input(0), 776 framerate_sent(0), 777 nominal_bitrate(0), 778 preferred_bitrate(0), 779 adapt_reason(0), 780 adapt_changes(0), 781 avg_encode_ms(0), 782 encode_usage_percent(0) { 783 } 784 785 std::vector<SsrcGroup> ssrc_groups; 786 std::string encoder_implementation_name; 787 int packets_cached; 788 int firs_rcvd; 789 int plis_rcvd; 790 int nacks_rcvd; 791 int input_frame_width; 792 int input_frame_height; 793 int send_frame_width; 794 int send_frame_height; 795 int framerate_input; 796 int framerate_sent; 797 int nominal_bitrate; 798 int preferred_bitrate; 799 int adapt_reason; 800 int adapt_changes; 801 int avg_encode_ms; 802 int encode_usage_percent; 803 VariableInfo<int> adapt_frame_drops; 804 VariableInfo<int> effects_frame_drops; 805 VariableInfo<double> capturer_frame_time; 806 }; 807 808 struct VideoReceiverInfo : public MediaReceiverInfo { 809 VideoReceiverInfo() 810 : packets_concealed(0), 811 firs_sent(0), 812 plis_sent(0), 813 nacks_sent(0), 814 frame_width(0), 815 frame_height(0), 816 framerate_rcvd(0), 817 framerate_decoded(0), 818 framerate_output(0), 819 framerate_render_input(0), 820 framerate_render_output(0), 821 decode_ms(0), 822 max_decode_ms(0), 823 jitter_buffer_ms(0), 824 min_playout_delay_ms(0), 825 render_delay_ms(0), 826 target_delay_ms(0), 827 current_delay_ms(0), 828 capture_start_ntp_time_ms(-1) { 829 } 830 831 std::vector<SsrcGroup> ssrc_groups; 832 std::string decoder_implementation_name; 833 int packets_concealed; 834 int firs_sent; 835 int plis_sent; 836 int nacks_sent; 837 int frame_width; 838 int frame_height; 839 int framerate_rcvd; 840 int framerate_decoded; 841 int framerate_output; 842 // Framerate as sent to the renderer. 843 int framerate_render_input; 844 // Framerate that the renderer reports. 845 int framerate_render_output; 846 847 // All stats below are gathered per-VideoReceiver, but some will be correlated 848 // across MediaStreamTracks. NOTE(hta): when sinking stats into per-SSRC 849 // structures, reflect this in the new layout. 850 851 // Current frame decode latency. 852 int decode_ms; 853 // Maximum observed frame decode latency. 854 int max_decode_ms; 855 // Jitter (network-related) latency. 856 int jitter_buffer_ms; 857 // Requested minimum playout latency. 858 int min_playout_delay_ms; 859 // Requested latency to account for rendering delay. 860 int render_delay_ms; 861 // Target overall delay: network+decode+render, accounting for 862 // min_playout_delay_ms. 863 int target_delay_ms; 864 // Current overall delay, possibly ramping towards target_delay_ms. 865 int current_delay_ms; 866 867 // Estimated capture start time in NTP time in ms. 868 int64_t capture_start_ntp_time_ms; 869 }; 870 871 struct DataSenderInfo : public MediaSenderInfo { 872 DataSenderInfo() 873 : ssrc(0) { 874 } 875 876 uint32_t ssrc; 877 }; 878 879 struct DataReceiverInfo : public MediaReceiverInfo { 880 DataReceiverInfo() 881 : ssrc(0) { 882 } 883 884 uint32_t ssrc; 885 }; 886 887 struct BandwidthEstimationInfo { 888 BandwidthEstimationInfo() 889 : available_send_bandwidth(0), 890 available_recv_bandwidth(0), 891 target_enc_bitrate(0), 892 actual_enc_bitrate(0), 893 retransmit_bitrate(0), 894 transmit_bitrate(0), 895 bucket_delay(0) { 896 } 897 898 int available_send_bandwidth; 899 int available_recv_bandwidth; 900 int target_enc_bitrate; 901 int actual_enc_bitrate; 902 int retransmit_bitrate; 903 int transmit_bitrate; 904 int64_t bucket_delay; 905 }; 906 907 struct VoiceMediaInfo { 908 void Clear() { 909 senders.clear(); 910 receivers.clear(); 911 } 912 std::vector<VoiceSenderInfo> senders; 913 std::vector<VoiceReceiverInfo> receivers; 914 }; 915 916 struct VideoMediaInfo { 917 void Clear() { 918 senders.clear(); 919 receivers.clear(); 920 bw_estimations.clear(); 921 } 922 std::vector<VideoSenderInfo> senders; 923 std::vector<VideoReceiverInfo> receivers; 924 std::vector<BandwidthEstimationInfo> bw_estimations; 925 }; 926 927 struct DataMediaInfo { 928 void Clear() { 929 senders.clear(); 930 receivers.clear(); 931 } 932 std::vector<DataSenderInfo> senders; 933 std::vector<DataReceiverInfo> receivers; 934 }; 935 936 struct RtcpParameters { 937 bool reduced_size = false; 938 }; 939 940 template <class Codec> 941 struct RtpParameters { 942 virtual std::string ToString() const { 943 std::ostringstream ost; 944 ost << "{"; 945 ost << "codecs: " << VectorToString(codecs) << ", "; 946 ost << "extensions: " << VectorToString(extensions); 947 ost << "}"; 948 return ost.str(); 949 } 950 951 std::vector<Codec> codecs; 952 std::vector<RtpHeaderExtension> extensions; 953 // TODO(pthatcher): Add streams. 954 RtcpParameters rtcp; 955 }; 956 957 template <class Codec, class Options> 958 struct RtpSendParameters : RtpParameters<Codec> { 959 std::string ToString() const override { 960 std::ostringstream ost; 961 ost << "{"; 962 ost << "codecs: " << VectorToString(this->codecs) << ", "; 963 ost << "extensions: " << VectorToString(this->extensions) << ", "; 964 ost << "max_bandiwidth_bps: " << max_bandwidth_bps << ", "; 965 ost << "options: " << options.ToString(); 966 ost << "}"; 967 return ost.str(); 968 } 969 970 int max_bandwidth_bps = -1; 971 Options options; 972 }; 973 974 struct AudioSendParameters : RtpSendParameters<AudioCodec, AudioOptions> { 975 }; 976 977 struct AudioRecvParameters : RtpParameters<AudioCodec> { 978 }; 979 980 class VoiceMediaChannel : public MediaChannel { 981 public: 982 enum Error { 983 ERROR_NONE = 0, // No error. 984 ERROR_OTHER, // Other errors. 985 ERROR_REC_DEVICE_OPEN_FAILED = 100, // Could not open mic. 986 ERROR_REC_DEVICE_MUTED, // Mic was muted by OS. 987 ERROR_REC_DEVICE_SILENT, // No background noise picked up. 988 ERROR_REC_DEVICE_SATURATION, // Mic input is clipping. 989 ERROR_REC_DEVICE_REMOVED, // Mic was removed while active. 990 ERROR_REC_RUNTIME_ERROR, // Processing is encountering errors. 991 ERROR_REC_SRTP_ERROR, // Generic SRTP failure. 992 ERROR_REC_SRTP_AUTH_FAILED, // Failed to authenticate packets. 993 ERROR_REC_TYPING_NOISE_DETECTED, // Typing noise is detected. 994 ERROR_PLAY_DEVICE_OPEN_FAILED = 200, // Could not open playout. 995 ERROR_PLAY_DEVICE_MUTED, // Playout muted by OS. 996 ERROR_PLAY_DEVICE_REMOVED, // Playout removed while active. 997 ERROR_PLAY_RUNTIME_ERROR, // Errors in voice processing. 998 ERROR_PLAY_SRTP_ERROR, // Generic SRTP failure. 999 ERROR_PLAY_SRTP_AUTH_FAILED, // Failed to authenticate packets. 1000 ERROR_PLAY_SRTP_REPLAY, // Packet replay detected. 1001 }; 1002 1003 VoiceMediaChannel() {} 1004 virtual ~VoiceMediaChannel() {} 1005 virtual bool SetSendParameters(const AudioSendParameters& params) = 0; 1006 virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0; 1007 // Starts or stops playout of received audio. 1008 virtual bool SetPlayout(bool playout) = 0; 1009 // Starts or stops sending (and potentially capture) of local audio. 1010 virtual bool SetSend(SendFlags flag) = 0; 1011 // Configure stream for sending. 1012 virtual bool SetAudioSend(uint32_t ssrc, 1013 bool enable, 1014 const AudioOptions* options, 1015 AudioRenderer* renderer) = 0; 1016 // Gets current energy levels for all incoming streams. 1017 virtual bool GetActiveStreams(AudioInfo::StreamList* actives) = 0; 1018 // Get the current energy level of the stream sent to the speaker. 1019 virtual int GetOutputLevel() = 0; 1020 // Get the time in milliseconds since last recorded keystroke, or negative. 1021 virtual int GetTimeSinceLastTyping() = 0; 1022 // Temporarily exposed field for tuning typing detect options. 1023 virtual void SetTypingDetectionParameters(int time_window, 1024 int cost_per_typing, int reporting_threshold, int penalty_decay, 1025 int type_event_delay) = 0; 1026 // Set speaker output volume of the specified ssrc. 1027 virtual bool SetOutputVolume(uint32_t ssrc, double volume) = 0; 1028 // Returns if the telephone-event has been negotiated. 1029 virtual bool CanInsertDtmf() = 0; 1030 // Send a DTMF |event|. The DTMF out-of-band signal will be used. 1031 // The |ssrc| should be either 0 or a valid send stream ssrc. 1032 // The valid value for the |event| are 0 to 15 which corresponding to 1033 // DTMF event 0-9, *, #, A-D. 1034 virtual bool InsertDtmf(uint32_t ssrc, int event, int duration) = 0; 1035 // Gets quality stats for the channel. 1036 virtual bool GetStats(VoiceMediaInfo* info) = 0; 1037 1038 virtual void SetRawAudioSink( 1039 uint32_t ssrc, 1040 rtc::scoped_ptr<webrtc::AudioSinkInterface> sink) = 0; 1041 }; 1042 1043 struct VideoSendParameters : RtpSendParameters<VideoCodec, VideoOptions> { 1044 }; 1045 1046 struct VideoRecvParameters : RtpParameters<VideoCodec> { 1047 }; 1048 1049 class VideoMediaChannel : public MediaChannel { 1050 public: 1051 enum Error { 1052 ERROR_NONE = 0, // No error. 1053 ERROR_OTHER, // Other errors. 1054 ERROR_REC_DEVICE_OPEN_FAILED = 100, // Could not open camera. 1055 ERROR_REC_DEVICE_NO_DEVICE, // No camera. 1056 ERROR_REC_DEVICE_IN_USE, // Device is in already use. 1057 ERROR_REC_DEVICE_REMOVED, // Device is removed. 1058 ERROR_REC_SRTP_ERROR, // Generic sender SRTP failure. 1059 ERROR_REC_SRTP_AUTH_FAILED, // Failed to authenticate packets. 1060 ERROR_REC_CPU_MAX_CANT_DOWNGRADE, // Can't downgrade capture anymore. 1061 ERROR_PLAY_SRTP_ERROR = 200, // Generic receiver SRTP failure. 1062 ERROR_PLAY_SRTP_AUTH_FAILED, // Failed to authenticate packets. 1063 ERROR_PLAY_SRTP_REPLAY, // Packet replay detected. 1064 }; 1065 1066 VideoMediaChannel() : renderer_(NULL) {} 1067 virtual ~VideoMediaChannel() {} 1068 1069 virtual bool SetSendParameters(const VideoSendParameters& params) = 0; 1070 virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0; 1071 // Gets the currently set codecs/payload types to be used for outgoing media. 1072 virtual bool GetSendCodec(VideoCodec* send_codec) = 0; 1073 // Sets the format of a specified outgoing stream. 1074 virtual bool SetSendStreamFormat(uint32_t ssrc, 1075 const VideoFormat& format) = 0; 1076 // Starts or stops transmission (and potentially capture) of local video. 1077 virtual bool SetSend(bool send) = 0; 1078 // Configure stream for sending. 1079 virtual bool SetVideoSend(uint32_t ssrc, 1080 bool enable, 1081 const VideoOptions* options) = 0; 1082 // Sets the renderer object to be used for the specified stream. 1083 // If SSRC is 0, the renderer is used for the 'default' stream. 1084 virtual bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer) = 0; 1085 // If |ssrc| is 0, replace the default capturer (engine capturer) with 1086 // |capturer|. If |ssrc| is non zero create a new stream with |ssrc| as SSRC. 1087 virtual bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) = 0; 1088 // Gets quality stats for the channel. 1089 virtual bool GetStats(VideoMediaInfo* info) = 0; 1090 // Send an intra frame to the receivers. 1091 virtual bool SendIntraFrame() = 0; 1092 // Reuqest each of the remote senders to send an intra frame. 1093 virtual bool RequestIntraFrame() = 0; 1094 virtual void UpdateAspectRatio(int ratio_w, int ratio_h) = 0; 1095 1096 protected: 1097 VideoRenderer *renderer_; 1098 }; 1099 1100 enum DataMessageType { 1101 // Chrome-Internal use only. See SctpDataMediaChannel for the actual PPID 1102 // values. 1103 DMT_NONE = 0, 1104 DMT_CONTROL = 1, 1105 DMT_BINARY = 2, 1106 DMT_TEXT = 3, 1107 }; 1108 1109 // Info about data received in DataMediaChannel. For use in 1110 // DataMediaChannel::SignalDataReceived and in all of the signals that 1111 // signal fires, on up the chain. 1112 struct ReceiveDataParams { 1113 // The in-packet stream indentifier. 1114 // For SCTP, this is really SID, not SSRC. 1115 uint32_t ssrc; 1116 // The type of message (binary, text, or control). 1117 DataMessageType type; 1118 // A per-stream value incremented per packet in the stream. 1119 int seq_num; 1120 // A per-stream value monotonically increasing with time. 1121 int timestamp; 1122 1123 ReceiveDataParams() : 1124 ssrc(0), 1125 type(DMT_TEXT), 1126 seq_num(0), 1127 timestamp(0) { 1128 } 1129 }; 1130 1131 struct SendDataParams { 1132 // The in-packet stream indentifier. 1133 // For SCTP, this is really SID, not SSRC. 1134 uint32_t ssrc; 1135 // The type of message (binary, text, or control). 1136 DataMessageType type; 1137 1138 // For SCTP, whether to send messages flagged as ordered or not. 1139 // If false, messages can be received out of order. 1140 bool ordered; 1141 // For SCTP, whether the messages are sent reliably or not. 1142 // If false, messages may be lost. 1143 bool reliable; 1144 // For SCTP, if reliable == false, provide partial reliability by 1145 // resending up to this many times. Either count or millis 1146 // is supported, not both at the same time. 1147 int max_rtx_count; 1148 // For SCTP, if reliable == false, provide partial reliability by 1149 // resending for up to this many milliseconds. Either count or millis 1150 // is supported, not both at the same time. 1151 int max_rtx_ms; 1152 1153 SendDataParams() : 1154 ssrc(0), 1155 type(DMT_TEXT), 1156 // TODO(pthatcher): Make these true by default? 1157 ordered(false), 1158 reliable(false), 1159 max_rtx_count(0), 1160 max_rtx_ms(0) { 1161 } 1162 }; 1163 1164 enum SendDataResult { SDR_SUCCESS, SDR_ERROR, SDR_BLOCK }; 1165 1166 struct DataOptions { 1167 std::string ToString() const { 1168 return "{}"; 1169 } 1170 }; 1171 1172 struct DataSendParameters : RtpSendParameters<DataCodec, DataOptions> { 1173 std::string ToString() const { 1174 std::ostringstream ost; 1175 // Options and extensions aren't used. 1176 ost << "{"; 1177 ost << "codecs: " << VectorToString(codecs) << ", "; 1178 ost << "max_bandiwidth_bps: " << max_bandwidth_bps; 1179 ost << "}"; 1180 return ost.str(); 1181 } 1182 }; 1183 1184 struct DataRecvParameters : RtpParameters<DataCodec> { 1185 }; 1186 1187 class DataMediaChannel : public MediaChannel { 1188 public: 1189 enum Error { 1190 ERROR_NONE = 0, // No error. 1191 ERROR_OTHER, // Other errors. 1192 ERROR_SEND_SRTP_ERROR = 200, // Generic SRTP failure. 1193 ERROR_SEND_SRTP_AUTH_FAILED, // Failed to authenticate packets. 1194 ERROR_RECV_SRTP_ERROR, // Generic SRTP failure. 1195 ERROR_RECV_SRTP_AUTH_FAILED, // Failed to authenticate packets. 1196 ERROR_RECV_SRTP_REPLAY, // Packet replay detected. 1197 }; 1198 1199 virtual ~DataMediaChannel() {} 1200 1201 virtual bool SetSendParameters(const DataSendParameters& params) = 0; 1202 virtual bool SetRecvParameters(const DataRecvParameters& params) = 0; 1203 1204 // TODO(pthatcher): Implement this. 1205 virtual bool GetStats(DataMediaInfo* info) { return true; } 1206 1207 virtual bool SetSend(bool send) = 0; 1208 virtual bool SetReceive(bool receive) = 0; 1209 1210 virtual bool SendData( 1211 const SendDataParams& params, 1212 const rtc::Buffer& payload, 1213 SendDataResult* result = NULL) = 0; 1214 // Signals when data is received (params, data, len) 1215 sigslot::signal3<const ReceiveDataParams&, 1216 const char*, 1217 size_t> SignalDataReceived; 1218 // Signal when the media channel is ready to send the stream. Arguments are: 1219 // writable(bool) 1220 sigslot::signal1<bool> SignalReadyToSend; 1221 // Signal for notifying that the remote side has closed the DataChannel. 1222 sigslot::signal1<uint32_t> SignalStreamClosedRemotely; 1223 }; 1224 1225 } // namespace cricket 1226 1227 #endif // TALK_MEDIA_BASE_MEDIACHANNEL_H_ 1228
