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