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#ifndef WEBRTC_VIDEO_SEND_STREAM_H_
12#define WEBRTC_VIDEO_SEND_STREAM_H_
13
14#include <map>
15#include <string>
16
17#include "webrtc/common_types.h"
18#include "webrtc/config.h"
19#include "webrtc/frame_callback.h"
20#include "webrtc/stream.h"
21#include "webrtc/transport.h"
22#include "webrtc/video_renderer.h"
23
24namespace webrtc {
25
26class LoadObserver;
27class VideoEncoder;
28
29class EncodingTimeObserver {
30 public:
31  virtual ~EncodingTimeObserver() {}
32
33  virtual void OnReportEncodedTime(int64_t ntp_time_ms, int encode_time_ms) = 0;
34};
35
36// Class to deliver captured frame to the video send stream.
37class VideoCaptureInput {
38 public:
39  // These methods do not lock internally and must be called sequentially.
40  // If your application switches input sources synchronization must be done
41  // externally to make sure that any old frames are not delivered concurrently.
42  virtual void IncomingCapturedFrame(const VideoFrame& video_frame) = 0;
43
44 protected:
45  virtual ~VideoCaptureInput() {}
46};
47
48class VideoSendStream : public SendStream {
49 public:
50  struct StreamStats {
51    FrameCounts frame_counts;
52    int width = 0;
53    int height = 0;
54    // TODO(holmer): Move bitrate_bps out to the webrtc::Call layer.
55    int total_bitrate_bps = 0;
56    int retransmit_bitrate_bps = 0;
57    int avg_delay_ms = 0;
58    int max_delay_ms = 0;
59    StreamDataCounters rtp_stats;
60    RtcpPacketTypeCounter rtcp_packet_type_counts;
61    RtcpStatistics rtcp_stats;
62  };
63
64  struct Stats {
65    std::string encoder_implementation_name = "unknown";
66    int input_frame_rate = 0;
67    int encode_frame_rate = 0;
68    int avg_encode_time_ms = 0;
69    int encode_usage_percent = 0;
70    int target_media_bitrate_bps = 0;
71    int media_bitrate_bps = 0;
72    bool suspended = false;
73    bool bw_limited_resolution = false;
74    std::map<uint32_t, StreamStats> substreams;
75  };
76
77  struct Config {
78    Config() = delete;
79    explicit Config(Transport* send_transport)
80        : send_transport(send_transport) {}
81
82    std::string ToString() const;
83
84    struct EncoderSettings {
85      std::string ToString() const;
86
87      std::string payload_name;
88      int payload_type = -1;
89
90      // TODO(sophiechang): Delete this field when no one is using internal
91      // sources anymore.
92      bool internal_source = false;
93
94      // Uninitialized VideoEncoder instance to be used for encoding. Will be
95      // initialized from inside the VideoSendStream.
96      VideoEncoder* encoder = nullptr;
97    } encoder_settings;
98
99    static const size_t kDefaultMaxPacketSize = 1500 - 40;  // TCP over IPv4.
100    struct Rtp {
101      std::string ToString() const;
102
103      std::vector<uint32_t> ssrcs;
104
105      // See RtcpMode for description.
106      RtcpMode rtcp_mode = RtcpMode::kCompound;
107
108      // Max RTP packet size delivered to send transport from VideoEngine.
109      size_t max_packet_size = kDefaultMaxPacketSize;
110
111      // RTP header extensions to use for this send stream.
112      std::vector<RtpExtension> extensions;
113
114      // See NackConfig for description.
115      NackConfig nack;
116
117      // See FecConfig for description.
118      FecConfig fec;
119
120      // Settings for RTP retransmission payload format, see RFC 4588 for
121      // details.
122      struct Rtx {
123        std::string ToString() const;
124        // SSRCs to use for the RTX streams.
125        std::vector<uint32_t> ssrcs;
126
127        // Payload type to use for the RTX stream.
128        int payload_type = -1;
129      } rtx;
130
131      // RTCP CNAME, see RFC 3550.
132      std::string c_name;
133    } rtp;
134
135    // Transport for outgoing packets.
136    Transport* send_transport = nullptr;
137
138    // Callback for overuse and normal usage based on the jitter of incoming
139    // captured frames. 'nullptr' disables the callback.
140    LoadObserver* overuse_callback = nullptr;
141
142    // Called for each I420 frame before encoding the frame. Can be used for
143    // effects, snapshots etc. 'nullptr' disables the callback.
144    I420FrameCallback* pre_encode_callback = nullptr;
145
146    // Called for each encoded frame, e.g. used for file storage. 'nullptr'
147    // disables the callback.
148    EncodedFrameObserver* post_encode_callback = nullptr;
149
150    // Renderer for local preview. The local renderer will be called even if
151    // sending hasn't started. 'nullptr' disables local rendering.
152    VideoRenderer* local_renderer = nullptr;
153
154    // Expected delay needed by the renderer, i.e. the frame will be delivered
155    // this many milliseconds, if possible, earlier than expected render time.
156    // Only valid if |local_renderer| is set.
157    int render_delay_ms = 0;
158
159    // Target delay in milliseconds. A positive value indicates this stream is
160    // used for streaming instead of a real-time call.
161    int target_delay_ms = 0;
162
163    // True if the stream should be suspended when the available bitrate fall
164    // below the minimum configured bitrate. If this variable is false, the
165    // stream may send at a rate higher than the estimated available bitrate.
166    bool suspend_below_min_bitrate = false;
167
168    // Called for each encoded frame. Passes the total time spent on encoding.
169    // TODO(ivica): Consolidate with post_encode_callback:
170    // https://code.google.com/p/webrtc/issues/detail?id=5042
171    EncodingTimeObserver* encoding_time_observer = nullptr;
172  };
173
174  // Gets interface used to insert captured frames. Valid as long as the
175  // VideoSendStream is valid.
176  virtual VideoCaptureInput* Input() = 0;
177
178  // Set which streams to send. Must have at least as many SSRCs as configured
179  // in the config. Encoder settings are passed on to the encoder instance along
180  // with the VideoStream settings.
181  virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
182
183  virtual Stats GetStats() = 0;
184};
185
186}  // namespace webrtc
187
188#endif  // WEBRTC_VIDEO_SEND_STREAM_H_
189