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
23namespace webrtc {
24
25// Settings for NACK, see RFC 4585 for details.
26struct 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.
37struct 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.
54struct 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
72struct 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
100struct 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.
129struct 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
137struct NetEqFastAccelerate {
138  NetEqFastAccelerate() : enabled(false) {}
139  explicit NetEqFastAccelerate(bool value) : enabled(value) {}
140  static const ConfigOptionID identifier = ConfigOptionID::kNetEqFastAccelerate;
141  bool enabled;
142};
143
144struct 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