blob: b5d69c68d3de80fd655e8be4092c46c52a44421c [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
2 * libjingle
3 * Copyright 2014 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifndef TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_
29#define TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_
30
31#include <map>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032#include <string>
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000033#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000034
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000035#include "talk/media/base/mediaengine.h"
36#include "talk/media/webrtc/webrtcvideochannelfactory.h"
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +000037#include "talk/media/webrtc/webrtcvideodecoderfactory.h"
38#include "talk/media/webrtc/webrtcvideoencoderfactory.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000039#include "webrtc/base/cpumonitor.h"
pbos@webrtc.org575d1262014-10-08 14:48:08 +000040#include "webrtc/base/criticalsection.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000041#include "webrtc/base/scoped_ptr.h"
pbos@webrtc.org38344ed2014-09-24 06:05:00 +000042#include "webrtc/base/thread_annotations.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000043#include "webrtc/call.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000044#include "webrtc/common_video/interface/i420_video_frame.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000045#include "webrtc/transport.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000046#include "webrtc/video_receive_stream.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000047#include "webrtc/video_renderer.h"
48#include "webrtc/video_send_stream.h"
49
50namespace webrtc {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000051class VideoDecoder;
52class VideoEncoder;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000053}
54
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000055namespace rtc {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000056class CpuMonitor;
57class Thread;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000058} // namespace rtc
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000059
60namespace cricket {
61
62class VideoCapturer;
63class VideoFrame;
64class VideoProcessor;
65class VideoRenderer;
66class VoiceMediaChannel;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000067class WebRtcDecoderObserver;
68class WebRtcEncoderObserver;
69class WebRtcLocalStreamInfo;
70class WebRtcRenderAdapter;
71class WebRtcVideoChannelRecvInfo;
72class WebRtcVideoChannelSendInfo;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000073class WebRtcVoiceEngine;
74
75struct CapturedFrame;
76struct Device;
77
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +000078class UnsignalledSsrcHandler {
79 public:
80 enum Action {
81 kDropPacket,
82 kDeliverPacket,
83 };
84 virtual Action OnUnsignalledSsrc(VideoMediaChannel* engine,
85 uint32_t ssrc) = 0;
86};
87
88// TODO(pbos): Remove, use external handlers only.
89class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
90 public:
91 DefaultUnsignalledSsrcHandler();
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000092 Action OnUnsignalledSsrc(VideoMediaChannel* engine, uint32_t ssrc) override;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +000093
94 VideoRenderer* GetDefaultRenderer() const;
95 void SetDefaultRenderer(VideoMediaChannel* channel, VideoRenderer* renderer);
96
97 private:
98 uint32_t default_recv_ssrc_;
99 VideoRenderer* default_renderer_;
100};
101
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000102// CallFactory, overridden for testing to verify that webrtc::Call is configured
103// properly.
104class WebRtcCallFactory {
105 public:
106 virtual ~WebRtcCallFactory();
107 virtual webrtc::Call* CreateCall(const webrtc::Call::Config& config);
108};
109
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000110// WebRtcVideoEngine2 is used for the new native WebRTC Video API (webrtc:1667).
buildbot@webrtc.org3c16d8b2014-10-13 06:35:10 +0000111class WebRtcVideoEngine2 : public sigslot::has_slots<> {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000112 public:
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000113 explicit WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine);
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000114 virtual ~WebRtcVideoEngine2();
115
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000116 // Used for testing to be able to check and use the webrtc::Call config.
117 void SetCallFactory(WebRtcCallFactory* call_factory);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000118
119 // Basic video engine implementation.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000120 bool Init(rtc::Thread* worker_thread);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000121 void Terminate();
122
123 int GetCapabilities();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000124 bool SetDefaultEncoderConfig(const VideoEncoderConfig& config);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000125
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000126 WebRtcVideoChannel2* CreateChannel(const VideoOptions& options,
127 VoiceMediaChannel* voice_channel);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000128
129 const std::vector<VideoCodec>& codecs() const;
130 const std::vector<RtpHeaderExtension>& rtp_header_extensions() const;
131 void SetLogging(int min_sev, const char* filter);
132
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000133 // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does
134 // not take the ownership of |decoder_factory|. The caller needs to make sure
135 // that |decoder_factory| outlives the video engine.
136 void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory);
137 // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does
138 // not take the ownership of |encoder_factory|. The caller needs to make sure
139 // that |encoder_factory| outlives the video engine.
140 virtual void SetExternalEncoderFactory(
141 WebRtcVideoEncoderFactory* encoder_factory);
142
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000143 bool EnableTimedRender();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000144 // This is currently ignored.
145 sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
146
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000147 bool FindCodec(const VideoCodec& in);
148 bool CanSendCodec(const VideoCodec& in,
149 const VideoCodec& current,
150 VideoCodec* out);
151 // Check whether the supplied trace should be ignored.
152 bool ShouldIgnoreTrace(const std::string& trace);
153
buildbot@webrtc.org992febb2014-09-05 16:39:08 +0000154 VideoFormat GetStartCaptureFormat() const { return default_codec_format_; }
155
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000156 private:
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000157 std::vector<VideoCodec> GetSupportedCodecs() const;
158
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000159 rtc::Thread* worker_thread_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000160 WebRtcVoiceEngine* voice_engine_;
161 std::vector<VideoCodec> video_codecs_;
162 std::vector<RtpHeaderExtension> rtp_header_extensions_;
buildbot@webrtc.org992febb2014-09-05 16:39:08 +0000163 VideoFormat default_codec_format_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000164
165 bool initialized_;
166
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000167 WebRtcCallFactory default_call_factory_;
168 WebRtcCallFactory* call_factory_;
169
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000170 WebRtcVideoDecoderFactory* external_decoder_factory_;
171 WebRtcVideoEncoderFactory* external_encoder_factory_;
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000172 rtc::scoped_ptr<WebRtcVideoEncoderFactory> simulcast_encoder_factory_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000173};
174
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000175class WebRtcVideoChannel2 : public rtc::MessageHandler,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000176 public VideoMediaChannel,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000177 public webrtc::newapi::Transport,
178 public webrtc::LoadObserver {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000179 public:
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000180 WebRtcVideoChannel2(WebRtcCallFactory* call_factory,
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000181 WebRtcVoiceEngine* voice_engine,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000182 VoiceMediaChannel* voice_channel,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000183 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000184 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000185 WebRtcVideoDecoderFactory* external_decoder_factory);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000186 ~WebRtcVideoChannel2();
187 bool Init();
188
189 // VideoMediaChannel implementation
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000190 bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) override;
191 bool SetSendCodecs(const std::vector<VideoCodec>& codecs) override;
192 bool GetSendCodec(VideoCodec* send_codec) override;
193 bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) override;
194 bool SetRender(bool render) override;
195 bool SetSend(bool send) override;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000196
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000197 bool AddSendStream(const StreamParams& sp) override;
198 bool RemoveSendStream(uint32 ssrc) override;
199 bool AddRecvStream(const StreamParams& sp) override;
200 bool RemoveRecvStream(uint32 ssrc) override;
201 bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) override;
202 bool GetStats(VideoMediaInfo* info) override;
203 bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) override;
204 bool SendIntraFrame() override;
205 bool RequestIntraFrame() override;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000206
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000207 void OnPacketReceived(rtc::Buffer* packet,
208 const rtc::PacketTime& packet_time) override;
209 void OnRtcpReceived(rtc::Buffer* packet,
210 const rtc::PacketTime& packet_time) override;
211 void OnReadyToSend(bool ready) override;
212 bool MuteStream(uint32 ssrc, bool mute) override;
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000213
214 // Set send/receive RTP header extensions. This must be done before creating
215 // streams as it only has effect on future streams.
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000216 bool SetRecvRtpHeaderExtensions(
pbos@webrtc.org0d852d52015-02-09 15:14:36 +0000217 const std::vector<RtpHeaderExtension>& extensions) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000218 bool SetSendRtpHeaderExtensions(
pbos@webrtc.org0d852d52015-02-09 15:14:36 +0000219 const std::vector<RtpHeaderExtension>& extensions) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000220 bool SetMaxSendBandwidth(int bps) override;
221 bool SetOptions(const VideoOptions& options) override;
222 bool GetOptions(VideoOptions* options) const override {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000223 *options = options_;
224 return true;
225 }
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000226 void SetInterface(NetworkInterface* iface) override;
227 void UpdateAspectRatio(int ratio_w, int ratio_h) override;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000228
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000229 void OnMessage(rtc::Message* msg) override;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000230
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000231 void OnLoadUpdate(Load load) override;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000232
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000233 // Implemented for VideoMediaChannelTest.
234 bool sending() const { return sending_; }
buildbot@webrtc.org2c0fb052014-08-13 16:47:12 +0000235 uint32 GetDefaultSendChannelSsrc() { return default_send_ssrc_; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000236 bool GetRenderer(uint32 ssrc, VideoRenderer** renderer);
237
238 private:
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000239 void ConfigureReceiverRtp(webrtc::VideoReceiveStream::Config* config,
240 const StreamParams& sp) const;
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000241 bool CodecIsExternallySupported(const std::string& name) const;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000242
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000243 struct VideoCodecSettings {
244 VideoCodecSettings();
andrew@webrtc.org8f27fcc2015-01-09 20:22:46 +0000245
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000246 bool operator ==(const VideoCodecSettings& other) const;
247
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000248 VideoCodec codec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000249 webrtc::FecConfig fec;
250 int rtx_payload_type;
251 };
252
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000253 // Wrapper for the sender part, this is where the capturer is connected and
254 // frames are then converted from cricket frames to webrtc frames.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000255 class WebRtcVideoSendStream : public sigslot::has_slots<> {
256 public:
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000257 WebRtcVideoSendStream(
258 webrtc::Call* call,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000259 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000260 const VideoOptions& options,
261 const Settable<VideoCodecSettings>& codec_settings,
262 const StreamParams& sp,
263 const std::vector<webrtc::RtpExtension>& rtp_extensions);
264
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000265 ~WebRtcVideoSendStream();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000266 void SetOptions(const VideoOptions& options);
267 void SetCodec(const VideoCodecSettings& codec);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000268 void SetRtpExtensions(
269 const std::vector<webrtc::RtpExtension>& rtp_extensions);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000270
271 void InputFrame(VideoCapturer* capturer, const VideoFrame* frame);
272 bool SetCapturer(VideoCapturer* capturer);
273 bool SetVideoFormat(const VideoFormat& format);
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +0000274 void MuteStream(bool mute);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000275 bool DisconnectCapturer();
276
277 void Start();
278 void Stop();
279
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000280 VideoSenderInfo GetVideoSenderInfo();
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000281 void FillBandwidthEstimationInfo(BandwidthEstimationInfo* bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000282
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000283 void OnCpuResolutionRequest(
284 CoordinatedVideoAdapter::AdaptRequest adapt_request);
285
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000286 private:
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000287 // Parameters needed to reconstruct the underlying stream.
288 // webrtc::VideoSendStream doesn't support setting a lot of options on the
289 // fly, so when those need to be changed we tear down and reconstruct with
290 // similar parameters depending on which options changed etc.
291 struct VideoSendStreamParameters {
292 VideoSendStreamParameters(
293 const webrtc::VideoSendStream::Config& config,
294 const VideoOptions& options,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000295 const Settable<VideoCodecSettings>& codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000296 webrtc::VideoSendStream::Config config;
297 VideoOptions options;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000298 Settable<VideoCodecSettings> codec_settings;
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000299 // Sent resolutions + bitrates etc. by the underlying VideoSendStream,
300 // typically changes when setting a new resolution or reconfiguring
301 // bitrates.
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000302 webrtc::VideoEncoderConfig encoder_config;
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000303 };
304
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000305 struct AllocatedEncoder {
306 AllocatedEncoder(webrtc::VideoEncoder* encoder,
307 webrtc::VideoCodecType type,
308 bool external)
309 : encoder(encoder), type(type), external(external) {}
310 webrtc::VideoEncoder* encoder;
311 webrtc::VideoCodecType type;
312 bool external;
313 };
314
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000315 struct Dimensions {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +0000316 // Initial encoder configuration (QCIF, 176x144) frame (to ensure that
317 // hardware encoders can be initialized). This gives us low memory usage
318 // but also makes it so configuration errors are discovered at the time we
319 // apply the settings rather than when we get the first frame (waiting for
320 // the first frame to know that you gave a bad codec parameter could make
321 // debugging hard).
322 // TODO(pbos): Consider setting up encoders lazily.
323 Dimensions() : width(176), height(144), is_screencast(false) {}
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000324 int width;
325 int height;
326 bool is_screencast;
327 };
328
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000329 union VideoEncoderSettings {
330 webrtc::VideoCodecVP8 vp8;
331 webrtc::VideoCodecVP9 vp9;
332 };
333
334 static std::vector<webrtc::VideoStream> CreateVideoStreams(
335 const VideoCodec& codec,
336 const VideoOptions& options,
337 size_t num_streams);
338 static std::vector<webrtc::VideoStream> CreateSimulcastVideoStreams(
339 const VideoCodec& codec,
340 const VideoOptions& options,
341 size_t num_streams);
342
343 void* ConfigureVideoEncoderSettings(const VideoCodec& codec,
344 const VideoOptions& options)
345 EXCLUSIVE_LOCKS_REQUIRED(lock_);
346
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000347 AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec)
348 EXCLUSIVE_LOCKS_REQUIRED(lock_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000349 void DestroyVideoEncoder(AllocatedEncoder* encoder)
350 EXCLUSIVE_LOCKS_REQUIRED(lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000351 void SetCodecAndOptions(const VideoCodecSettings& codec,
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +0000352 const VideoOptions& options)
353 EXCLUSIVE_LOCKS_REQUIRED(lock_);
354 void RecreateWebRtcStream() EXCLUSIVE_LOCKS_REQUIRED(lock_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000355 webrtc::VideoEncoderConfig CreateVideoEncoderConfig(
356 const Dimensions& dimensions,
357 const VideoCodec& codec) const EXCLUSIVE_LOCKS_REQUIRED(lock_);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000358 void SetDimensions(int width, int height, bool is_screencast)
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +0000359 EXCLUSIVE_LOCKS_REQUIRED(lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000360
361 webrtc::Call* const call_;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000362 WebRtcVideoEncoderFactory* const external_encoder_factory_
363 GUARDED_BY(lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000364
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000365 rtc::CriticalSection lock_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000366 webrtc::VideoSendStream* stream_ GUARDED_BY(lock_);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000367 VideoSendStreamParameters parameters_ GUARDED_BY(lock_);
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000368 VideoEncoderSettings encoder_settings_ GUARDED_BY(lock_);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000369 AllocatedEncoder allocated_encoder_ GUARDED_BY(lock_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000370 Dimensions last_dimensions_ GUARDED_BY(lock_);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000371
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000372 VideoCapturer* capturer_ GUARDED_BY(lock_);
373 bool sending_ GUARDED_BY(lock_);
374 bool muted_ GUARDED_BY(lock_);
375 VideoFormat format_ GUARDED_BY(lock_);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +0000376 int old_adapt_changes_ GUARDED_BY(lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000377
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000378 rtc::CriticalSection frame_lock_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000379 webrtc::I420VideoFrame video_frame_ GUARDED_BY(frame_lock_);
380 };
381
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000382 // Wrapper for the receiver part, contains configs etc. that are needed to
383 // reconstruct the underlying VideoReceiveStream. Also serves as a wrapper
384 // between webrtc::VideoRenderer and cricket::VideoRenderer.
385 class WebRtcVideoReceiveStream : public webrtc::VideoRenderer {
386 public:
387 WebRtcVideoReceiveStream(
388 webrtc::Call*,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000389 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000390 const webrtc::VideoReceiveStream::Config& config,
391 const std::vector<VideoCodecSettings>& recv_codecs);
392 ~WebRtcVideoReceiveStream();
393
394 void SetRecvCodecs(const std::vector<VideoCodecSettings>& recv_codecs);
395 void SetRtpExtensions(const std::vector<webrtc::RtpExtension>& extensions);
396
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000397 void RenderFrame(const webrtc::I420VideoFrame& frame,
398 int time_to_render_ms) override;
399 bool IsTextureSupported() const override;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000400
401 void SetRenderer(cricket::VideoRenderer* renderer);
402 cricket::VideoRenderer* GetRenderer();
403
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000404 VideoReceiverInfo GetVideoReceiverInfo();
405
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000406 private:
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000407 struct AllocatedDecoder {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000408 AllocatedDecoder(webrtc::VideoDecoder* decoder,
409 webrtc::VideoCodecType type,
410 bool external)
411 : decoder(decoder), type(type), external(external) {}
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000412 webrtc::VideoDecoder* decoder;
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000413 webrtc::VideoCodecType type;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000414 bool external;
415 };
416
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000417 void SetSize(int width, int height);
418 void RecreateWebRtcStream();
419
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000420 AllocatedDecoder CreateOrReuseVideoDecoder(
421 std::vector<AllocatedDecoder>* old_decoder,
422 const VideoCodec& codec);
423 void ClearDecoders(std::vector<AllocatedDecoder>* allocated_decoders);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000424
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000425 webrtc::Call* const call_;
426
427 webrtc::VideoReceiveStream* stream_;
428 webrtc::VideoReceiveStream::Config config_;
429
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000430 WebRtcVideoDecoderFactory* const external_decoder_factory_;
431 std::vector<AllocatedDecoder> allocated_decoders_;
432
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000433 rtc::CriticalSection renderer_lock_;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000434 cricket::VideoRenderer* renderer_ GUARDED_BY(renderer_lock_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000435 int last_width_ GUARDED_BY(renderer_lock_);
436 int last_height_ GUARDED_BY(renderer_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +0000437 // Expands remote RTP timestamps to int64_t to be able to estimate how long
438 // the stream has been running.
439 rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
440 GUARDED_BY(renderer_lock_);
441 int64_t first_frame_timestamp_ GUARDED_BY(renderer_lock_);
442 // Start NTP time is estimated as current remote NTP time (estimated from
443 // RTCP) minus the elapsed time, as soon as remote NTP time is available.
444 int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000445 };
446
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000447 void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000448 void SetDefaultOptions();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000449
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000450 bool SendRtp(const uint8_t* data, size_t len) override;
451 bool SendRtcp(const uint8_t* data, size_t len) override;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000452
453 void StartAllSendStreams();
454 void StopAllSendStreams();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000455
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000456 static std::vector<VideoCodecSettings> MapCodecs(
457 const std::vector<VideoCodec>& codecs);
458 std::vector<VideoCodecSettings> FilterSupportedCodecs(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000459 const std::vector<VideoCodecSettings>& mapped_codecs) const;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000460
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000461 void FillSenderStats(VideoMediaInfo* info);
462 void FillReceiverStats(VideoMediaInfo* info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000463 void FillBandwidthEstimationStats(const webrtc::Call::Stats& stats,
464 VideoMediaInfo* info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +0000465
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000466 uint32_t rtcp_receiver_report_ssrc_;
467 bool sending_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000468 rtc::scoped_ptr<webrtc::Call> call_;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000469 WebRtcCallFactory* call_factory_;
470
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000471 uint32_t default_send_ssrc_;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000472
473 DefaultUnsignalledSsrcHandler default_unsignalled_ssrc_handler_;
474 UnsignalledSsrcHandler* const unsignalled_ssrc_handler_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000475
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000476 rtc::CriticalSection stream_crit_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000477 // Using primary-ssrc (first ssrc) as key.
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000478 std::map<uint32, WebRtcVideoSendStream*> send_streams_
479 GUARDED_BY(stream_crit_);
480 std::map<uint32, WebRtcVideoReceiveStream*> receive_streams_
481 GUARDED_BY(stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000482
483 Settable<VideoCodecSettings> send_codec_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000484 std::vector<webrtc::RtpExtension> send_rtp_extensions_;
485
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000486 VoiceMediaChannel* const voice_channel_;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000487 WebRtcVideoEncoderFactory* const external_encoder_factory_;
488 WebRtcVideoDecoderFactory* const external_decoder_factory_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000489 std::vector<VideoCodecSettings> recv_codecs_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000490 std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
pbos@webrtc.org00873182014-11-25 14:03:34 +0000491 webrtc::Call::Config::BitrateConfig bitrate_config_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000492 VideoOptions options_;
493};
494
495} // namespace cricket
496
497#endif // TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_