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 { NackConfigNackConfig27 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 { FecConfigFecConfig38 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 { RtpExtensionRtpExtension55 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 { NetEqCapacityConfigNetEqCapacityConfig130 NetEqCapacityConfig() : enabled(false), capacity(0) {} NetEqCapacityConfigNetEqCapacityConfig131 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 { NetEqFastAccelerateNetEqFastAccelerate138 NetEqFastAccelerate() : enabled(false) {} NetEqFastAccelerateNetEqFastAccelerate139 explicit NetEqFastAccelerate(bool value) : enabled(value) {} 140 static const ConfigOptionID identifier = ConfigOptionID::kNetEqFastAccelerate; 141 bool enabled; 142 }; 143 144 struct VoicePacing { VoicePacingVoicePacing145 VoicePacing() : enabled(false) {} VoicePacingVoicePacing146 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