src/third_party/webrtc/video_send_stream.h

   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           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 {
  52     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 {
  62       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 {
  75       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 {
 102         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:
 161   virtual ~VideoSendStream() {}
 162 };
 163
 164 }  // namespace webrtc
 165
 166 #endif  // WEBRTC_VIDEO_SEND_STREAM_H_