src/third_party/webrtc/video_receive_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_RECEIVE_STREAM_H_
  12 #define WEBRTC_VIDEO_RECEIVE_STREAM_H_
  13
  14 #include <map>
  15 #include <string>
  16 #include <vector>
  17
  18 #include "webrtc/common_types.h"
  19 #include "webrtc/config.h"
  20 #include "webrtc/frame_callback.h"
  21 #include "webrtc/transport.h"
  22 #include "webrtc/video_renderer.h"
  23
  24 namespace webrtc {
  25
  26 namespace newapi {
  27 // RTCP mode to use. Compound mode is described by RFC 4585 and reduced-size
  28 // RTCP mode is described by RFC 5506.
  29 enum RtcpMode { kRtcpCompound, kRtcpReducedSize };
  30 }  // namespace newapi
  31
  32 class VideoDecoder;
  33
  34 class VideoReceiveStream {
  35  public:
  36   // TODO(mflodman) Move all these settings to VideoDecoder and move the
  37   // declaration to common_types.h.
  38   struct Decoder {
  39     Decoder()
  40         : decoder(NULL),
  41           payload_type(0),
  42           renderer(false),
  43           expected_delay_ms(0) {}
  44
  45     // The actual decoder instance.
  46     VideoDecoder* decoder;
  47
  48     // Received RTP packets with this payload type will be sent to this decoder
  49     // instance.
  50     int payload_type;
  51
  52     // Name of the decoded payload (such as VP8). Maps back to the depacketizer
  53     // used to unpack incoming packets.
  54     std::string payload_name;
  55
  56     // 'true' if the decoder handles rendering as well.
  57     bool renderer;
  58
  59     // The expected delay for decoding and rendering, i.e. the frame will be
  60     // delivered this many milliseconds, if possible, earlier than the ideal
  61     // render time.
  62     // Note: Ignored if 'renderer' is false.
  63     int expected_delay_ms;
  64   };
  65
  66   struct Stats : public SsrcStats {
  67     Stats()
  68         : network_frame_rate(0),
  69           decode_frame_rate(0),
  70           render_frame_rate(0),
  71           avg_delay_ms(0),
  72           discarded_packets(0),
  73           ssrc(0) {}
  74
  75     int network_frame_rate;
  76     int decode_frame_rate;
  77     int render_frame_rate;
  78     int avg_delay_ms;
  79     int discarded_packets;
  80     uint32_t ssrc;
  81     std::string c_name;
  82   };
  83
  84   struct Config {
  85     Config()
  86         : renderer(NULL),
  87           render_delay_ms(0),
  88           audio_channel_id(-1),
  89           pre_decode_callback(NULL),
  90           pre_render_callback(NULL),
  91           target_delay_ms(0) {}
  92
  93     // Decoders for every payload that we can receive.
  94     std::vector<Decoder> decoders;
  95
  96     // Receive-stream specific RTP settings.
  97     struct Rtp {
  98       Rtp()
  99           : remote_ssrc(0),
 100             local_ssrc(0),
 101             rtcp_mode(newapi::kRtcpReducedSize),
 102             remb(true) {}
 103
 104       // Synchronization source (stream identifier) to be received.
 105       uint32_t remote_ssrc;
 106       // Sender SSRC used for sending RTCP (such as receiver reports).
 107       uint32_t local_ssrc;
 108
 109       // See RtcpMode for description.
 110       newapi::RtcpMode rtcp_mode;
 111
 112       // Extended RTCP settings.
 113       struct RtcpXr {
 114         RtcpXr() : receiver_reference_time_report(false) {}
 115
 116         // True if RTCP Receiver Reference Time Report Block extension
 117         // (RFC 3611) should be enabled.
 118         bool receiver_reference_time_report;
 119       } rtcp_xr;
 120
 121       // See draft-alvestrand-rmcat-remb for information.
 122       bool remb;
 123
 124       // See NackConfig for description.
 125       NackConfig nack;
 126
 127       // See FecConfig for description.
 128       FecConfig fec;
 129
 130       // RTX settings for incoming video payloads that may be received. RTX is
 131       // disabled if there's no config present.
 132       struct Rtx {
 133         Rtx() : ssrc(0), payload_type(0) {}
 134
 135         // SSRCs to use for the RTX streams.
 136         uint32_t ssrc;
 137
 138         // Payload type to use for the RTX stream.
 139         int payload_type;
 140       };
 141
 142       // Map from video RTP payload type -> RTX config.
 143       typedef std::map<int, Rtx> RtxMap;
 144       RtxMap rtx;
 145
 146       // RTP header extensions used for the received stream.
 147       std::vector<RtpExtension> extensions;
 148     } rtp;
 149
 150     // VideoRenderer will be called for each decoded frame. 'NULL' disables
 151     // rendering of this stream.
 152     VideoRenderer* renderer;
 153
 154     // Expected delay needed by the renderer, i.e. the frame will be delivered
 155     // this many milliseconds, if possible, earlier than the ideal render time.
 156     // Only valid if 'renderer' is set.
 157     int render_delay_ms;
 158
 159     // Audio channel corresponding to this video stream, used for audio/video
 160     // synchronization. 'audio_channel_id' is ignored if no VoiceEngine is set
 161     // when creating the VideoEngine instance. '-1' disables a/v sync.
 162     int audio_channel_id;
 163
 164     // Called for each incoming video frame, i.e. in encoded state. E.g. used
 165     // when
 166     // saving the stream to a file. 'NULL' disables the callback.
 167     EncodedFrameObserver* pre_decode_callback;
 168
 169     // Called for each decoded frame. E.g. used when adding effects to the
 170     // decoded
 171     // stream. 'NULL' disables the callback.
 172     I420FrameCallback* pre_render_callback;
 173
 174     // Target delay in milliseconds. A positive value indicates this stream is
 175     // used for streaming instead of a real-time call.
 176     int target_delay_ms;
 177   };
 178
 179   virtual void Start() = 0;
 180   virtual void Stop() = 0;
 181
 182   // TODO(pbos): Add info on currently-received codec to Stats.
 183   virtual Stats GetStats() const = 0;
 184
 185  protected:
 186   virtual ~VideoReceiveStream() {}
 187 };
 188
 189 }  // namespace webrtc
 190
 191 #endif  // WEBRTC_VIDEO_RECEIVE_STREAM_H_