| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 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> | |
| 32 #include <string> | |
| 33 #include <vector> | |
| 34 | |
| 35 #include "talk/media/base/mediaengine.h" | |
| 36 #include "talk/media/webrtc/webrtcvideochannelfactory.h" | |
| 37 #include "talk/media/webrtc/webrtcvideodecoderfactory.h" | |
| 38 #include "talk/media/webrtc/webrtcvideoencoderfactory.h" | |
| 39 #include "webrtc/base/criticalsection.h" | |
| 40 #include "webrtc/base/scoped_ptr.h" | |
| 41 #include "webrtc/base/thread_annotations.h" | |
| 42 #include "webrtc/base/thread_checker.h" | |
| 43 #include "webrtc/media/base/videosinkinterface.h" | |
| 44 #include "webrtc/call.h" | |
| 45 #include "webrtc/transport.h" | |
| 46 #include "webrtc/video_frame.h" | |
| 47 #include "webrtc/video_receive_stream.h" | |
| 48 #include "webrtc/video_renderer.h" | |
| 49 #include "webrtc/video_send_stream.h" | |
| 50 | |
| 51 namespace webrtc { | |
| 52 class VideoDecoder; | |
| 53 class VideoEncoder; | |
| 54 } | |
| 55 | |
| 56 namespace rtc { | |
| 57 class Thread; | |
| 58 } // namespace rtc | |
| 59 | |
| 60 namespace cricket { | |
| 61 | |
| 62 class VideoCapturer; | |
| 63 class VideoFrame; | |
| 64 class VideoProcessor; | |
| 65 class VideoRenderer; | |
| 66 class VoiceMediaChannel; | |
| 67 class WebRtcDecoderObserver; | |
| 68 class WebRtcEncoderObserver; | |
| 69 class WebRtcLocalStreamInfo; | |
| 70 class WebRtcRenderAdapter; | |
| 71 class WebRtcVideoChannelRecvInfo; | |
| 72 class WebRtcVideoChannelSendInfo; | |
| 73 class WebRtcVoiceEngine; | |
| 74 class WebRtcVoiceMediaChannel; | |
| 75 | |
| 76 struct CapturedFrame; | |
| 77 struct Device; | |
| 78 | |
| 79 // Exposed here for unittests. | |
| 80 std::vector<VideoCodec> DefaultVideoCodecList(); | |
| 81 | |
| 82 class UnsignalledSsrcHandler { | |
| 83 public: | |
| 84 enum Action { | |
| 85 kDropPacket, | |
| 86 kDeliverPacket, | |
| 87 }; | |
| 88 virtual Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel, | |
| 89 uint32_t ssrc) = 0; | |
| 90 }; | |
| 91 | |
| 92 // TODO(pbos): Remove, use external handlers only. | |
| 93 class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler { | |
| 94 public: | |
| 95 DefaultUnsignalledSsrcHandler(); | |
| 96 Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel, | |
| 97 uint32_t ssrc) override; | |
| 98 | |
| 99 rtc::VideoSinkInterface<VideoFrame>* GetDefaultSink() const; | |
| 100 void SetDefaultSink(VideoMediaChannel* channel, | |
| 101 rtc::VideoSinkInterface<VideoFrame>* sink); | |
| 102 | |
| 103 private: | |
| 104 uint32_t default_recv_ssrc_; | |
| 105 rtc::VideoSinkInterface<VideoFrame>* default_sink_; | |
| 106 }; | |
| 107 | |
| 108 // WebRtcVideoEngine2 is used for the new native WebRTC Video API (webrtc:1667). | |
| 109 class WebRtcVideoEngine2 { | |
| 110 public: | |
| 111 WebRtcVideoEngine2(); | |
| 112 ~WebRtcVideoEngine2(); | |
| 113 | |
| 114 // Basic video engine implementation. | |
| 115 void Init(); | |
| 116 | |
| 117 WebRtcVideoChannel2* CreateChannel(webrtc::Call* call, | |
| 118 const VideoOptions& options); | |
| 119 | |
| 120 const std::vector<VideoCodec>& codecs() const; | |
| 121 RtpCapabilities GetCapabilities() const; | |
| 122 | |
| 123 // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does | |
| 124 // not take the ownership of |decoder_factory|. The caller needs to make sure | |
| 125 // that |decoder_factory| outlives the video engine. | |
| 126 void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory); | |
| 127 // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does | |
| 128 // not take the ownership of |encoder_factory|. The caller needs to make sure | |
| 129 // that |encoder_factory| outlives the video engine. | |
| 130 virtual void SetExternalEncoderFactory( | |
| 131 WebRtcVideoEncoderFactory* encoder_factory); | |
| 132 | |
| 133 private: | |
| 134 std::vector<VideoCodec> GetSupportedCodecs() const; | |
| 135 | |
| 136 std::vector<VideoCodec> video_codecs_; | |
| 137 | |
| 138 bool initialized_; | |
| 139 | |
| 140 WebRtcVideoDecoderFactory* external_decoder_factory_; | |
| 141 WebRtcVideoEncoderFactory* external_encoder_factory_; | |
| 142 rtc::scoped_ptr<WebRtcVideoEncoderFactory> simulcast_encoder_factory_; | |
| 143 }; | |
| 144 | |
| 145 class WebRtcVideoChannel2 : public VideoMediaChannel, | |
| 146 public webrtc::Transport, | |
| 147 public webrtc::LoadObserver { | |
| 148 public: | |
| 149 WebRtcVideoChannel2(webrtc::Call* call, | |
| 150 const VideoOptions& options, | |
| 151 const std::vector<VideoCodec>& recv_codecs, | |
| 152 WebRtcVideoEncoderFactory* external_encoder_factory, | |
| 153 WebRtcVideoDecoderFactory* external_decoder_factory); | |
| 154 ~WebRtcVideoChannel2() override; | |
| 155 | |
| 156 // VideoMediaChannel implementation | |
| 157 bool SetSendParameters(const VideoSendParameters& params) override; | |
| 158 bool SetRecvParameters(const VideoRecvParameters& params) override; | |
| 159 bool GetSendCodec(VideoCodec* send_codec) override; | |
| 160 bool SetSend(bool send) override; | |
| 161 bool SetVideoSend(uint32_t ssrc, | |
| 162 bool mute, | |
| 163 const VideoOptions* options) override; | |
| 164 bool AddSendStream(const StreamParams& sp) override; | |
| 165 bool RemoveSendStream(uint32_t ssrc) override; | |
| 166 bool AddRecvStream(const StreamParams& sp) override; | |
| 167 bool AddRecvStream(const StreamParams& sp, bool default_stream); | |
| 168 bool RemoveRecvStream(uint32_t ssrc) override; | |
| 169 bool SetSink(uint32_t ssrc, | |
| 170 rtc::VideoSinkInterface<VideoFrame>* sink) override; | |
| 171 bool GetStats(VideoMediaInfo* info) override; | |
| 172 bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) override; | |
| 173 | |
| 174 void OnPacketReceived(rtc::Buffer* packet, | |
| 175 const rtc::PacketTime& packet_time) override; | |
| 176 void OnRtcpReceived(rtc::Buffer* packet, | |
| 177 const rtc::PacketTime& packet_time) override; | |
| 178 void OnReadyToSend(bool ready) override; | |
| 179 void SetInterface(NetworkInterface* iface) override; | |
| 180 | |
| 181 void OnLoadUpdate(Load load) override; | |
| 182 | |
| 183 // Implemented for VideoMediaChannelTest. | |
| 184 bool sending() const { return sending_; } | |
| 185 uint32_t GetDefaultSendChannelSsrc() { return default_send_ssrc_; } | |
| 186 | |
| 187 private: | |
| 188 class WebRtcVideoReceiveStream; | |
| 189 struct VideoCodecSettings { | |
| 190 VideoCodecSettings(); | |
| 191 | |
| 192 bool operator==(const VideoCodecSettings& other) const; | |
| 193 bool operator!=(const VideoCodecSettings& other) const; | |
| 194 | |
| 195 VideoCodec codec; | |
| 196 webrtc::FecConfig fec; | |
| 197 int rtx_payload_type; | |
| 198 }; | |
| 199 | |
| 200 struct ChangedSendParameters { | |
| 201 // These optionals are unset if not changed. | |
| 202 rtc::Optional<VideoCodecSettings> codec; | |
| 203 rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions; | |
| 204 rtc::Optional<int> max_bandwidth_bps; | |
| 205 rtc::Optional<VideoOptions> options; | |
| 206 rtc::Optional<webrtc::RtcpMode> rtcp_mode; | |
| 207 }; | |
| 208 | |
| 209 struct ChangedRecvParameters { | |
| 210 // These optionals are unset if not changed. | |
| 211 rtc::Optional<std::vector<VideoCodecSettings>> codec_settings; | |
| 212 rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions; | |
| 213 rtc::Optional<webrtc::RtcpMode> rtcp_mode; | |
| 214 }; | |
| 215 | |
| 216 bool GetChangedSendParameters(const VideoSendParameters& params, | |
| 217 ChangedSendParameters* changed_params) const; | |
| 218 bool GetChangedRecvParameters(const VideoRecvParameters& params, | |
| 219 ChangedRecvParameters* changed_params) const; | |
| 220 | |
| 221 bool MuteStream(uint32_t ssrc, bool mute); | |
| 222 | |
| 223 void SetMaxSendBandwidth(int bps); | |
| 224 void SetOptions(const VideoOptions& options); | |
| 225 | |
| 226 void ConfigureReceiverRtp(webrtc::VideoReceiveStream::Config* config, | |
| 227 const StreamParams& sp) const; | |
| 228 bool CodecIsExternallySupported(const std::string& name) const; | |
| 229 bool ValidateSendSsrcAvailability(const StreamParams& sp) const | |
| 230 EXCLUSIVE_LOCKS_REQUIRED(stream_crit_); | |
| 231 bool ValidateReceiveSsrcAvailability(const StreamParams& sp) const | |
| 232 EXCLUSIVE_LOCKS_REQUIRED(stream_crit_); | |
| 233 void DeleteReceiveStream(WebRtcVideoReceiveStream* stream) | |
| 234 EXCLUSIVE_LOCKS_REQUIRED(stream_crit_); | |
| 235 | |
| 236 static std::string CodecSettingsVectorToString( | |
| 237 const std::vector<VideoCodecSettings>& codecs); | |
| 238 | |
| 239 // Wrapper for the sender part, this is where the capturer is connected and | |
| 240 // frames are then converted from cricket frames to webrtc frames. | |
| 241 class WebRtcVideoSendStream : public sigslot::has_slots<> { | |
| 242 public: | |
| 243 WebRtcVideoSendStream( | |
| 244 webrtc::Call* call, | |
| 245 const StreamParams& sp, | |
| 246 const webrtc::VideoSendStream::Config& config, | |
| 247 WebRtcVideoEncoderFactory* external_encoder_factory, | |
| 248 const VideoOptions& options, | |
| 249 int max_bitrate_bps, | |
| 250 const rtc::Optional<VideoCodecSettings>& codec_settings, | |
| 251 const std::vector<webrtc::RtpExtension>& rtp_extensions, | |
| 252 const VideoSendParameters& send_params); | |
| 253 ~WebRtcVideoSendStream(); | |
| 254 | |
| 255 void SetOptions(const VideoOptions& options); | |
| 256 // TODO(pbos): Move logic from SetOptions into this method. | |
| 257 void SetSendParameters(const ChangedSendParameters& send_params); | |
| 258 | |
| 259 void InputFrame(VideoCapturer* capturer, const VideoFrame* frame); | |
| 260 bool SetCapturer(VideoCapturer* capturer); | |
| 261 void MuteStream(bool mute); | |
| 262 bool DisconnectCapturer(); | |
| 263 | |
| 264 void Start(); | |
| 265 void Stop(); | |
| 266 | |
| 267 const std::vector<uint32_t>& GetSsrcs() const; | |
| 268 VideoSenderInfo GetVideoSenderInfo(); | |
| 269 void FillBandwidthEstimationInfo(BandwidthEstimationInfo* bwe_info); | |
| 270 | |
| 271 private: | |
| 272 // Parameters needed to reconstruct the underlying stream. | |
| 273 // webrtc::VideoSendStream doesn't support setting a lot of options on the | |
| 274 // fly, so when those need to be changed we tear down and reconstruct with | |
| 275 // similar parameters depending on which options changed etc. | |
| 276 struct VideoSendStreamParameters { | |
| 277 VideoSendStreamParameters( | |
| 278 const webrtc::VideoSendStream::Config& config, | |
| 279 const VideoOptions& options, | |
| 280 int max_bitrate_bps, | |
| 281 const rtc::Optional<VideoCodecSettings>& codec_settings); | |
| 282 webrtc::VideoSendStream::Config config; | |
| 283 VideoOptions options; | |
| 284 int max_bitrate_bps; | |
| 285 rtc::Optional<VideoCodecSettings> codec_settings; | |
| 286 // Sent resolutions + bitrates etc. by the underlying VideoSendStream, | |
| 287 // typically changes when setting a new resolution or reconfiguring | |
| 288 // bitrates. | |
| 289 webrtc::VideoEncoderConfig encoder_config; | |
| 290 }; | |
| 291 | |
| 292 struct AllocatedEncoder { | |
| 293 AllocatedEncoder(webrtc::VideoEncoder* encoder, | |
| 294 webrtc::VideoCodecType type, | |
| 295 bool external); | |
| 296 webrtc::VideoEncoder* encoder; | |
| 297 webrtc::VideoEncoder* external_encoder; | |
| 298 webrtc::VideoCodecType type; | |
| 299 bool external; | |
| 300 }; | |
| 301 | |
| 302 struct Dimensions { | |
| 303 // Initial encoder configuration (QCIF, 176x144) frame (to ensure that | |
| 304 // hardware encoders can be initialized). This gives us low memory usage | |
| 305 // but also makes it so configuration errors are discovered at the time we | |
| 306 // apply the settings rather than when we get the first frame (waiting for | |
| 307 // the first frame to know that you gave a bad codec parameter could make | |
| 308 // debugging hard). | |
| 309 // TODO(pbos): Consider setting up encoders lazily. | |
| 310 Dimensions() : width(176), height(144), is_screencast(false) {} | |
| 311 int width; | |
| 312 int height; | |
| 313 bool is_screencast; | |
| 314 }; | |
| 315 | |
| 316 union VideoEncoderSettings { | |
| 317 webrtc::VideoCodecH264 h264; | |
| 318 webrtc::VideoCodecVP8 vp8; | |
| 319 webrtc::VideoCodecVP9 vp9; | |
| 320 }; | |
| 321 | |
| 322 static std::vector<webrtc::VideoStream> CreateVideoStreams( | |
| 323 const VideoCodec& codec, | |
| 324 const VideoOptions& options, | |
| 325 int max_bitrate_bps, | |
| 326 size_t num_streams); | |
| 327 static std::vector<webrtc::VideoStream> CreateSimulcastVideoStreams( | |
| 328 const VideoCodec& codec, | |
| 329 const VideoOptions& options, | |
| 330 int max_bitrate_bps, | |
| 331 size_t num_streams); | |
| 332 | |
| 333 void* ConfigureVideoEncoderSettings(const VideoCodec& codec, | |
| 334 const VideoOptions& options, | |
| 335 bool is_screencast) | |
| 336 EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 337 | |
| 338 AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec) | |
| 339 EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 340 void DestroyVideoEncoder(AllocatedEncoder* encoder) | |
| 341 EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 342 void SetCodecAndOptions(const VideoCodecSettings& codec, | |
| 343 const VideoOptions& options) | |
| 344 EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 345 void RecreateWebRtcStream() EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 346 webrtc::VideoEncoderConfig CreateVideoEncoderConfig( | |
| 347 const Dimensions& dimensions, | |
| 348 const VideoCodec& codec) const EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 349 void SetDimensions(int width, int height, bool is_screencast) | |
| 350 EXCLUSIVE_LOCKS_REQUIRED(lock_); | |
| 351 | |
| 352 const std::vector<uint32_t> ssrcs_; | |
| 353 const std::vector<SsrcGroup> ssrc_groups_; | |
| 354 webrtc::Call* const call_; | |
| 355 WebRtcVideoEncoderFactory* const external_encoder_factory_ | |
| 356 GUARDED_BY(lock_); | |
| 357 | |
| 358 rtc::CriticalSection lock_; | |
| 359 webrtc::VideoSendStream* stream_ GUARDED_BY(lock_); | |
| 360 VideoSendStreamParameters parameters_ GUARDED_BY(lock_); | |
| 361 bool pending_encoder_reconfiguration_ GUARDED_BY(lock_); | |
| 362 VideoEncoderSettings encoder_settings_ GUARDED_BY(lock_); | |
| 363 AllocatedEncoder allocated_encoder_ GUARDED_BY(lock_); | |
| 364 Dimensions last_dimensions_ GUARDED_BY(lock_); | |
| 365 | |
| 366 VideoCapturer* capturer_ GUARDED_BY(lock_); | |
| 367 bool sending_ GUARDED_BY(lock_); | |
| 368 bool muted_ GUARDED_BY(lock_); | |
| 369 VideoFormat format_ GUARDED_BY(lock_); | |
| 370 int old_adapt_changes_ GUARDED_BY(lock_); | |
| 371 | |
| 372 // The timestamp of the first frame received | |
| 373 // Used to generate the timestamps of subsequent frames | |
| 374 int64_t first_frame_timestamp_ms_ GUARDED_BY(lock_); | |
| 375 | |
| 376 // The timestamp of the last frame received | |
| 377 // Used to generate timestamp for the black frame when capturer is removed | |
| 378 int64_t last_frame_timestamp_ms_ GUARDED_BY(lock_); | |
| 379 }; | |
| 380 | |
| 381 // Wrapper for the receiver part, contains configs etc. that are needed to | |
| 382 // reconstruct the underlying VideoReceiveStream. Also serves as a wrapper | |
| 383 // between webrtc::VideoRenderer and cricket::VideoRenderer. | |
| 384 class WebRtcVideoReceiveStream : public webrtc::VideoRenderer { | |
| 385 public: | |
| 386 WebRtcVideoReceiveStream( | |
| 387 webrtc::Call* call, | |
| 388 const StreamParams& sp, | |
| 389 const webrtc::VideoReceiveStream::Config& config, | |
| 390 WebRtcVideoDecoderFactory* external_decoder_factory, | |
| 391 bool default_stream, | |
| 392 const std::vector<VideoCodecSettings>& recv_codecs, | |
| 393 bool disable_prerenderer_smoothing); | |
| 394 ~WebRtcVideoReceiveStream(); | |
| 395 | |
| 396 const std::vector<uint32_t>& GetSsrcs() const; | |
| 397 | |
| 398 void SetLocalSsrc(uint32_t local_ssrc); | |
| 399 void SetFeedbackParameters(bool nack_enabled, | |
| 400 bool remb_enabled, | |
| 401 bool transport_cc_enabled); | |
| 402 void SetRecvParameters(const ChangedRecvParameters& recv_params); | |
| 403 | |
| 404 void RenderFrame(const webrtc::VideoFrame& frame, | |
| 405 int time_to_render_ms) override; | |
| 406 bool IsTextureSupported() const override; | |
| 407 bool SmoothsRenderedFrames() const override; | |
| 408 bool IsDefaultStream() const; | |
| 409 | |
| 410 void SetSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink); | |
| 411 | |
| 412 VideoReceiverInfo GetVideoReceiverInfo(); | |
| 413 | |
| 414 private: | |
| 415 struct AllocatedDecoder { | |
| 416 AllocatedDecoder(webrtc::VideoDecoder* decoder, | |
| 417 webrtc::VideoCodecType type, | |
| 418 bool external); | |
| 419 webrtc::VideoDecoder* decoder; | |
| 420 // Decoder wrapped into a fallback decoder to permit software fallback. | |
| 421 webrtc::VideoDecoder* external_decoder; | |
| 422 webrtc::VideoCodecType type; | |
| 423 bool external; | |
| 424 }; | |
| 425 | |
| 426 void RecreateWebRtcStream(); | |
| 427 | |
| 428 void ConfigureCodecs(const std::vector<VideoCodecSettings>& recv_codecs, | |
| 429 std::vector<AllocatedDecoder>* old_codecs); | |
| 430 AllocatedDecoder CreateOrReuseVideoDecoder( | |
| 431 std::vector<AllocatedDecoder>* old_decoder, | |
| 432 const VideoCodec& codec); | |
| 433 void ClearDecoders(std::vector<AllocatedDecoder>* allocated_decoders); | |
| 434 | |
| 435 std::string GetCodecNameFromPayloadType(int payload_type); | |
| 436 | |
| 437 webrtc::Call* const call_; | |
| 438 const std::vector<uint32_t> ssrcs_; | |
| 439 const std::vector<SsrcGroup> ssrc_groups_; | |
| 440 | |
| 441 webrtc::VideoReceiveStream* stream_; | |
| 442 const bool default_stream_; | |
| 443 webrtc::VideoReceiveStream::Config config_; | |
| 444 | |
| 445 WebRtcVideoDecoderFactory* const external_decoder_factory_; | |
| 446 std::vector<AllocatedDecoder> allocated_decoders_; | |
| 447 | |
| 448 const bool disable_prerenderer_smoothing_; | |
| 449 | |
| 450 rtc::CriticalSection sink_lock_; | |
| 451 rtc::VideoSinkInterface<cricket::VideoFrame>* sink_ GUARDED_BY(sink_lock_); | |
| 452 int last_width_ GUARDED_BY(sink_lock_); | |
| 453 int last_height_ GUARDED_BY(sink_lock_); | |
| 454 // Expands remote RTP timestamps to int64_t to be able to estimate how long | |
| 455 // the stream has been running. | |
| 456 rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_ | |
| 457 GUARDED_BY(sink_lock_); | |
| 458 int64_t first_frame_timestamp_ GUARDED_BY(sink_lock_); | |
| 459 // Start NTP time is estimated as current remote NTP time (estimated from | |
| 460 // RTCP) minus the elapsed time, as soon as remote NTP time is available. | |
| 461 int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(sink_lock_); | |
| 462 }; | |
| 463 | |
| 464 void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine); | |
| 465 void SetDefaultOptions(); | |
| 466 | |
| 467 bool SendRtp(const uint8_t* data, | |
| 468 size_t len, | |
| 469 const webrtc::PacketOptions& options) override; | |
| 470 bool SendRtcp(const uint8_t* data, size_t len) override; | |
| 471 | |
| 472 void StartAllSendStreams(); | |
| 473 void StopAllSendStreams(); | |
| 474 | |
| 475 static std::vector<VideoCodecSettings> MapCodecs( | |
| 476 const std::vector<VideoCodec>& codecs); | |
| 477 std::vector<VideoCodecSettings> FilterSupportedCodecs( | |
| 478 const std::vector<VideoCodecSettings>& mapped_codecs) const; | |
| 479 static bool ReceiveCodecsHaveChanged(std::vector<VideoCodecSettings> before, | |
| 480 std::vector<VideoCodecSettings> after); | |
| 481 | |
| 482 void FillSenderStats(VideoMediaInfo* info); | |
| 483 void FillReceiverStats(VideoMediaInfo* info); | |
| 484 void FillBandwidthEstimationStats(const webrtc::Call::Stats& stats, | |
| 485 VideoMediaInfo* info); | |
| 486 | |
| 487 rtc::ThreadChecker thread_checker_; | |
| 488 | |
| 489 uint32_t rtcp_receiver_report_ssrc_; | |
| 490 bool sending_; | |
| 491 webrtc::Call* const call_; | |
| 492 | |
| 493 uint32_t default_send_ssrc_; | |
| 494 | |
| 495 DefaultUnsignalledSsrcHandler default_unsignalled_ssrc_handler_; | |
| 496 UnsignalledSsrcHandler* const unsignalled_ssrc_handler_; | |
| 497 | |
| 498 // Separate list of set capturers used to signal CPU adaptation. These should | |
| 499 // not be locked while calling methods that take other locks to prevent | |
| 500 // lock-order inversions. | |
| 501 rtc::CriticalSection capturer_crit_; | |
| 502 bool signal_cpu_adaptation_ GUARDED_BY(capturer_crit_); | |
| 503 std::map<uint32_t, VideoCapturer*> capturers_ GUARDED_BY(capturer_crit_); | |
| 504 | |
| 505 rtc::CriticalSection stream_crit_; | |
| 506 // Using primary-ssrc (first ssrc) as key. | |
| 507 std::map<uint32_t, WebRtcVideoSendStream*> send_streams_ | |
| 508 GUARDED_BY(stream_crit_); | |
| 509 std::map<uint32_t, WebRtcVideoReceiveStream*> receive_streams_ | |
| 510 GUARDED_BY(stream_crit_); | |
| 511 std::set<uint32_t> send_ssrcs_ GUARDED_BY(stream_crit_); | |
| 512 std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_); | |
| 513 | |
| 514 rtc::Optional<VideoCodecSettings> send_codec_; | |
| 515 std::vector<webrtc::RtpExtension> send_rtp_extensions_; | |
| 516 | |
| 517 WebRtcVideoEncoderFactory* const external_encoder_factory_; | |
| 518 WebRtcVideoDecoderFactory* const external_decoder_factory_; | |
| 519 std::vector<VideoCodecSettings> recv_codecs_; | |
| 520 std::vector<webrtc::RtpExtension> recv_rtp_extensions_; | |
| 521 webrtc::Call::Config::BitrateConfig bitrate_config_; | |
| 522 VideoOptions options_; | |
| 523 // TODO(deadbeef): Don't duplicate information between | |
| 524 // send_params/recv_params, rtp_extensions, options, etc. | |
| 525 VideoSendParameters send_params_; | |
| 526 VideoRecvParameters recv_params_; | |
| 527 }; | |
| 528 | |
| 529 } // namespace cricket | |
| 530 | |
| 531 #endif // TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1587193006:
Move talk/media to webrtc/media (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master