• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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>
ToStringIfSet(const char * key,const rtc::Optional<T> & val)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>
VectorToString(const std::vector<T> & vals)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 {
SetAllAudioOptions102    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  
ToStringAudioOptions158    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>
SetFromAudioOptions229    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 {
VideoOptionsVideoOptions241    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  
SetAllVideoOptions247    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  
ToStringVideoOptions306    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>
SetFromVideoOptions399    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 {
RtpHeaderExtensionRtpHeaderExtension407    RtpHeaderExtension() : id(0) {}
RtpHeaderExtensionRtpHeaderExtension408    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  
ToStringRtpHeaderExtension417    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.
FindHeaderExtension(const std::vector<RtpHeaderExtension> & extensions,const std::string & name)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;
~NetworkInterface()465      virtual ~NetworkInterface() {}
466    };
467  
MediaChannel()468    MediaChannel() : network_interface_(NULL) {}
~MediaChannel()469    virtual ~MediaChannel() {}
470  
471    // Sets the abstract interface class for sending RTP/RTCP data.
SetInterface(NetworkInterface * iface)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.
GetRtpSendTimeExtnId()501    virtual int GetRtpSendTimeExtnId() const {
502      return -1;
503    }
504  
505    // Base method to send packet using NetworkInterface.
SendPacket(rtc::Buffer * packet,const rtc::PacketOptions & options)506    bool SendPacket(rtc::Buffer* packet, const rtc::PacketOptions& options) {
507      return DoSendPacket(packet, false, options);
508    }
509  
SendRtcp(rtc::Buffer * packet,const rtc::PacketOptions & options)510    bool SendRtcp(rtc::Buffer* packet, const rtc::PacketOptions& options) {
511      return DoSendPacket(packet, true, options);
512    }
513  
SetOption(NetworkInterface::SocketType type,rtc::Socket::Option opt,int option)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.
SetDscp(rtc::DiffServCodePoint value)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:
DoSendPacket(rtc::Buffer * packet,bool rtcp,const rtc::PacketOptions & options)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 {
SsrcSenderInfoSsrcSenderInfo571    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 {
SsrcReceiverInfoSsrcReceiverInfo580    SsrcReceiverInfo()
581        : ssrc(0),
582          timestamp(0) {
583    }
584    uint32_t ssrc;
585    double timestamp;
586  };
587  
588  struct MediaSenderInfo {
MediaSenderInfoMediaSenderInfo589    MediaSenderInfo()
590        : bytes_sent(0),
591          packets_sent(0),
592          packets_lost(0),
593          fraction_lost(0.0),
594          rtt_ms(0) {
595    }
add_ssrcMediaSenderInfo596    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.
add_ssrcMediaSenderInfo601    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.
ssrcsMediaSenderInfo607    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.
ssrcMediaSenderInfo618    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 {
VariableInfoVariableInfo637    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 {
MediaReceiverInfoMediaReceiverInfo650    MediaReceiverInfo()
651        : bytes_rcvd(0),
652          packets_rcvd(0),
653          packets_lost(0),
654          fraction_lost(0.0) {
655    }
add_ssrcMediaReceiverInfo656    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.
add_ssrcMediaReceiverInfo661    void add_ssrc(uint32_t ssrc) {
662      SsrcReceiverInfo stat;
663      stat.ssrc = ssrc;
664      add_ssrc(stat);
665    }
ssrcsMediaReceiverInfo666    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.
ssrcMediaReceiverInfo677    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 {
VoiceSenderInfoVoiceSenderInfo695    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 {
VoiceReceiverInfoVoiceReceiverInfo719    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 {
VideoSenderInfoVideoSenderInfo766    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 {
VideoReceiverInfoVideoReceiverInfo809    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 {
DataSenderInfoDataSenderInfo872    DataSenderInfo()
873        : ssrc(0) {
874    }
875  
876    uint32_t ssrc;
877  };
878  
879  struct DataReceiverInfo : public MediaReceiverInfo {
DataReceiverInfoDataReceiverInfo880    DataReceiverInfo()
881        : ssrc(0) {
882    }
883  
884    uint32_t ssrc;
885  };
886  
887  struct BandwidthEstimationInfo {
BandwidthEstimationInfoBandwidthEstimationInfo888    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 {
ClearVoiceMediaInfo908    void Clear() {
909      senders.clear();
910      receivers.clear();
911    }
912    std::vector<VoiceSenderInfo> senders;
913    std::vector<VoiceReceiverInfo> receivers;
914  };
915  
916  struct VideoMediaInfo {
ClearVideoMediaInfo917    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 {
ClearDataMediaInfo928    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 {
ToStringRtpParameters942    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> {
ToStringRtpSendParameters959    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  
VoiceMediaChannel()1003    VoiceMediaChannel() {}
~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  
VideoMediaChannel()1066    VideoMediaChannel() : renderer_(NULL) {}
~VideoMediaChannel()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  
ReceiveDataParamsReceiveDataParams1123    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  
SendDataParamsSendDataParams1153    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 {
ToStringDataOptions1167    std::string ToString() const {
1168      return "{}";
1169    }
1170  };
1171  
1172  struct DataSendParameters : RtpSendParameters<DataCodec, DataOptions> {
ToStringDataSendParameters1173    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  
~DataMediaChannel()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.
GetStats(DataMediaInfo * info)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