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