Home | History | Annotate | Download | only in webrtc 
      1 /*
      2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 // TODO(pbos): Move Config from common.h to here.
     12 
     13 #ifndef WEBRTC_CONFIG_H_
     14 #define WEBRTC_CONFIG_H_
     15 
     16 #include <string>
     17 #include <vector>
     18 
     19 #include "webrtc/common.h"
     20 #include "webrtc/common_types.h"
     21 #include "webrtc/typedefs.h"
     22 
     23 namespace webrtc {
     24 
     25 // Settings for NACK, see RFC 4585 for details.
     26 struct NackConfig {
     27   NackConfig() : rtp_history_ms(0) {}
     28   // Send side: the time RTP packets are stored for retransmissions.
     29   // Receive side: the time the receiver is prepared to wait for
     30   // retransmissions.
     31   // Set to '0' to disable.
     32   int rtp_history_ms;
     33 };
     34 
     35 // Settings for forward error correction, see RFC 5109 for details. Set the
     36 // payload types to '-1' to disable.
     37 struct FecConfig {
     38   FecConfig()
     39       : ulpfec_payload_type(-1),
     40         red_payload_type(-1),
     41         red_rtx_payload_type(-1) {}
     42   std::string ToString() const;
     43   // Payload type used for ULPFEC packets.
     44   int ulpfec_payload_type;
     45 
     46   // Payload type used for RED packets.
     47   int red_payload_type;
     48 
     49   // RTX payload type for RED payload.
     50   int red_rtx_payload_type;
     51 };
     52 
     53 // RTP header extension, see RFC 5285.
     54 struct RtpExtension {
     55   RtpExtension(const std::string& name, int id) : name(name), id(id) {}
     56   std::string ToString() const;
     57   bool operator==(const RtpExtension& rhs) const {
     58     return name == rhs.name && id == rhs.id;
     59   }
     60   static bool IsSupportedForAudio(const std::string& name);
     61   static bool IsSupportedForVideo(const std::string& name);
     62 
     63   static const char* kTOffset;
     64   static const char* kAbsSendTime;
     65   static const char* kVideoRotation;
     66   static const char* kAudioLevel;
     67   static const char* kTransportSequenceNumber;
     68   std::string name;
     69   int id;
     70 };
     71 
     72 struct VideoStream {
     73   VideoStream();
     74   ~VideoStream();
     75   std::string ToString() const;
     76 
     77   size_t width;
     78   size_t height;
     79   int max_framerate;
     80 
     81   int min_bitrate_bps;
     82   int target_bitrate_bps;
     83   int max_bitrate_bps;
     84 
     85   int max_qp;
     86 
     87   // Bitrate thresholds for enabling additional temporal layers. Since these are
     88   // thresholds in between layers, we have one additional layer. One threshold
     89   // gives two temporal layers, one below the threshold and one above, two give
     90   // three, and so on.
     91   // The VideoEncoder may redistribute bitrates over the temporal layers so a
     92   // bitrate threshold of 100k and an estimate of 105k does not imply that we
     93   // get 100k in one temporal layer and 5k in the other, just that the bitrate
     94   // in the first temporal layer should not exceed 100k.
     95   // TODO(pbos): Apart from a special case for two-layer screencast these
     96   // thresholds are not propagated to the VideoEncoder. To be implemented.
     97   std::vector<int> temporal_layer_thresholds_bps;
     98 };
     99 
    100 struct VideoEncoderConfig {
    101   enum class ContentType {
    102     kRealtimeVideo,
    103     kScreen,
    104   };
    105 
    106   VideoEncoderConfig();
    107   ~VideoEncoderConfig();
    108   std::string ToString() const;
    109 
    110   std::vector<VideoStream> streams;
    111   std::vector<SpatialLayer> spatial_layers;
    112   ContentType content_type;
    113   void* encoder_specific_settings;
    114 
    115   // Padding will be used up to this bitrate regardless of the bitrate produced
    116   // by the encoder. Padding above what's actually produced by the encoder helps
    117   // maintaining a higher bitrate estimate. Padding will however not be sent
    118   // unless the estimated bandwidth indicates that the link can handle it.
    119   int min_transmit_bitrate_bps;
    120 };
    121 
    122 // Controls the capacity of the packet buffer in NetEq. The capacity is the
    123 // maximum number of packets that the buffer can contain. If the limit is
    124 // exceeded, the buffer will be flushed. The capacity does not affect the actual
    125 // audio delay in the general case, since this is governed by the target buffer
    126 // level (calculated from the jitter profile). It is only in the rare case of
    127 // severe network freezes that a higher capacity will lead to a (transient)
    128 // increase in audio delay.
    129 struct NetEqCapacityConfig {
    130   NetEqCapacityConfig() : enabled(false), capacity(0) {}
    131   explicit NetEqCapacityConfig(int value) : enabled(true), capacity(value) {}
    132   static const ConfigOptionID identifier = ConfigOptionID::kNetEqCapacityConfig;
    133   bool enabled;
    134   int capacity;
    135 };
    136 
    137 struct NetEqFastAccelerate {
    138   NetEqFastAccelerate() : enabled(false) {}
    139   explicit NetEqFastAccelerate(bool value) : enabled(value) {}
    140   static const ConfigOptionID identifier = ConfigOptionID::kNetEqFastAccelerate;
    141   bool enabled;
    142 };
    143 
    144 struct VoicePacing {
    145   VoicePacing() : enabled(false) {}
    146   explicit VoicePacing(bool value) : enabled(value) {}
    147   static const ConfigOptionID identifier = ConfigOptionID::kVoicePacing;
    148   bool enabled;
    149 };
    150 
    151 }  // namespace webrtc
    152 
    153 #endif  // WEBRTC_CONFIG_H_
    154