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