1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_VIDEO_SEND_STREAM_H_
#define WEBRTC_VIDEO_SEND_STREAM_H_
#include <map>
#include <string>
#include "webrtc/common_types.h"
#include "webrtc/config.h"
#include "webrtc/frame_callback.h"
#include "webrtc/video_renderer.h"
namespace webrtc {
class VideoEncoder;
// Class to deliver captured frame to the video send stream.
class VideoSendStreamInput {
public:
// These methods do not lock internally and must be called sequentially.
// If your application switches input sources synchronization must be done
// externally to make sure that any old frames are not delivered concurrently.
virtual void SwapFrame(I420VideoFrame* video_frame) = 0;
protected:
virtual ~VideoSendStreamInput() {}
};
class VideoSendStream {
public:
struct Stats {
Stats()
: input_frame_rate(0),
encode_frame_rate(0),
media_bitrate_bps(0),
suspended(false) {}
int input_frame_rate;
int encode_frame_rate;
int media_bitrate_bps;
bool suspended;
std::map<uint32_t, SsrcStats> substreams;
};
struct Config {
Config()
: pre_encode_callback(NULL),
post_encode_callback(NULL),
local_renderer(NULL),
render_delay_ms(0),
target_delay_ms(0),
suspend_below_min_bitrate(false) {}
std::string ToString() const;
struct EncoderSettings {
EncoderSettings() : payload_type(-1), encoder(NULL) {}
std::string ToString() const;
std::string payload_name;
int payload_type;
// Uninitialized VideoEncoder instance to be used for encoding. Will be
// initialized from inside the VideoSendStream.
webrtc::VideoEncoder* encoder;
} encoder_settings;
static const size_t kDefaultMaxPacketSize = 1500 - 40; // TCP over IPv4.
struct Rtp {
Rtp() : max_packet_size(kDefaultMaxPacketSize) {}
std::string ToString() const;
std::vector<uint32_t> ssrcs;
// Max RTP packet size delivered to send transport from VideoEngine.
size_t max_packet_size;
// RTP header extensions to use for this send stream.
std::vector<RtpExtension> extensions;
// See NackConfig for description.
NackConfig nack;
// See FecConfig for description.
FecConfig fec;
// Settings for RTP retransmission payload format, see RFC 4588 for
// details.
struct Rtx {
Rtx() : payload_type(-1), pad_with_redundant_payloads(false) {}
std::string ToString() const;
// SSRCs to use for the RTX streams.
std::vector<uint32_t> ssrcs;
// Payload type to use for the RTX stream.
int payload_type;
// Use redundant payloads to pad the bitrate. Instead of padding with
// randomized packets, we will preemptively retransmit media packets on
// the RTX stream.
bool pad_with_redundant_payloads;
} rtx;
// RTCP CNAME, see RFC 3550.
std::string c_name;
} rtp;
// Called for each I420 frame before encoding the frame. Can be used for
// effects, snapshots etc. 'NULL' disables the callback.
I420FrameCallback* pre_encode_callback;
// Called for each encoded frame, e.g. used for file storage. 'NULL'
// disables the callback.
EncodedFrameObserver* post_encode_callback;
// Renderer for local preview. The local renderer will be called even if
// sending hasn't started. 'NULL' disables local rendering.
VideoRenderer* local_renderer;
// Expected delay needed by the renderer, i.e. the frame will be delivered
// this many milliseconds, if possible, earlier than expected render time.
// Only valid if |local_renderer| is set.
int render_delay_ms;
// Target delay in milliseconds. A positive value indicates this stream is
// used for streaming instead of a real-time call.
int target_delay_ms;
// True if the stream should be suspended when the available bitrate fall
// below the minimum configured bitrate. If this variable is false, the
// stream may send at a rate higher than the estimated available bitrate.
bool suspend_below_min_bitrate;
};
// Gets interface used to insert captured frames. Valid as long as the
// VideoSendStream is valid.
virtual VideoSendStreamInput* Input() = 0;
virtual void Start() = 0;
virtual void Stop() = 0;
// Set which streams to send. Must have at least as many SSRCs as configured
// in the config. Encoder settings are passed on to the encoder instance along
// with the VideoStream settings.
virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
virtual Stats GetStats() const = 0;
protected:
virtual ~VideoSendStream() {}
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_SEND_STREAM_H_
|
