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