pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 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 | #ifdef HAVE_WEBRTC_VIDEO |
| 29 | #include "talk/media/webrtc/webrtcvideoengine2.h" |
| 30 | |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 31 | #include <set> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 32 | #include <string> |
| 33 | |
| 34 | #include "libyuv/convert_from.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 35 | #include "talk/media/base/videocapturer.h" |
| 36 | #include "talk/media/base/videorenderer.h" |
buildbot@webrtc.org | df9bbbe | 2014-06-19 19:54:33 +0000 | [diff] [blame] | 37 | #include "talk/media/webrtc/constants.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 38 | #include "talk/media/webrtc/webrtcvideocapturer.h" |
| 39 | #include "talk/media/webrtc/webrtcvideoframe.h" |
| 40 | #include "talk/media/webrtc/webrtcvoiceengine.h" |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 +0000 | [diff] [blame] | 41 | #include "webrtc/base/buffer.h" |
| 42 | #include "webrtc/base/logging.h" |
| 43 | #include "webrtc/base/stringutils.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 44 | #include "webrtc/call.h" |
pbos@webrtc.org | ab990ae | 2014-09-17 09:02:25 +0000 | [diff] [blame] | 45 | #include "webrtc/video_encoder.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 46 | |
| 47 | #define UNIMPLEMENTED \ |
| 48 | LOG(LS_ERROR) << "Call to unimplemented function " << __FUNCTION__; \ |
| 49 | ASSERT(false) |
| 50 | |
| 51 | namespace cricket { |
| 52 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 53 | // This constant is really an on/off, lower-level configurable NACK history |
| 54 | // duration hasn't been implemented. |
| 55 | static const int kNackHistoryMs = 1000; |
| 56 | |
buildbot@webrtc.org | 933d88a | 2014-09-18 20:23:05 +0000 | [diff] [blame] | 57 | static const int kDefaultQpMax = 56; |
| 58 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 59 | static const int kDefaultRtcpReceiverReportSsrc = 1; |
| 60 | |
| 61 | struct VideoCodecPref { |
| 62 | int payload_type; |
pbos@webrtc.org | 97fdeb8 | 2014-08-22 10:36:23 +0000 | [diff] [blame] | 63 | int width; |
| 64 | int height; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 65 | const char* name; |
| 66 | int rtx_payload_type; |
pbos@webrtc.org | 97fdeb8 | 2014-08-22 10:36:23 +0000 | [diff] [blame] | 67 | } kDefaultVideoCodecPref = {100, 640, 400, kVp8CodecName, 96}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 68 | |
pbos@webrtc.org | 97fdeb8 | 2014-08-22 10:36:23 +0000 | [diff] [blame] | 69 | VideoCodecPref kRedPref = {116, -1, -1, kRedCodecName, -1}; |
| 70 | VideoCodecPref kUlpfecPref = {117, -1, -1, kUlpfecCodecName, -1}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 71 | |
| 72 | static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs, |
| 73 | const VideoCodec& requested_codec, |
| 74 | VideoCodec* matching_codec) { |
| 75 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 76 | if (requested_codec.Matches(codecs[i])) { |
| 77 | *matching_codec = codecs[i]; |
| 78 | return true; |
| 79 | } |
| 80 | } |
| 81 | return false; |
| 82 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 83 | |
pbos@webrtc.org | f99c2f2 | 2014-06-13 12:27:38 +0000 | [diff] [blame] | 84 | static void AddDefaultFeedbackParams(VideoCodec* codec) { |
| 85 | const FeedbackParam kFir(kRtcpFbParamCcm, kRtcpFbCcmParamFir); |
| 86 | codec->AddFeedbackParam(kFir); |
| 87 | const FeedbackParam kNack(kRtcpFbParamNack, kParamValueEmpty); |
| 88 | codec->AddFeedbackParam(kNack); |
| 89 | const FeedbackParam kPli(kRtcpFbParamNack, kRtcpFbNackParamPli); |
| 90 | codec->AddFeedbackParam(kPli); |
| 91 | const FeedbackParam kRemb(kRtcpFbParamRemb, kParamValueEmpty); |
| 92 | codec->AddFeedbackParam(kRemb); |
| 93 | } |
| 94 | |
| 95 | static bool IsNackEnabled(const VideoCodec& codec) { |
| 96 | return codec.HasFeedbackParam( |
| 97 | FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)); |
| 98 | } |
| 99 | |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 100 | static bool IsRembEnabled(const VideoCodec& codec) { |
| 101 | return codec.HasFeedbackParam( |
| 102 | FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty)); |
| 103 | } |
| 104 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 105 | static VideoCodec DefaultVideoCodec() { |
| 106 | VideoCodec default_codec(kDefaultVideoCodecPref.payload_type, |
| 107 | kDefaultVideoCodecPref.name, |
pbos@webrtc.org | 97fdeb8 | 2014-08-22 10:36:23 +0000 | [diff] [blame] | 108 | kDefaultVideoCodecPref.width, |
| 109 | kDefaultVideoCodecPref.height, |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 110 | kDefaultFramerate, |
| 111 | 0); |
pbos@webrtc.org | f99c2f2 | 2014-06-13 12:27:38 +0000 | [diff] [blame] | 112 | AddDefaultFeedbackParams(&default_codec); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 113 | return default_codec; |
| 114 | } |
| 115 | |
| 116 | static VideoCodec DefaultRedCodec() { |
| 117 | return VideoCodec(kRedPref.payload_type, kRedPref.name, 0, 0, 0, 0); |
| 118 | } |
| 119 | |
| 120 | static VideoCodec DefaultUlpfecCodec() { |
| 121 | return VideoCodec(kUlpfecPref.payload_type, kUlpfecPref.name, 0, 0, 0, 0); |
| 122 | } |
| 123 | |
| 124 | static std::vector<VideoCodec> DefaultVideoCodecs() { |
| 125 | std::vector<VideoCodec> codecs; |
| 126 | codecs.push_back(DefaultVideoCodec()); |
| 127 | codecs.push_back(DefaultRedCodec()); |
| 128 | codecs.push_back(DefaultUlpfecCodec()); |
| 129 | if (kDefaultVideoCodecPref.rtx_payload_type != -1) { |
| 130 | codecs.push_back( |
| 131 | VideoCodec::CreateRtxCodec(kDefaultVideoCodecPref.rtx_payload_type, |
| 132 | kDefaultVideoCodecPref.payload_type)); |
| 133 | } |
| 134 | return codecs; |
| 135 | } |
| 136 | |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 137 | static bool ValidateRtpHeaderExtensionIds( |
| 138 | const std::vector<RtpHeaderExtension>& extensions) { |
| 139 | std::set<int> extensions_used; |
| 140 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 141 | if (extensions[i].id < 0 || extensions[i].id >= 15 || |
| 142 | !extensions_used.insert(extensions[i].id).second) { |
| 143 | LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids."; |
| 144 | return false; |
| 145 | } |
| 146 | } |
| 147 | return true; |
| 148 | } |
| 149 | |
| 150 | static std::vector<webrtc::RtpExtension> FilterRtpExtensions( |
| 151 | const std::vector<RtpHeaderExtension>& extensions) { |
| 152 | std::vector<webrtc::RtpExtension> webrtc_extensions; |
| 153 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 154 | // Unsupported extensions will be ignored. |
| 155 | if (webrtc::RtpExtension::IsSupported(extensions[i].uri)) { |
| 156 | webrtc_extensions.push_back(webrtc::RtpExtension( |
| 157 | extensions[i].uri, extensions[i].id)); |
| 158 | } else { |
| 159 | LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri; |
| 160 | } |
| 161 | } |
| 162 | return webrtc_extensions; |
| 163 | } |
| 164 | |
pbos@webrtc.org | 0d523ee | 2014-06-05 09:10:55 +0000 | [diff] [blame] | 165 | WebRtcVideoEncoderFactory2::~WebRtcVideoEncoderFactory2() { |
| 166 | } |
| 167 | |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 168 | std::vector<webrtc::VideoStream> WebRtcVideoEncoderFactory2::CreateVideoStreams( |
| 169 | const VideoCodec& codec, |
| 170 | const VideoOptions& options, |
| 171 | size_t num_streams) { |
| 172 | assert(SupportsCodec(codec)); |
| 173 | if (num_streams != 1) { |
| 174 | LOG(LS_ERROR) << "Unsupported number of streams: " << num_streams; |
| 175 | return std::vector<webrtc::VideoStream>(); |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 176 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 177 | |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 178 | webrtc::VideoStream stream; |
| 179 | stream.width = codec.width; |
| 180 | stream.height = codec.height; |
| 181 | stream.max_framerate = |
| 182 | codec.framerate != 0 ? codec.framerate : kDefaultFramerate; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 183 | |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 184 | int min_bitrate = kMinVideoBitrate; |
| 185 | codec.GetParam(kCodecParamMinBitrate, &min_bitrate); |
| 186 | int max_bitrate = kMaxVideoBitrate; |
| 187 | codec.GetParam(kCodecParamMaxBitrate, &max_bitrate); |
| 188 | stream.min_bitrate_bps = min_bitrate * 1000; |
| 189 | stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate * 1000; |
| 190 | |
buildbot@webrtc.org | 933d88a | 2014-09-18 20:23:05 +0000 | [diff] [blame] | 191 | int max_qp = kDefaultQpMax; |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 192 | codec.GetParam(kCodecParamMaxQuantization, &max_qp); |
| 193 | stream.max_qp = max_qp; |
| 194 | std::vector<webrtc::VideoStream> streams; |
| 195 | streams.push_back(stream); |
| 196 | return streams; |
| 197 | } |
| 198 | |
| 199 | webrtc::VideoEncoder* WebRtcVideoEncoderFactory2::CreateVideoEncoder( |
| 200 | const VideoCodec& codec, |
| 201 | const VideoOptions& options) { |
| 202 | assert(SupportsCodec(codec)); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 203 | if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) { |
pbos@webrtc.org | ab990ae | 2014-09-17 09:02:25 +0000 | [diff] [blame] | 204 | return webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 205 | } |
| 206 | // This shouldn't happen, we should be able to create encoders for all codecs |
| 207 | // we support. |
| 208 | assert(false); |
| 209 | return NULL; |
| 210 | } |
| 211 | |
| 212 | void* WebRtcVideoEncoderFactory2::CreateVideoEncoderSettings( |
| 213 | const VideoCodec& codec, |
| 214 | const VideoOptions& options) { |
| 215 | assert(SupportsCodec(codec)); |
| 216 | if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) { |
pbos@webrtc.org | 6cd6ba8 | 2014-09-18 12:42:28 +0000 | [diff] [blame] | 217 | webrtc::VideoCodecVP8* settings = new webrtc::VideoCodecVP8( |
| 218 | webrtc::VideoEncoder::GetDefaultVp8Settings()); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 219 | options.video_noise_reduction.Get(&settings->denoisingOn); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 220 | return settings; |
| 221 | } |
| 222 | return NULL; |
| 223 | } |
| 224 | |
| 225 | void WebRtcVideoEncoderFactory2::DestroyVideoEncoderSettings( |
| 226 | const VideoCodec& codec, |
| 227 | void* encoder_settings) { |
| 228 | assert(SupportsCodec(codec)); |
| 229 | if (encoder_settings == NULL) { |
| 230 | return; |
| 231 | } |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 232 | if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) { |
| 233 | delete reinterpret_cast<webrtc::VideoCodecVP8*>(encoder_settings); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 234 | } |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | bool WebRtcVideoEncoderFactory2::SupportsCodec(const VideoCodec& codec) { |
buildbot@webrtc.org | df9bbbe | 2014-06-19 19:54:33 +0000 | [diff] [blame] | 238 | return _stricmp(codec.name.c_str(), kVp8CodecName) == 0; |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 239 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 240 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 241 | DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler() |
| 242 | : default_recv_ssrc_(0), default_renderer_(NULL) {} |
| 243 | |
| 244 | UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc( |
| 245 | VideoMediaChannel* channel, |
| 246 | uint32_t ssrc) { |
| 247 | if (default_recv_ssrc_ != 0) { // Already one default stream. |
| 248 | LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set."; |
| 249 | return kDropPacket; |
| 250 | } |
| 251 | |
| 252 | StreamParams sp; |
| 253 | sp.ssrcs.push_back(ssrc); |
| 254 | LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << "."; |
| 255 | if (!channel->AddRecvStream(sp)) { |
| 256 | LOG(LS_WARNING) << "Could not create default receive stream."; |
| 257 | } |
| 258 | |
| 259 | channel->SetRenderer(ssrc, default_renderer_); |
| 260 | default_recv_ssrc_ = ssrc; |
| 261 | return kDeliverPacket; |
| 262 | } |
| 263 | |
| 264 | VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const { |
| 265 | return default_renderer_; |
| 266 | } |
| 267 | |
| 268 | void DefaultUnsignalledSsrcHandler::SetDefaultRenderer( |
| 269 | VideoMediaChannel* channel, |
| 270 | VideoRenderer* renderer) { |
| 271 | default_renderer_ = renderer; |
| 272 | if (default_recv_ssrc_ != 0) { |
| 273 | channel->SetRenderer(default_recv_ssrc_, default_renderer_); |
| 274 | } |
| 275 | } |
| 276 | |
pbos@webrtc.org | 97fdeb8 | 2014-08-22 10:36:23 +0000 | [diff] [blame] | 277 | WebRtcVideoEngine2::WebRtcVideoEngine2() |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 278 | : worker_thread_(NULL), |
| 279 | voice_engine_(NULL), |
| 280 | video_codecs_(DefaultVideoCodecs()), |
buildbot@webrtc.org | 992febb | 2014-09-05 16:39:08 +0000 | [diff] [blame] | 281 | default_codec_format_(kDefaultVideoCodecPref.width, |
| 282 | kDefaultVideoCodecPref.height, |
| 283 | FPS_TO_INTERVAL(kDefaultFramerate), |
| 284 | FOURCC_ANY), |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 285 | initialized_(false), |
| 286 | cpu_monitor_(new rtc::CpuMonitor(NULL)), |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 287 | channel_factory_(NULL), |
| 288 | external_decoder_factory_(NULL), |
| 289 | external_encoder_factory_(NULL) { |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 290 | LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()"; |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 291 | rtp_header_extensions_.push_back( |
| 292 | RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension, |
| 293 | kRtpTimestampOffsetHeaderExtensionDefaultId)); |
| 294 | rtp_header_extensions_.push_back( |
| 295 | RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, |
| 296 | kRtpAbsoluteSenderTimeHeaderExtensionDefaultId)); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 297 | } |
| 298 | |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 299 | void WebRtcVideoEngine2::SetChannelFactory( |
| 300 | WebRtcVideoChannelFactory* channel_factory) { |
| 301 | channel_factory_ = channel_factory; |
| 302 | } |
| 303 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 304 | WebRtcVideoEngine2::~WebRtcVideoEngine2() { |
| 305 | LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2"; |
| 306 | |
| 307 | if (initialized_) { |
| 308 | Terminate(); |
| 309 | } |
| 310 | } |
| 311 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 312 | bool WebRtcVideoEngine2::Init(rtc::Thread* worker_thread) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 313 | LOG(LS_INFO) << "WebRtcVideoEngine2::Init"; |
| 314 | worker_thread_ = worker_thread; |
| 315 | ASSERT(worker_thread_ != NULL); |
| 316 | |
| 317 | cpu_monitor_->set_thread(worker_thread_); |
| 318 | if (!cpu_monitor_->Start(kCpuMonitorPeriodMs)) { |
| 319 | LOG(LS_ERROR) << "Failed to start CPU monitor."; |
| 320 | cpu_monitor_.reset(); |
| 321 | } |
| 322 | |
| 323 | initialized_ = true; |
| 324 | return true; |
| 325 | } |
| 326 | |
| 327 | void WebRtcVideoEngine2::Terminate() { |
| 328 | LOG(LS_INFO) << "WebRtcVideoEngine2::Terminate"; |
| 329 | |
| 330 | cpu_monitor_->Stop(); |
| 331 | |
| 332 | initialized_ = false; |
| 333 | } |
| 334 | |
| 335 | int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; } |
| 336 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 337 | bool WebRtcVideoEngine2::SetDefaultEncoderConfig( |
| 338 | const VideoEncoderConfig& config) { |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 339 | const VideoCodec& codec = config.max_codec; |
| 340 | // TODO(pbos): Make use of external encoder factory. |
| 341 | if (!GetVideoEncoderFactory()->SupportsCodec(codec)) { |
| 342 | LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported:" |
| 343 | << codec.ToString(); |
| 344 | return false; |
| 345 | } |
| 346 | |
buildbot@webrtc.org | 992febb | 2014-09-05 16:39:08 +0000 | [diff] [blame] | 347 | default_codec_format_ = |
| 348 | VideoFormat(codec.width, |
| 349 | codec.height, |
| 350 | VideoFormat::FpsToInterval(codec.framerate), |
| 351 | FOURCC_ANY); |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 352 | video_codecs_.clear(); |
| 353 | video_codecs_.push_back(codec); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 354 | return true; |
| 355 | } |
| 356 | |
| 357 | VideoEncoderConfig WebRtcVideoEngine2::GetDefaultEncoderConfig() const { |
| 358 | return VideoEncoderConfig(DefaultVideoCodec()); |
| 359 | } |
| 360 | |
| 361 | WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel( |
| 362 | VoiceMediaChannel* voice_channel) { |
| 363 | LOG(LS_INFO) << "CreateChannel: " |
| 364 | << (voice_channel != NULL ? "With" : "Without") |
| 365 | << " voice channel."; |
| 366 | WebRtcVideoChannel2* channel = |
| 367 | channel_factory_ != NULL |
| 368 | ? channel_factory_->Create(this, voice_channel) |
| 369 | : new WebRtcVideoChannel2( |
pbos@webrtc.org | 0d523ee | 2014-06-05 09:10:55 +0000 | [diff] [blame] | 370 | this, voice_channel, GetVideoEncoderFactory()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 371 | if (!channel->Init()) { |
| 372 | delete channel; |
| 373 | return NULL; |
| 374 | } |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 375 | channel->SetRecvCodecs(video_codecs_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 376 | return channel; |
| 377 | } |
| 378 | |
| 379 | const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const { |
| 380 | return video_codecs_; |
| 381 | } |
| 382 | |
| 383 | const std::vector<RtpHeaderExtension>& |
| 384 | WebRtcVideoEngine2::rtp_header_extensions() const { |
| 385 | return rtp_header_extensions_; |
| 386 | } |
| 387 | |
| 388 | void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) { |
| 389 | // TODO(pbos): Set up logging. |
| 390 | LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"'; |
| 391 | // if min_sev == -1, we keep the current log level. |
| 392 | if (min_sev < 0) { |
| 393 | assert(min_sev == -1); |
| 394 | return; |
| 395 | } |
| 396 | } |
| 397 | |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 398 | void WebRtcVideoEngine2::SetExternalDecoderFactory( |
| 399 | WebRtcVideoDecoderFactory* decoder_factory) { |
| 400 | external_decoder_factory_ = decoder_factory; |
| 401 | } |
| 402 | |
| 403 | void WebRtcVideoEngine2::SetExternalEncoderFactory( |
| 404 | WebRtcVideoEncoderFactory* encoder_factory) { |
| 405 | if (external_encoder_factory_ == encoder_factory) { |
| 406 | return; |
| 407 | } |
| 408 | if (external_encoder_factory_) { |
| 409 | external_encoder_factory_->RemoveObserver(this); |
| 410 | } |
| 411 | external_encoder_factory_ = encoder_factory; |
| 412 | if (external_encoder_factory_) { |
| 413 | external_encoder_factory_->AddObserver(this); |
| 414 | } |
| 415 | |
| 416 | // Invoke OnCodecAvailable() here in case the list of codecs is already |
| 417 | // available when the encoder factory is installed. If not the encoder |
| 418 | // factory will invoke the callback later when the codecs become available. |
| 419 | OnCodecsAvailable(); |
| 420 | } |
| 421 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 422 | bool WebRtcVideoEngine2::EnableTimedRender() { |
| 423 | // TODO(pbos): Figure out whether this can be removed. |
| 424 | return true; |
| 425 | } |
| 426 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 427 | // Checks to see whether we comprehend and could receive a particular codec |
| 428 | bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) { |
| 429 | // TODO(pbos): Probe encoder factory to figure out that the codec is supported |
| 430 | // if supported by the encoder factory. Add a corresponding test that fails |
| 431 | // with this code (that doesn't ask the factory). |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 432 | for (size_t j = 0; j < video_codecs_.size(); ++j) { |
| 433 | VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0); |
| 434 | if (codec.Matches(in)) { |
| 435 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 436 | } |
| 437 | } |
| 438 | return false; |
| 439 | } |
| 440 | |
| 441 | // Tells whether the |requested| codec can be transmitted or not. If it can be |
| 442 | // transmitted |out| is set with the best settings supported. Aspect ratio will |
| 443 | // be set as close to |current|'s as possible. If not set |requested|'s |
| 444 | // dimensions will be used for aspect ratio matching. |
| 445 | bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested, |
| 446 | const VideoCodec& current, |
| 447 | VideoCodec* out) { |
| 448 | assert(out != NULL); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 449 | |
| 450 | if (requested.width != requested.height && |
| 451 | (requested.height == 0 || requested.width == 0)) { |
| 452 | // 0xn and nx0 are invalid resolutions. |
| 453 | return false; |
| 454 | } |
| 455 | |
| 456 | VideoCodec matching_codec; |
| 457 | if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) { |
| 458 | // Codec not supported. |
| 459 | return false; |
| 460 | } |
| 461 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 462 | out->id = requested.id; |
| 463 | out->name = requested.name; |
| 464 | out->preference = requested.preference; |
| 465 | out->params = requested.params; |
| 466 | out->framerate = |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 467 | rtc::_min(requested.framerate, matching_codec.framerate); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 468 | out->params = requested.params; |
| 469 | out->feedback_params = requested.feedback_params; |
pbos@webrtc.org | 8fdeee6 | 2014-07-20 14:40:23 +0000 | [diff] [blame] | 470 | out->width = requested.width; |
| 471 | out->height = requested.height; |
| 472 | if (requested.width == 0 && requested.height == 0) { |
| 473 | return true; |
| 474 | } |
| 475 | |
| 476 | while (out->width > matching_codec.width) { |
| 477 | out->width /= 2; |
| 478 | out->height /= 2; |
| 479 | } |
| 480 | |
| 481 | return out->width > 0 && out->height > 0; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 482 | } |
| 483 | |
| 484 | bool WebRtcVideoEngine2::SetVoiceEngine(WebRtcVoiceEngine* voice_engine) { |
| 485 | if (initialized_) { |
| 486 | LOG(LS_WARNING) << "SetVoiceEngine can not be called after Init"; |
| 487 | return false; |
| 488 | } |
| 489 | voice_engine_ = voice_engine; |
| 490 | return true; |
| 491 | } |
| 492 | |
| 493 | // Ignore spammy trace messages, mostly from the stats API when we haven't |
| 494 | // gotten RTCP info yet from the remote side. |
| 495 | bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) { |
| 496 | static const char* const kTracesToIgnore[] = {NULL}; |
| 497 | for (const char* const* p = kTracesToIgnore; *p; ++p) { |
| 498 | if (trace.find(*p) == 0) { |
| 499 | return true; |
| 500 | } |
| 501 | } |
| 502 | return false; |
| 503 | } |
| 504 | |
buildbot@webrtc.org | d41eaeb | 2014-06-12 07:13:26 +0000 | [diff] [blame] | 505 | WebRtcVideoEncoderFactory2* WebRtcVideoEngine2::GetVideoEncoderFactory() { |
| 506 | return &default_video_encoder_factory_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 507 | } |
| 508 | |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 509 | void WebRtcVideoEngine2::OnCodecsAvailable() { |
| 510 | // TODO(pbos): Implement. |
| 511 | } |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 512 | // Thin map between VideoFrame and an existing webrtc::I420VideoFrame |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 513 | // to avoid having to copy the rendered VideoFrame prematurely. |
| 514 | // This implementation is only safe to use in a const context and should never |
| 515 | // be written to. |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 516 | class WebRtcVideoRenderFrame : public VideoFrame { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 517 | public: |
| 518 | explicit WebRtcVideoRenderFrame(const webrtc::I420VideoFrame* frame) |
| 519 | : frame_(frame) {} |
| 520 | |
| 521 | virtual bool InitToBlack(int w, |
| 522 | int h, |
| 523 | size_t pixel_width, |
| 524 | size_t pixel_height, |
| 525 | int64 elapsed_time, |
| 526 | int64 time_stamp) OVERRIDE { |
| 527 | UNIMPLEMENTED; |
| 528 | return false; |
| 529 | } |
| 530 | |
| 531 | virtual bool Reset(uint32 fourcc, |
| 532 | int w, |
| 533 | int h, |
| 534 | int dw, |
| 535 | int dh, |
| 536 | uint8* sample, |
| 537 | size_t sample_size, |
| 538 | size_t pixel_width, |
| 539 | size_t pixel_height, |
| 540 | int64 elapsed_time, |
| 541 | int64 time_stamp, |
| 542 | int rotation) OVERRIDE { |
| 543 | UNIMPLEMENTED; |
| 544 | return false; |
| 545 | } |
| 546 | |
| 547 | virtual size_t GetWidth() const OVERRIDE { |
| 548 | return static_cast<size_t>(frame_->width()); |
| 549 | } |
| 550 | virtual size_t GetHeight() const OVERRIDE { |
| 551 | return static_cast<size_t>(frame_->height()); |
| 552 | } |
| 553 | |
| 554 | virtual const uint8* GetYPlane() const OVERRIDE { |
| 555 | return frame_->buffer(webrtc::kYPlane); |
| 556 | } |
| 557 | virtual const uint8* GetUPlane() const OVERRIDE { |
| 558 | return frame_->buffer(webrtc::kUPlane); |
| 559 | } |
| 560 | virtual const uint8* GetVPlane() const OVERRIDE { |
| 561 | return frame_->buffer(webrtc::kVPlane); |
| 562 | } |
| 563 | |
| 564 | virtual uint8* GetYPlane() OVERRIDE { |
| 565 | UNIMPLEMENTED; |
| 566 | return NULL; |
| 567 | } |
| 568 | virtual uint8* GetUPlane() OVERRIDE { |
| 569 | UNIMPLEMENTED; |
| 570 | return NULL; |
| 571 | } |
| 572 | virtual uint8* GetVPlane() OVERRIDE { |
| 573 | UNIMPLEMENTED; |
| 574 | return NULL; |
| 575 | } |
| 576 | |
| 577 | virtual int32 GetYPitch() const OVERRIDE { |
| 578 | return frame_->stride(webrtc::kYPlane); |
| 579 | } |
| 580 | virtual int32 GetUPitch() const OVERRIDE { |
| 581 | return frame_->stride(webrtc::kUPlane); |
| 582 | } |
| 583 | virtual int32 GetVPitch() const OVERRIDE { |
| 584 | return frame_->stride(webrtc::kVPlane); |
| 585 | } |
| 586 | |
| 587 | virtual void* GetNativeHandle() const OVERRIDE { return NULL; } |
| 588 | |
| 589 | virtual size_t GetPixelWidth() const OVERRIDE { return 1; } |
| 590 | virtual size_t GetPixelHeight() const OVERRIDE { return 1; } |
| 591 | |
| 592 | virtual int64 GetElapsedTime() const OVERRIDE { |
| 593 | // Convert millisecond render time to ns timestamp. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 594 | return frame_->render_time_ms() * rtc::kNumNanosecsPerMillisec; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 595 | } |
| 596 | virtual int64 GetTimeStamp() const OVERRIDE { |
| 597 | // Convert 90K rtp timestamp to ns timestamp. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 598 | return (frame_->timestamp() / 90) * rtc::kNumNanosecsPerMillisec; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 599 | } |
| 600 | virtual void SetElapsedTime(int64 elapsed_time) OVERRIDE { UNIMPLEMENTED; } |
| 601 | virtual void SetTimeStamp(int64 time_stamp) OVERRIDE { UNIMPLEMENTED; } |
| 602 | |
| 603 | virtual int GetRotation() const OVERRIDE { |
| 604 | UNIMPLEMENTED; |
| 605 | return ROTATION_0; |
| 606 | } |
| 607 | |
| 608 | virtual VideoFrame* Copy() const OVERRIDE { |
| 609 | UNIMPLEMENTED; |
| 610 | return NULL; |
| 611 | } |
| 612 | |
| 613 | virtual bool MakeExclusive() OVERRIDE { |
| 614 | UNIMPLEMENTED; |
| 615 | return false; |
| 616 | } |
| 617 | |
| 618 | virtual size_t CopyToBuffer(uint8* buffer, size_t size) const { |
| 619 | UNIMPLEMENTED; |
| 620 | return 0; |
| 621 | } |
| 622 | |
| 623 | // TODO(fbarchard): Refactor into base class and share with LMI |
| 624 | virtual size_t ConvertToRgbBuffer(uint32 to_fourcc, |
| 625 | uint8* buffer, |
| 626 | size_t size, |
| 627 | int stride_rgb) const OVERRIDE { |
| 628 | size_t width = GetWidth(); |
| 629 | size_t height = GetHeight(); |
| 630 | size_t needed = (stride_rgb >= 0 ? stride_rgb : -stride_rgb) * height; |
| 631 | if (size < needed) { |
| 632 | LOG(LS_WARNING) << "RGB buffer is not large enough"; |
| 633 | return needed; |
| 634 | } |
| 635 | |
| 636 | if (libyuv::ConvertFromI420(GetYPlane(), |
| 637 | GetYPitch(), |
| 638 | GetUPlane(), |
| 639 | GetUPitch(), |
| 640 | GetVPlane(), |
| 641 | GetVPitch(), |
| 642 | buffer, |
| 643 | stride_rgb, |
| 644 | static_cast<int>(width), |
| 645 | static_cast<int>(height), |
| 646 | to_fourcc)) { |
| 647 | LOG(LS_ERROR) << "RGB type not supported: " << to_fourcc; |
| 648 | return 0; // 0 indicates error |
| 649 | } |
| 650 | return needed; |
| 651 | } |
| 652 | |
| 653 | protected: |
| 654 | virtual VideoFrame* CreateEmptyFrame(int w, |
| 655 | int h, |
| 656 | size_t pixel_width, |
| 657 | size_t pixel_height, |
| 658 | int64 elapsed_time, |
| 659 | int64 time_stamp) const OVERRIDE { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 660 | WebRtcVideoFrame* frame = new WebRtcVideoFrame(); |
| 661 | frame->InitToBlack( |
| 662 | w, h, pixel_width, pixel_height, elapsed_time, time_stamp); |
| 663 | return frame; |
| 664 | } |
| 665 | |
| 666 | private: |
| 667 | const webrtc::I420VideoFrame* const frame_; |
| 668 | }; |
| 669 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 670 | WebRtcVideoChannel2::WebRtcVideoChannel2( |
| 671 | WebRtcVideoEngine2* engine, |
| 672 | VoiceMediaChannel* voice_channel, |
| 673 | WebRtcVideoEncoderFactory2* encoder_factory) |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 674 | : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
| 675 | encoder_factory_(encoder_factory) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 676 | // TODO(pbos): Connect the video and audio with |voice_channel|. |
| 677 | webrtc::Call::Config config(this); |
| 678 | Construct(webrtc::Call::Create(config), engine); |
| 679 | } |
| 680 | |
| 681 | WebRtcVideoChannel2::WebRtcVideoChannel2( |
| 682 | webrtc::Call* call, |
| 683 | WebRtcVideoEngine2* engine, |
| 684 | WebRtcVideoEncoderFactory2* encoder_factory) |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 685 | : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
| 686 | encoder_factory_(encoder_factory) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 687 | Construct(call, engine); |
| 688 | } |
| 689 | |
| 690 | void WebRtcVideoChannel2::Construct(webrtc::Call* call, |
| 691 | WebRtcVideoEngine2* engine) { |
| 692 | rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
| 693 | sending_ = false; |
| 694 | call_.reset(call); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 695 | default_send_ssrc_ = 0; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 696 | |
| 697 | SetDefaultOptions(); |
| 698 | } |
| 699 | |
| 700 | void WebRtcVideoChannel2::SetDefaultOptions() { |
| 701 | options_.video_noise_reduction.Set(true); |
pbos@webrtc.org | 543e589 | 2014-07-23 07:01:31 +0000 | [diff] [blame] | 702 | options_.use_payload_padding.Set(false); |
pbos@webrtc.org | 5ff71ab | 2014-07-23 07:28:56 +0000 | [diff] [blame] | 703 | options_.suspend_below_min_bitrate.Set(false); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 704 | } |
| 705 | |
| 706 | WebRtcVideoChannel2::~WebRtcVideoChannel2() { |
| 707 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 708 | send_streams_.begin(); |
| 709 | it != send_streams_.end(); |
| 710 | ++it) { |
| 711 | delete it->second; |
| 712 | } |
| 713 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 714 | for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 715 | receive_streams_.begin(); |
| 716 | it != receive_streams_.end(); |
| 717 | ++it) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 718 | delete it->second; |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | bool WebRtcVideoChannel2::Init() { return true; } |
| 723 | |
| 724 | namespace { |
| 725 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 726 | static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) { |
| 727 | std::stringstream out; |
| 728 | out << '{'; |
| 729 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 730 | out << codecs[i].ToString(); |
| 731 | if (i != codecs.size() - 1) { |
| 732 | out << ", "; |
| 733 | } |
| 734 | } |
| 735 | out << '}'; |
| 736 | return out.str(); |
| 737 | } |
| 738 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 739 | static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) { |
| 740 | bool has_video = false; |
| 741 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 742 | if (!codecs[i].ValidateCodecFormat()) { |
| 743 | return false; |
| 744 | } |
| 745 | if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) { |
| 746 | has_video = true; |
| 747 | } |
| 748 | } |
| 749 | if (!has_video) { |
| 750 | LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: " |
| 751 | << CodecVectorToString(codecs); |
| 752 | return false; |
| 753 | } |
| 754 | return true; |
| 755 | } |
| 756 | |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 757 | static std::string RtpExtensionsToString( |
| 758 | const std::vector<RtpHeaderExtension>& extensions) { |
| 759 | std::stringstream out; |
| 760 | out << '{'; |
| 761 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 762 | out << "{" << extensions[i].uri << ": " << extensions[i].id << "}"; |
| 763 | if (i != extensions.size() - 1) { |
| 764 | out << ", "; |
| 765 | } |
| 766 | } |
| 767 | out << '}'; |
| 768 | return out.str(); |
| 769 | } |
| 770 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 771 | } // namespace |
| 772 | |
| 773 | bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 774 | LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs); |
| 775 | if (!ValidateCodecFormats(codecs)) { |
| 776 | return false; |
| 777 | } |
| 778 | |
| 779 | const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs); |
| 780 | if (mapped_codecs.empty()) { |
| 781 | LOG(LS_ERROR) << "SetRecvCodecs called without video codec payloads."; |
| 782 | return false; |
| 783 | } |
| 784 | |
| 785 | // TODO(pbos): Add a decoder factory which controls supported codecs. |
| 786 | // Blocked on webrtc:2854. |
| 787 | for (size_t i = 0; i < mapped_codecs.size(); ++i) { |
buildbot@webrtc.org | df9bbbe | 2014-06-19 19:54:33 +0000 | [diff] [blame] | 788 | if (_stricmp(mapped_codecs[i].codec.name.c_str(), kVp8CodecName) != 0) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 789 | LOG(LS_ERROR) << "SetRecvCodecs called with unsupported codec: '" |
| 790 | << mapped_codecs[i].codec.name << "'"; |
| 791 | return false; |
| 792 | } |
| 793 | } |
| 794 | |
| 795 | recv_codecs_ = mapped_codecs; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 796 | |
| 797 | for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
| 798 | receive_streams_.begin(); |
| 799 | it != receive_streams_.end(); |
| 800 | ++it) { |
| 801 | it->second->SetRecvCodecs(recv_codecs_); |
| 802 | } |
| 803 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 804 | return true; |
| 805 | } |
| 806 | |
| 807 | bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) { |
| 808 | LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs); |
| 809 | if (!ValidateCodecFormats(codecs)) { |
| 810 | return false; |
| 811 | } |
| 812 | |
| 813 | const std::vector<VideoCodecSettings> supported_codecs = |
| 814 | FilterSupportedCodecs(MapCodecs(codecs)); |
| 815 | |
| 816 | if (supported_codecs.empty()) { |
| 817 | LOG(LS_ERROR) << "No video codecs supported by encoder factory."; |
| 818 | return false; |
| 819 | } |
| 820 | |
| 821 | send_codec_.Set(supported_codecs.front()); |
| 822 | LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString(); |
| 823 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 824 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 825 | send_streams_.begin(); |
| 826 | it != send_streams_.end(); |
| 827 | ++it) { |
| 828 | assert(it->second != NULL); |
| 829 | it->second->SetCodec(supported_codecs.front()); |
| 830 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 831 | |
| 832 | return true; |
| 833 | } |
| 834 | |
| 835 | bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) { |
| 836 | VideoCodecSettings codec_settings; |
| 837 | if (!send_codec_.Get(&codec_settings)) { |
| 838 | LOG(LS_VERBOSE) << "GetSendCodec: No send codec set."; |
| 839 | return false; |
| 840 | } |
| 841 | *codec = codec_settings.codec; |
| 842 | return true; |
| 843 | } |
| 844 | |
| 845 | bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc, |
| 846 | const VideoFormat& format) { |
| 847 | LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> " |
| 848 | << format.ToString(); |
| 849 | if (send_streams_.find(ssrc) == send_streams_.end()) { |
| 850 | return false; |
| 851 | } |
| 852 | return send_streams_[ssrc]->SetVideoFormat(format); |
| 853 | } |
| 854 | |
| 855 | bool WebRtcVideoChannel2::SetRender(bool render) { |
| 856 | // TODO(pbos): Implement. Or refactor away as it shouldn't be needed. |
| 857 | LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false"); |
| 858 | return true; |
| 859 | } |
| 860 | |
| 861 | bool WebRtcVideoChannel2::SetSend(bool send) { |
| 862 | LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false"); |
| 863 | if (send && !send_codec_.IsSet()) { |
| 864 | LOG(LS_ERROR) << "SetSend(true) called before setting codec."; |
| 865 | return false; |
| 866 | } |
| 867 | if (send) { |
| 868 | StartAllSendStreams(); |
| 869 | } else { |
| 870 | StopAllSendStreams(); |
| 871 | } |
| 872 | sending_ = send; |
| 873 | return true; |
| 874 | } |
| 875 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 876 | bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) { |
| 877 | LOG(LS_INFO) << "AddSendStream: " << sp.ToString(); |
| 878 | if (sp.ssrcs.empty()) { |
| 879 | LOG(LS_ERROR) << "No SSRCs in stream parameters."; |
| 880 | return false; |
| 881 | } |
| 882 | |
| 883 | uint32 ssrc = sp.first_ssrc(); |
| 884 | assert(ssrc != 0); |
| 885 | // TODO(pbos): Make sure none of sp.ssrcs are used, not just the identifying |
| 886 | // ssrc. |
| 887 | if (send_streams_.find(ssrc) != send_streams_.end()) { |
| 888 | LOG(LS_ERROR) << "Send stream with ssrc '" << ssrc << "' already exists."; |
| 889 | return false; |
| 890 | } |
| 891 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 892 | std::vector<uint32> primary_ssrcs; |
| 893 | sp.GetPrimarySsrcs(&primary_ssrcs); |
| 894 | std::vector<uint32> rtx_ssrcs; |
| 895 | sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs); |
| 896 | if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) { |
| 897 | LOG(LS_ERROR) |
| 898 | << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): " |
| 899 | << sp.ToString(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 900 | return false; |
| 901 | } |
| 902 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 903 | WebRtcVideoSendStream* stream = |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 904 | new WebRtcVideoSendStream(call_.get(), |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 905 | encoder_factory_, |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 906 | options_, |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 907 | send_codec_, |
| 908 | sp, |
| 909 | send_rtp_extensions_); |
| 910 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 911 | send_streams_[ssrc] = stream; |
| 912 | |
| 913 | if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) { |
| 914 | rtcp_receiver_report_ssrc_ = ssrc; |
| 915 | } |
| 916 | if (default_send_ssrc_ == 0) { |
| 917 | default_send_ssrc_ = ssrc; |
| 918 | } |
| 919 | if (sending_) { |
| 920 | stream->Start(); |
| 921 | } |
| 922 | |
| 923 | return true; |
| 924 | } |
| 925 | |
| 926 | bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) { |
| 927 | LOG(LS_INFO) << "RemoveSendStream: " << ssrc; |
| 928 | |
| 929 | if (ssrc == 0) { |
| 930 | if (default_send_ssrc_ == 0) { |
| 931 | LOG(LS_ERROR) << "No default send stream active."; |
| 932 | return false; |
| 933 | } |
| 934 | |
| 935 | LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_; |
| 936 | ssrc = default_send_ssrc_; |
| 937 | } |
| 938 | |
| 939 | std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 940 | send_streams_.find(ssrc); |
| 941 | if (it == send_streams_.end()) { |
| 942 | return false; |
| 943 | } |
| 944 | |
| 945 | delete it->second; |
| 946 | send_streams_.erase(it); |
| 947 | |
| 948 | if (ssrc == default_send_ssrc_) { |
| 949 | default_send_ssrc_ = 0; |
| 950 | } |
| 951 | |
| 952 | return true; |
| 953 | } |
| 954 | |
| 955 | bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) { |
| 956 | LOG(LS_INFO) << "AddRecvStream: " << sp.ToString(); |
| 957 | assert(sp.ssrcs.size() > 0); |
| 958 | |
| 959 | uint32 ssrc = sp.first_ssrc(); |
| 960 | assert(ssrc != 0); // TODO(pbos): Is this ever valid? |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 961 | |
| 962 | // TODO(pbos): Check if any of the SSRCs overlap. |
| 963 | if (receive_streams_.find(ssrc) != receive_streams_.end()) { |
| 964 | LOG(LS_ERROR) << "Receive stream for SSRC " << ssrc << "already exists."; |
| 965 | return false; |
| 966 | } |
| 967 | |
pbos@webrtc.org | bd249bc | 2014-07-07 04:45:15 +0000 | [diff] [blame] | 968 | webrtc::VideoReceiveStream::Config config; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 969 | ConfigureReceiverRtp(&config, sp); |
| 970 | receive_streams_[ssrc] = |
| 971 | new WebRtcVideoReceiveStream(call_.get(), config, recv_codecs_); |
| 972 | |
| 973 | return true; |
| 974 | } |
| 975 | |
| 976 | void WebRtcVideoChannel2::ConfigureReceiverRtp( |
| 977 | webrtc::VideoReceiveStream::Config* config, |
| 978 | const StreamParams& sp) const { |
| 979 | uint32 ssrc = sp.first_ssrc(); |
| 980 | |
| 981 | config->rtp.remote_ssrc = ssrc; |
| 982 | config->rtp.local_ssrc = rtcp_receiver_report_ssrc_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 983 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 984 | config->rtp.extensions = recv_rtp_extensions_; |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 985 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 986 | // TODO(pbos): This protection is against setting the same local ssrc as |
| 987 | // remote which is not permitted by the lower-level API. RTCP requires a |
| 988 | // corresponding sender SSRC. Figure out what to do when we don't have |
| 989 | // (receive-only) or know a good local SSRC. |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 990 | if (config->rtp.remote_ssrc == config->rtp.local_ssrc) { |
| 991 | if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) { |
| 992 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 993 | } else { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 994 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 995 | } |
| 996 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 997 | |
| 998 | for (size_t i = 0; i < recv_codecs_.size(); ++i) { |
| 999 | if (recv_codecs_[i].codec.id == kDefaultVideoCodecPref.payload_type) { |
| 1000 | config->rtp.fec = recv_codecs_[i].fec; |
| 1001 | uint32 rtx_ssrc; |
| 1002 | if (recv_codecs_[i].rtx_payload_type != -1 && |
| 1003 | sp.GetFidSsrc(ssrc, &rtx_ssrc)) { |
| 1004 | config->rtp.rtx[kDefaultVideoCodecPref.payload_type].ssrc = rtx_ssrc; |
| 1005 | config->rtp.rtx[kDefaultVideoCodecPref.payload_type].payload_type = |
| 1006 | recv_codecs_[i].rtx_payload_type; |
| 1007 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1008 | break; |
| 1009 | } |
| 1010 | } |
| 1011 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1012 | } |
| 1013 | |
| 1014 | bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) { |
| 1015 | LOG(LS_INFO) << "RemoveRecvStream: " << ssrc; |
| 1016 | if (ssrc == 0) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1017 | LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported."; |
| 1018 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1019 | } |
| 1020 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1021 | std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream = |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1022 | receive_streams_.find(ssrc); |
| 1023 | if (stream == receive_streams_.end()) { |
| 1024 | LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc; |
| 1025 | return false; |
| 1026 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1027 | delete stream->second; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1028 | receive_streams_.erase(stream); |
| 1029 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1030 | return true; |
| 1031 | } |
| 1032 | |
| 1033 | bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) { |
| 1034 | LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " " |
| 1035 | << (renderer ? "(ptr)" : "NULL"); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1036 | if (ssrc == 0) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1037 | default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1038 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1039 | } |
| 1040 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1041 | std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
| 1042 | receive_streams_.find(ssrc); |
| 1043 | if (it == receive_streams_.end()) { |
| 1044 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1045 | } |
| 1046 | |
| 1047 | it->second->SetRenderer(renderer); |
| 1048 | return true; |
| 1049 | } |
| 1050 | |
| 1051 | bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) { |
| 1052 | if (ssrc == 0) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1053 | *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer(); |
| 1054 | return *renderer != NULL; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1055 | } |
| 1056 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1057 | std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
| 1058 | receive_streams_.find(ssrc); |
| 1059 | if (it == receive_streams_.end()) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1060 | return false; |
| 1061 | } |
| 1062 | *renderer = it->second->GetRenderer(); |
| 1063 | return true; |
| 1064 | } |
| 1065 | |
| 1066 | bool WebRtcVideoChannel2::GetStats(const StatsOptions& options, |
| 1067 | VideoMediaInfo* info) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1068 | info->Clear(); |
| 1069 | FillSenderStats(info); |
| 1070 | FillReceiverStats(info); |
| 1071 | FillBandwidthEstimationStats(info); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1072 | return true; |
| 1073 | } |
| 1074 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1075 | void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) { |
| 1076 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 1077 | send_streams_.begin(); |
| 1078 | it != send_streams_.end(); |
| 1079 | ++it) { |
| 1080 | video_media_info->senders.push_back(it->second->GetVideoSenderInfo()); |
| 1081 | } |
| 1082 | } |
| 1083 | |
| 1084 | void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) { |
| 1085 | for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
| 1086 | receive_streams_.begin(); |
| 1087 | it != receive_streams_.end(); |
| 1088 | ++it) { |
| 1089 | video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo()); |
| 1090 | } |
| 1091 | } |
| 1092 | |
| 1093 | void WebRtcVideoChannel2::FillBandwidthEstimationStats( |
| 1094 | VideoMediaInfo* video_media_info) { |
| 1095 | // TODO(pbos): Implement. |
| 1096 | } |
| 1097 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1098 | bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) { |
| 1099 | LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> " |
| 1100 | << (capturer != NULL ? "(capturer)" : "NULL"); |
| 1101 | assert(ssrc != 0); |
| 1102 | if (send_streams_.find(ssrc) == send_streams_.end()) { |
| 1103 | LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; |
| 1104 | return false; |
| 1105 | } |
| 1106 | return send_streams_[ssrc]->SetCapturer(capturer); |
| 1107 | } |
| 1108 | |
| 1109 | bool WebRtcVideoChannel2::SendIntraFrame() { |
| 1110 | // TODO(pbos): Implement. |
| 1111 | LOG(LS_VERBOSE) << "SendIntraFrame()."; |
| 1112 | return true; |
| 1113 | } |
| 1114 | |
| 1115 | bool WebRtcVideoChannel2::RequestIntraFrame() { |
| 1116 | // TODO(pbos): Implement. |
| 1117 | LOG(LS_VERBOSE) << "SendIntraFrame()."; |
| 1118 | return true; |
| 1119 | } |
| 1120 | |
| 1121 | void WebRtcVideoChannel2::OnPacketReceived( |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1122 | rtc::Buffer* packet, |
| 1123 | const rtc::PacketTime& packet_time) { |
pbos@webrtc.org | 4e545cc | 2014-05-14 13:58:13 +0000 | [diff] [blame] | 1124 | const webrtc::PacketReceiver::DeliveryStatus delivery_result = |
| 1125 | call_->Receiver()->DeliverPacket( |
| 1126 | reinterpret_cast<const uint8_t*>(packet->data()), packet->length()); |
| 1127 | switch (delivery_result) { |
| 1128 | case webrtc::PacketReceiver::DELIVERY_OK: |
| 1129 | return; |
| 1130 | case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR: |
| 1131 | return; |
| 1132 | case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC: |
| 1133 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1134 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1135 | |
| 1136 | uint32 ssrc = 0; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1137 | if (!GetRtpSsrc(packet->data(), packet->length(), &ssrc)) { |
| 1138 | return; |
| 1139 | } |
| 1140 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1141 | // TODO(pbos): Make sure that the unsignalled SSRC uses the video payload. |
| 1142 | // Also figure out whether RTX needs to be handled. |
| 1143 | switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) { |
| 1144 | case UnsignalledSsrcHandler::kDropPacket: |
| 1145 | return; |
| 1146 | case UnsignalledSsrcHandler::kDeliverPacket: |
| 1147 | break; |
| 1148 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1149 | |
pbos@webrtc.org | 1e019d1 | 2014-05-16 11:38:45 +0000 | [diff] [blame] | 1150 | if (call_->Receiver()->DeliverPacket( |
| 1151 | reinterpret_cast<const uint8_t*>(packet->data()), packet->length()) != |
| 1152 | webrtc::PacketReceiver::DELIVERY_OK) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1153 | LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1154 | return; |
| 1155 | } |
| 1156 | } |
| 1157 | |
| 1158 | void WebRtcVideoChannel2::OnRtcpReceived( |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1159 | rtc::Buffer* packet, |
| 1160 | const rtc::PacketTime& packet_time) { |
pbos@webrtc.org | 1e019d1 | 2014-05-16 11:38:45 +0000 | [diff] [blame] | 1161 | if (call_->Receiver()->DeliverPacket( |
| 1162 | reinterpret_cast<const uint8_t*>(packet->data()), packet->length()) != |
| 1163 | webrtc::PacketReceiver::DELIVERY_OK) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1164 | LOG(LS_WARNING) << "Failed to deliver RTCP packet."; |
| 1165 | } |
| 1166 | } |
| 1167 | |
| 1168 | void WebRtcVideoChannel2::OnReadyToSend(bool ready) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1169 | LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); |
| 1170 | call_->SignalNetworkState(ready ? webrtc::Call::kNetworkUp |
| 1171 | : webrtc::Call::kNetworkDown); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1172 | } |
| 1173 | |
| 1174 | bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) { |
| 1175 | LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> " |
| 1176 | << (mute ? "mute" : "unmute"); |
| 1177 | assert(ssrc != 0); |
| 1178 | if (send_streams_.find(ssrc) == send_streams_.end()) { |
| 1179 | LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; |
| 1180 | return false; |
| 1181 | } |
pbos@webrtc.org | ef8bb8d | 2014-08-13 21:36:18 +0000 | [diff] [blame] | 1182 | |
| 1183 | send_streams_[ssrc]->MuteStream(mute); |
| 1184 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1185 | } |
| 1186 | |
| 1187 | bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions( |
| 1188 | const std::vector<RtpHeaderExtension>& extensions) { |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1189 | LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: " |
| 1190 | << RtpExtensionsToString(extensions); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1191 | if (!ValidateRtpHeaderExtensionIds(extensions)) |
| 1192 | return false; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1193 | |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1194 | recv_rtp_extensions_ = FilterRtpExtensions(extensions); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1195 | for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it = |
| 1196 | receive_streams_.begin(); |
| 1197 | it != receive_streams_.end(); |
| 1198 | ++it) { |
| 1199 | it->second->SetRtpExtensions(recv_rtp_extensions_); |
| 1200 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1201 | return true; |
| 1202 | } |
| 1203 | |
| 1204 | bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions( |
| 1205 | const std::vector<RtpHeaderExtension>& extensions) { |
pbos@webrtc.org | 587ef60 | 2014-06-16 17:32:02 +0000 | [diff] [blame] | 1206 | LOG(LS_INFO) << "SetSendRtpHeaderExtensions: " |
| 1207 | << RtpExtensionsToString(extensions); |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 1208 | if (!ValidateRtpHeaderExtensionIds(extensions)) |
| 1209 | return false; |
| 1210 | |
| 1211 | send_rtp_extensions_ = FilterRtpExtensions(extensions); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1212 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 1213 | send_streams_.begin(); |
| 1214 | it != send_streams_.end(); |
| 1215 | ++it) { |
| 1216 | it->second->SetRtpExtensions(send_rtp_extensions_); |
| 1217 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1218 | return true; |
| 1219 | } |
| 1220 | |
| 1221 | bool WebRtcVideoChannel2::SetStartSendBandwidth(int bps) { |
| 1222 | // TODO(pbos): Implement. |
| 1223 | LOG(LS_VERBOSE) << "SetStartSendBandwidth: " << bps; |
| 1224 | return true; |
| 1225 | } |
| 1226 | |
| 1227 | bool WebRtcVideoChannel2::SetMaxSendBandwidth(int bps) { |
| 1228 | // TODO(pbos): Implement. |
| 1229 | LOG(LS_VERBOSE) << "SetMaxSendBandwidth: " << bps; |
| 1230 | return true; |
| 1231 | } |
| 1232 | |
| 1233 | bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) { |
| 1234 | LOG(LS_VERBOSE) << "SetOptions: " << options.ToString(); |
| 1235 | options_.SetAll(options); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1236 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 1237 | send_streams_.begin(); |
| 1238 | it != send_streams_.end(); |
| 1239 | ++it) { |
| 1240 | it->second->SetOptions(options_); |
| 1241 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1242 | return true; |
| 1243 | } |
| 1244 | |
| 1245 | void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) { |
| 1246 | MediaChannel::SetInterface(iface); |
| 1247 | // Set the RTP recv/send buffer to a bigger size |
| 1248 | MediaChannel::SetOption(NetworkInterface::ST_RTP, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1249 | rtc::Socket::OPT_RCVBUF, |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1250 | kVideoRtpBufferSize); |
| 1251 | |
| 1252 | // TODO(sriniv): Remove or re-enable this. |
| 1253 | // As part of b/8030474, send-buffer is size now controlled through |
| 1254 | // portallocator flags. |
| 1255 | // network_interface_->SetOption(NetworkInterface::ST_RTP, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1256 | // rtc::Socket::OPT_SNDBUF, |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1257 | // kVideoRtpBufferSize); |
| 1258 | } |
| 1259 | |
| 1260 | void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) { |
| 1261 | // TODO(pbos): Implement. |
| 1262 | } |
| 1263 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1264 | void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1265 | // Ignored. |
| 1266 | } |
| 1267 | |
| 1268 | bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1269 | rtc::Buffer packet(data, len, kMaxRtpPacketLen); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1270 | return MediaChannel::SendPacket(&packet); |
| 1271 | } |
| 1272 | |
| 1273 | bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1274 | rtc::Buffer packet(data, len, kMaxRtpPacketLen); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1275 | return MediaChannel::SendRtcp(&packet); |
| 1276 | } |
| 1277 | |
| 1278 | void WebRtcVideoChannel2::StartAllSendStreams() { |
| 1279 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 1280 | send_streams_.begin(); |
| 1281 | it != send_streams_.end(); |
| 1282 | ++it) { |
| 1283 | it->second->Start(); |
| 1284 | } |
| 1285 | } |
| 1286 | |
| 1287 | void WebRtcVideoChannel2::StopAllSendStreams() { |
| 1288 | for (std::map<uint32, WebRtcVideoSendStream*>::iterator it = |
| 1289 | send_streams_.begin(); |
| 1290 | it != send_streams_.end(); |
| 1291 | ++it) { |
| 1292 | it->second->Stop(); |
| 1293 | } |
| 1294 | } |
| 1295 | |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1296 | WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters:: |
| 1297 | VideoSendStreamParameters( |
| 1298 | const webrtc::VideoSendStream::Config& config, |
| 1299 | const VideoOptions& options, |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1300 | const Settable<VideoCodecSettings>& codec_settings) |
| 1301 | : config(config), options(options), codec_settings(codec_settings) { |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1302 | } |
| 1303 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1304 | WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream( |
| 1305 | webrtc::Call* call, |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1306 | WebRtcVideoEncoderFactory2* encoder_factory, |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1307 | const VideoOptions& options, |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1308 | const Settable<VideoCodecSettings>& codec_settings, |
| 1309 | const StreamParams& sp, |
| 1310 | const std::vector<webrtc::RtpExtension>& rtp_extensions) |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1311 | : call_(call), |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1312 | encoder_factory_(encoder_factory), |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1313 | stream_(NULL), |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 1314 | parameters_(webrtc::VideoSendStream::Config(), options, codec_settings), |
| 1315 | capturer_(NULL), |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1316 | sending_(false), |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1317 | muted_(false) { |
| 1318 | parameters_.config.rtp.max_packet_size = kVideoMtu; |
| 1319 | |
| 1320 | sp.GetPrimarySsrcs(¶meters_.config.rtp.ssrcs); |
| 1321 | sp.GetFidSsrcs(parameters_.config.rtp.ssrcs, |
| 1322 | ¶meters_.config.rtp.rtx.ssrcs); |
| 1323 | parameters_.config.rtp.c_name = sp.cname; |
| 1324 | parameters_.config.rtp.extensions = rtp_extensions; |
| 1325 | |
| 1326 | VideoCodecSettings params; |
| 1327 | if (codec_settings.Get(¶ms)) { |
| 1328 | SetCodec(params); |
| 1329 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1330 | } |
| 1331 | |
| 1332 | WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() { |
| 1333 | DisconnectCapturer(); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1334 | if (stream_ != NULL) { |
| 1335 | call_->DestroyVideoSendStream(stream_); |
| 1336 | } |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1337 | delete parameters_.config.encoder_settings.encoder; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1338 | } |
| 1339 | |
| 1340 | static void SetWebRtcFrameToBlack(webrtc::I420VideoFrame* video_frame) { |
| 1341 | assert(video_frame != NULL); |
| 1342 | memset(video_frame->buffer(webrtc::kYPlane), |
| 1343 | 16, |
| 1344 | video_frame->allocated_size(webrtc::kYPlane)); |
| 1345 | memset(video_frame->buffer(webrtc::kUPlane), |
| 1346 | 128, |
| 1347 | video_frame->allocated_size(webrtc::kUPlane)); |
| 1348 | memset(video_frame->buffer(webrtc::kVPlane), |
| 1349 | 128, |
| 1350 | video_frame->allocated_size(webrtc::kVPlane)); |
| 1351 | } |
| 1352 | |
| 1353 | static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame, |
| 1354 | int width, |
| 1355 | int height) { |
| 1356 | video_frame->CreateEmptyFrame( |
| 1357 | width, height, width, (width + 1) / 2, (width + 1) / 2); |
| 1358 | SetWebRtcFrameToBlack(video_frame); |
| 1359 | } |
| 1360 | |
| 1361 | static void ConvertToI420VideoFrame(const VideoFrame& frame, |
| 1362 | webrtc::I420VideoFrame* i420_frame) { |
| 1363 | i420_frame->CreateFrame( |
| 1364 | static_cast<int>(frame.GetYPitch() * frame.GetHeight()), |
| 1365 | frame.GetYPlane(), |
| 1366 | static_cast<int>(frame.GetUPitch() * ((frame.GetHeight() + 1) / 2)), |
| 1367 | frame.GetUPlane(), |
| 1368 | static_cast<int>(frame.GetVPitch() * ((frame.GetHeight() + 1) / 2)), |
| 1369 | frame.GetVPlane(), |
| 1370 | static_cast<int>(frame.GetWidth()), |
| 1371 | static_cast<int>(frame.GetHeight()), |
| 1372 | static_cast<int>(frame.GetYPitch()), |
| 1373 | static_cast<int>(frame.GetUPitch()), |
| 1374 | static_cast<int>(frame.GetVPitch())); |
| 1375 | } |
| 1376 | |
| 1377 | void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame( |
| 1378 | VideoCapturer* capturer, |
| 1379 | const VideoFrame* frame) { |
| 1380 | LOG(LS_VERBOSE) << "InputFrame: " << frame->GetWidth() << "x" |
| 1381 | << frame->GetHeight(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1382 | // Lock before copying, can be called concurrently when swapping input source. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1383 | rtc::CritScope frame_cs(&frame_lock_); |
pbos@webrtc.org | d60d79a | 2014-09-24 07:10:57 +0000 | [diff] [blame^] | 1384 | ConvertToI420VideoFrame(*frame, &video_frame_); |
| 1385 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1386 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1387 | if (stream_ == NULL) { |
| 1388 | LOG(LS_WARNING) << "Capturer inputting frames before send codecs are " |
| 1389 | "configured, dropping."; |
| 1390 | return; |
| 1391 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1392 | if (format_.width == 0) { // Dropping frames. |
| 1393 | assert(format_.height == 0); |
| 1394 | LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame."; |
| 1395 | return; |
| 1396 | } |
pbos@webrtc.org | d60d79a | 2014-09-24 07:10:57 +0000 | [diff] [blame^] | 1397 | if (muted_) { |
| 1398 | // Create a black frame to transmit instead. |
| 1399 | CreateBlackFrame(&video_frame_, |
| 1400 | static_cast<int>(frame->GetWidth()), |
| 1401 | static_cast<int>(frame->GetHeight())); |
| 1402 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1403 | // Reconfigure codec if necessary. |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1404 | SetDimensions( |
| 1405 | video_frame_.width(), video_frame_.height(), capturer->IsScreencast()); |
| 1406 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1407 | LOG(LS_VERBOSE) << "SwapFrame: " << video_frame_.width() << "x" |
| 1408 | << video_frame_.height() << " -> (codec) " |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1409 | << parameters_.encoder_config.streams.back().width << "x" |
| 1410 | << parameters_.encoder_config.streams.back().height; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1411 | stream_->Input()->SwapFrame(&video_frame_); |
| 1412 | } |
| 1413 | |
| 1414 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer( |
| 1415 | VideoCapturer* capturer) { |
| 1416 | if (!DisconnectCapturer() && capturer == NULL) { |
| 1417 | return false; |
| 1418 | } |
| 1419 | |
| 1420 | { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1421 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1422 | |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1423 | if (capturer == NULL) { |
| 1424 | if (stream_ != NULL) { |
| 1425 | LOG(LS_VERBOSE) << "Disabling capturer, sending black frame."; |
| 1426 | webrtc::I420VideoFrame black_frame; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1427 | |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1428 | int width = format_.width; |
| 1429 | int height = format_.height; |
| 1430 | int half_width = (width + 1) / 2; |
| 1431 | black_frame.CreateEmptyFrame( |
| 1432 | width, height, width, half_width, half_width); |
| 1433 | SetWebRtcFrameToBlack(&black_frame); |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1434 | SetDimensions(width, height, false); |
pbos@webrtc.org | 9359cb3 | 2014-07-23 15:44:48 +0000 | [diff] [blame] | 1435 | stream_->Input()->SwapFrame(&black_frame); |
| 1436 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1437 | |
| 1438 | capturer_ = NULL; |
| 1439 | return true; |
| 1440 | } |
| 1441 | |
| 1442 | capturer_ = capturer; |
| 1443 | } |
| 1444 | // Lock cannot be held while connecting the capturer to prevent lock-order |
| 1445 | // violations. |
| 1446 | capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame); |
| 1447 | return true; |
| 1448 | } |
| 1449 | |
| 1450 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat( |
| 1451 | const VideoFormat& format) { |
| 1452 | if ((format.width == 0 || format.height == 0) && |
| 1453 | format.width != format.height) { |
| 1454 | LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not " |
| 1455 | "both, 0x0 drops frames)."; |
| 1456 | return false; |
| 1457 | } |
| 1458 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1459 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1460 | if (format.width == 0 && format.height == 0) { |
| 1461 | LOG(LS_INFO) |
| 1462 | << "0x0 resolution selected. Captured frames will be dropped for ssrc: " |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1463 | << parameters_.config.rtp.ssrcs[0] << "."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1464 | } else { |
| 1465 | // TODO(pbos): Fix me, this only affects the last stream! |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1466 | parameters_.encoder_config.streams.back().max_framerate = |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1467 | VideoFormat::IntervalToFps(format.interval); |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1468 | SetDimensions(format.width, format.height, false); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1469 | } |
| 1470 | |
| 1471 | format_ = format; |
| 1472 | return true; |
| 1473 | } |
| 1474 | |
pbos@webrtc.org | ef8bb8d | 2014-08-13 21:36:18 +0000 | [diff] [blame] | 1475 | void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1476 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1477 | muted_ = mute; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1478 | } |
| 1479 | |
| 1480 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1481 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1482 | if (capturer_ == NULL) { |
| 1483 | return false; |
| 1484 | } |
| 1485 | capturer_->SignalVideoFrame.disconnect(this); |
| 1486 | capturer_ = NULL; |
| 1487 | return true; |
| 1488 | } |
| 1489 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1490 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions( |
| 1491 | const VideoOptions& options) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1492 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1493 | VideoCodecSettings codec_settings; |
| 1494 | if (parameters_.codec_settings.Get(&codec_settings)) { |
| 1495 | SetCodecAndOptions(codec_settings, options); |
| 1496 | } else { |
| 1497 | parameters_.options = options; |
| 1498 | } |
| 1499 | } |
| 1500 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec( |
| 1501 | const VideoCodecSettings& codec_settings) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1502 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1503 | SetCodecAndOptions(codec_settings, parameters_.options); |
| 1504 | } |
| 1505 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions( |
| 1506 | const VideoCodecSettings& codec_settings, |
| 1507 | const VideoOptions& options) { |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1508 | std::vector<webrtc::VideoStream> video_streams = |
| 1509 | encoder_factory_->CreateVideoStreams( |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1510 | codec_settings.codec, options, parameters_.config.rtp.ssrcs.size()); |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1511 | if (video_streams.empty()) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1512 | return; |
| 1513 | } |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1514 | parameters_.encoder_config.streams = video_streams; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1515 | format_ = VideoFormat(codec_settings.codec.width, |
| 1516 | codec_settings.codec.height, |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1517 | VideoFormat::FpsToInterval(30), |
| 1518 | FOURCC_I420); |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1519 | |
| 1520 | webrtc::VideoEncoder* old_encoder = |
| 1521 | parameters_.config.encoder_settings.encoder; |
| 1522 | parameters_.config.encoder_settings.encoder = |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1523 | encoder_factory_->CreateVideoEncoder(codec_settings.codec, options); |
| 1524 | parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; |
| 1525 | parameters_.config.encoder_settings.payload_type = codec_settings.codec.id; |
| 1526 | parameters_.config.rtp.fec = codec_settings.fec; |
| 1527 | |
| 1528 | // Set RTX payload type if RTX is enabled. |
| 1529 | if (!parameters_.config.rtp.rtx.ssrcs.empty()) { |
| 1530 | parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; |
pbos@webrtc.org | 543e589 | 2014-07-23 07:01:31 +0000 | [diff] [blame] | 1531 | |
| 1532 | options.use_payload_padding.Get( |
| 1533 | ¶meters_.config.rtp.rtx.pad_with_redundant_payloads); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1534 | } |
| 1535 | |
| 1536 | if (IsNackEnabled(codec_settings.codec)) { |
| 1537 | parameters_.config.rtp.nack.rtp_history_ms = kNackHistoryMs; |
| 1538 | } |
| 1539 | |
pbos@webrtc.org | 5ff71ab | 2014-07-23 07:28:56 +0000 | [diff] [blame] | 1540 | options.suspend_below_min_bitrate.Get( |
| 1541 | ¶meters_.config.suspend_below_min_bitrate); |
| 1542 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1543 | parameters_.codec_settings.Set(codec_settings); |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1544 | parameters_.options = options; |
pbos@webrtc.org | 543e589 | 2014-07-23 07:01:31 +0000 | [diff] [blame] | 1545 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1546 | RecreateWebRtcStream(); |
| 1547 | delete old_encoder; |
| 1548 | } |
| 1549 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1550 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions( |
| 1551 | const std::vector<webrtc::RtpExtension>& rtp_extensions) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1552 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1553 | parameters_.config.rtp.extensions = rtp_extensions; |
| 1554 | RecreateWebRtcStream(); |
| 1555 | } |
| 1556 | |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1557 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions( |
| 1558 | int width, |
| 1559 | int height, |
| 1560 | bool override_max) { |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1561 | assert(!parameters_.encoder_config.streams.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1562 | LOG(LS_VERBOSE) << "SetDimensions: " << width << "x" << height; |
pbos@webrtc.org | c4175b9 | 2014-09-03 15:25:49 +0000 | [diff] [blame] | 1563 | |
| 1564 | VideoCodecSettings codec_settings; |
| 1565 | parameters_.codec_settings.Get(&codec_settings); |
| 1566 | // Restrict dimensions according to codec max. |
| 1567 | if (!override_max) { |
| 1568 | if (codec_settings.codec.width < width) |
| 1569 | width = codec_settings.codec.width; |
| 1570 | if (codec_settings.codec.height < height) |
| 1571 | height = codec_settings.codec.height; |
| 1572 | } |
| 1573 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1574 | if (parameters_.encoder_config.streams.back().width == width && |
| 1575 | parameters_.encoder_config.streams.back().height == height) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1576 | return; |
| 1577 | } |
| 1578 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1579 | webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config; |
| 1580 | encoder_config.encoder_specific_settings = |
| 1581 | encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec, |
| 1582 | parameters_.options); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1583 | |
pbos@webrtc.org | cddd17c | 2014-09-16 16:33:13 +0000 | [diff] [blame] | 1584 | VideoCodec codec = codec_settings.codec; |
| 1585 | codec.width = width; |
| 1586 | codec.height = height; |
pbos@webrtc.org | cddd17c | 2014-09-16 16:33:13 +0000 | [diff] [blame] | 1587 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1588 | encoder_config.streams = encoder_factory_->CreateVideoStreams( |
| 1589 | codec, parameters_.options, parameters_.config.rtp.ssrcs.size()); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1590 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1591 | bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config); |
| 1592 | |
| 1593 | encoder_factory_->DestroyVideoEncoderSettings( |
| 1594 | codec_settings.codec, |
| 1595 | encoder_config.encoder_specific_settings); |
| 1596 | |
| 1597 | encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1598 | |
| 1599 | if (!stream_reconfigured) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1600 | LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: " |
| 1601 | << width << "x" << height; |
| 1602 | return; |
| 1603 | } |
pbos@webrtc.org | cddd17c | 2014-09-16 16:33:13 +0000 | [diff] [blame] | 1604 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1605 | parameters_.encoder_config = encoder_config; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1606 | } |
| 1607 | |
| 1608 | void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1609 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1610 | assert(stream_ != NULL); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1611 | stream_->Start(); |
| 1612 | sending_ = true; |
| 1613 | } |
| 1614 | |
| 1615 | void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1616 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1617 | if (stream_ != NULL) { |
| 1618 | stream_->Stop(); |
| 1619 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1620 | sending_ = false; |
| 1621 | } |
| 1622 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1623 | VideoSenderInfo |
| 1624 | WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() { |
| 1625 | VideoSenderInfo info; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1626 | rtc::CritScope cs(&lock_); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1627 | for (size_t i = 0; i < parameters_.config.rtp.ssrcs.size(); ++i) { |
| 1628 | info.add_ssrc(parameters_.config.rtp.ssrcs[i]); |
| 1629 | } |
| 1630 | |
pbos@webrtc.org | c3d2bd2 | 2014-08-12 20:55:10 +0000 | [diff] [blame] | 1631 | if (stream_ == NULL) { |
| 1632 | return info; |
| 1633 | } |
| 1634 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1635 | webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
| 1636 | info.framerate_input = stats.input_frame_rate; |
| 1637 | info.framerate_sent = stats.encode_frame_rate; |
| 1638 | |
| 1639 | for (std::map<uint32_t, webrtc::StreamStats>::iterator it = |
| 1640 | stats.substreams.begin(); |
| 1641 | it != stats.substreams.end(); |
| 1642 | ++it) { |
| 1643 | // TODO(pbos): Wire up additional stats, such as padding bytes. |
| 1644 | webrtc::StreamStats stream_stats = it->second; |
| 1645 | info.bytes_sent += stream_stats.rtp_stats.bytes + |
| 1646 | stream_stats.rtp_stats.header_bytes + |
| 1647 | stream_stats.rtp_stats.padding_bytes; |
| 1648 | info.packets_sent += stream_stats.rtp_stats.packets; |
| 1649 | info.packets_lost += stream_stats.rtcp_stats.cumulative_lost; |
| 1650 | } |
| 1651 | |
| 1652 | if (!stats.substreams.empty()) { |
| 1653 | // TODO(pbos): Report fraction lost per SSRC. |
| 1654 | webrtc::StreamStats first_stream_stats = stats.substreams.begin()->second; |
| 1655 | info.fraction_lost = |
| 1656 | static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) / |
| 1657 | (1 << 8); |
| 1658 | } |
| 1659 | |
| 1660 | if (capturer_ != NULL && !capturer_->IsMuted()) { |
| 1661 | VideoFormat last_captured_frame_format; |
| 1662 | capturer_->GetStats(&info.adapt_frame_drops, |
| 1663 | &info.effects_frame_drops, |
| 1664 | &info.capturer_frame_time, |
| 1665 | &last_captured_frame_format); |
| 1666 | info.input_frame_width = last_captured_frame_format.width; |
| 1667 | info.input_frame_height = last_captured_frame_format.height; |
| 1668 | info.send_frame_width = |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1669 | static_cast<int>(parameters_.encoder_config.streams.front().width); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1670 | info.send_frame_height = |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1671 | static_cast<int>(parameters_.encoder_config.streams.front().height); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1672 | } |
| 1673 | |
| 1674 | // TODO(pbos): Support or remove the following stats. |
| 1675 | info.packets_cached = -1; |
| 1676 | info.rtt_ms = -1; |
| 1677 | |
| 1678 | return info; |
| 1679 | } |
| 1680 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1681 | void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() { |
| 1682 | if (stream_ != NULL) { |
| 1683 | call_->DestroyVideoSendStream(stream_); |
| 1684 | } |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1685 | |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1686 | VideoCodecSettings codec_settings; |
| 1687 | parameters_.codec_settings.Get(&codec_settings); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1688 | parameters_.encoder_config.encoder_specific_settings = |
| 1689 | encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec, |
| 1690 | parameters_.options); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1691 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1692 | stream_ = call_->CreateVideoSendStream(parameters_.config, |
| 1693 | parameters_.encoder_config); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1694 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1695 | encoder_factory_->DestroyVideoEncoderSettings( |
| 1696 | codec_settings.codec, |
| 1697 | parameters_.encoder_config.encoder_specific_settings); |
| 1698 | |
| 1699 | parameters_.encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1700 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1701 | if (sending_) { |
| 1702 | stream_->Start(); |
| 1703 | } |
| 1704 | } |
| 1705 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1706 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
| 1707 | webrtc::Call* call, |
| 1708 | const webrtc::VideoReceiveStream::Config& config, |
| 1709 | const std::vector<VideoCodecSettings>& recv_codecs) |
| 1710 | : call_(call), |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1711 | stream_(NULL), |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 1712 | config_(config), |
| 1713 | renderer_(NULL), |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1714 | last_width_(-1), |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 1715 | last_height_(-1) { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1716 | config_.renderer = this; |
| 1717 | // SetRecvCodecs will also reset (start) the VideoReceiveStream. |
| 1718 | SetRecvCodecs(recv_codecs); |
| 1719 | } |
| 1720 | |
| 1721 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
| 1722 | call_->DestroyVideoReceiveStream(stream_); |
| 1723 | } |
| 1724 | |
| 1725 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs( |
| 1726 | const std::vector<VideoCodecSettings>& recv_codecs) { |
| 1727 | // TODO(pbos): Reconfigure RTX based on incoming recv_codecs. |
| 1728 | // TODO(pbos): Base receive codecs off recv_codecs_ and set up using a |
| 1729 | // DecoderFactory similar to send side. Pending webrtc:2854. |
| 1730 | // Also set up default codecs if there's nothing in recv_codecs_. |
| 1731 | webrtc::VideoCodec codec; |
| 1732 | memset(&codec, 0, sizeof(codec)); |
| 1733 | |
| 1734 | codec.plType = kDefaultVideoCodecPref.payload_type; |
| 1735 | strcpy(codec.plName, kDefaultVideoCodecPref.name); |
| 1736 | codec.codecType = webrtc::kVideoCodecVP8; |
| 1737 | codec.codecSpecific.VP8.resilience = webrtc::kResilientStream; |
| 1738 | codec.codecSpecific.VP8.numberOfTemporalLayers = 1; |
| 1739 | codec.codecSpecific.VP8.denoisingOn = true; |
| 1740 | codec.codecSpecific.VP8.errorConcealmentOn = false; |
| 1741 | codec.codecSpecific.VP8.automaticResizeOn = false; |
| 1742 | codec.codecSpecific.VP8.frameDroppingOn = true; |
| 1743 | codec.codecSpecific.VP8.keyFrameInterval = 3000; |
| 1744 | // Bitrates don't matter and are ignored for the receiver. This is put in to |
| 1745 | // have the current underlying implementation accept the VideoCodec. |
| 1746 | codec.minBitrate = codec.startBitrate = codec.maxBitrate = 300; |
| 1747 | config_.codecs.clear(); |
| 1748 | config_.codecs.push_back(codec); |
| 1749 | |
| 1750 | config_.rtp.fec = recv_codecs.front().fec; |
| 1751 | |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1752 | config_.rtp.nack.rtp_history_ms = |
| 1753 | IsNackEnabled(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; |
| 1754 | config_.rtp.remb = IsRembEnabled(recv_codecs.begin()->codec); |
| 1755 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1756 | RecreateWebRtcStream(); |
| 1757 | } |
| 1758 | |
| 1759 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions( |
| 1760 | const std::vector<webrtc::RtpExtension>& extensions) { |
| 1761 | config_.rtp.extensions = extensions; |
| 1762 | RecreateWebRtcStream(); |
| 1763 | } |
| 1764 | |
| 1765 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() { |
| 1766 | if (stream_ != NULL) { |
| 1767 | call_->DestroyVideoReceiveStream(stream_); |
| 1768 | } |
| 1769 | stream_ = call_->CreateVideoReceiveStream(config_); |
| 1770 | stream_->Start(); |
| 1771 | } |
| 1772 | |
| 1773 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame( |
| 1774 | const webrtc::I420VideoFrame& frame, |
| 1775 | int time_to_render_ms) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1776 | rtc::CritScope crit(&renderer_lock_); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1777 | if (renderer_ == NULL) { |
| 1778 | LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer."; |
| 1779 | return; |
| 1780 | } |
| 1781 | |
| 1782 | if (frame.width() != last_width_ || frame.height() != last_height_) { |
| 1783 | SetSize(frame.width(), frame.height()); |
| 1784 | } |
| 1785 | |
| 1786 | LOG(LS_VERBOSE) << "RenderFrame: (" << frame.width() << "x" << frame.height() |
| 1787 | << ")"; |
| 1788 | |
| 1789 | const WebRtcVideoRenderFrame render_frame(&frame); |
| 1790 | renderer_->RenderFrame(&render_frame); |
| 1791 | } |
| 1792 | |
| 1793 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer( |
| 1794 | cricket::VideoRenderer* renderer) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1795 | rtc::CritScope crit(&renderer_lock_); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1796 | renderer_ = renderer; |
| 1797 | if (renderer_ != NULL && last_width_ != -1) { |
| 1798 | SetSize(last_width_, last_height_); |
| 1799 | } |
| 1800 | } |
| 1801 | |
| 1802 | VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() { |
| 1803 | // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by |
| 1804 | // design. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1805 | rtc::CritScope crit(&renderer_lock_); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1806 | return renderer_; |
| 1807 | } |
| 1808 | |
| 1809 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width, |
| 1810 | int height) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1811 | rtc::CritScope crit(&renderer_lock_); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1812 | if (!renderer_->SetSize(width, height, 0)) { |
| 1813 | LOG(LS_ERROR) << "Could not set renderer size."; |
| 1814 | } |
| 1815 | last_width_ = width; |
| 1816 | last_height_ = height; |
| 1817 | } |
| 1818 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1819 | VideoReceiverInfo |
| 1820 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() { |
| 1821 | VideoReceiverInfo info; |
| 1822 | info.add_ssrc(config_.rtp.remote_ssrc); |
| 1823 | webrtc::VideoReceiveStream::Stats stats = stream_->GetStats(); |
| 1824 | info.bytes_rcvd = stats.rtp_stats.bytes + stats.rtp_stats.header_bytes + |
| 1825 | stats.rtp_stats.padding_bytes; |
| 1826 | info.packets_rcvd = stats.rtp_stats.packets; |
| 1827 | |
| 1828 | info.framerate_rcvd = stats.network_frame_rate; |
| 1829 | info.framerate_decoded = stats.decode_frame_rate; |
| 1830 | info.framerate_output = stats.render_frame_rate; |
| 1831 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1832 | rtc::CritScope frame_cs(&renderer_lock_); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1833 | info.frame_width = last_width_; |
| 1834 | info.frame_height = last_height_; |
| 1835 | |
| 1836 | // TODO(pbos): Support or remove the following stats. |
| 1837 | info.packets_concealed = -1; |
| 1838 | |
| 1839 | return info; |
| 1840 | } |
| 1841 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1842 | WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings() |
| 1843 | : rtx_payload_type(-1) {} |
| 1844 | |
| 1845 | std::vector<WebRtcVideoChannel2::VideoCodecSettings> |
| 1846 | WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) { |
| 1847 | assert(!codecs.empty()); |
| 1848 | |
| 1849 | std::vector<VideoCodecSettings> video_codecs; |
| 1850 | std::map<int, bool> payload_used; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1851 | std::map<int, VideoCodec::CodecType> payload_codec_type; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1852 | std::map<int, int> rtx_mapping; // video payload type -> rtx payload type. |
| 1853 | |
| 1854 | webrtc::FecConfig fec_settings; |
| 1855 | |
| 1856 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 1857 | const VideoCodec& in_codec = codecs[i]; |
| 1858 | int payload_type = in_codec.id; |
| 1859 | |
| 1860 | if (payload_used[payload_type]) { |
| 1861 | LOG(LS_ERROR) << "Payload type already registered: " |
| 1862 | << in_codec.ToString(); |
| 1863 | return std::vector<VideoCodecSettings>(); |
| 1864 | } |
| 1865 | payload_used[payload_type] = true; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1866 | payload_codec_type[payload_type] = in_codec.GetCodecType(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1867 | |
| 1868 | switch (in_codec.GetCodecType()) { |
| 1869 | case VideoCodec::CODEC_RED: { |
| 1870 | // RED payload type, should not have duplicates. |
| 1871 | assert(fec_settings.red_payload_type == -1); |
| 1872 | fec_settings.red_payload_type = in_codec.id; |
| 1873 | continue; |
| 1874 | } |
| 1875 | |
| 1876 | case VideoCodec::CODEC_ULPFEC: { |
| 1877 | // ULPFEC payload type, should not have duplicates. |
| 1878 | assert(fec_settings.ulpfec_payload_type == -1); |
| 1879 | fec_settings.ulpfec_payload_type = in_codec.id; |
| 1880 | continue; |
| 1881 | } |
| 1882 | |
| 1883 | case VideoCodec::CODEC_RTX: { |
| 1884 | int associated_payload_type; |
| 1885 | if (!in_codec.GetParam(kCodecParamAssociatedPayloadType, |
| 1886 | &associated_payload_type)) { |
| 1887 | LOG(LS_ERROR) << "RTX codec without associated payload type: " |
| 1888 | << in_codec.ToString(); |
| 1889 | return std::vector<VideoCodecSettings>(); |
| 1890 | } |
| 1891 | rtx_mapping[associated_payload_type] = in_codec.id; |
| 1892 | continue; |
| 1893 | } |
| 1894 | |
| 1895 | case VideoCodec::CODEC_VIDEO: |
| 1896 | break; |
| 1897 | } |
| 1898 | |
| 1899 | video_codecs.push_back(VideoCodecSettings()); |
| 1900 | video_codecs.back().codec = in_codec; |
| 1901 | } |
| 1902 | |
| 1903 | // One of these codecs should have been a video codec. Only having FEC |
| 1904 | // parameters into this code is a logic error. |
| 1905 | assert(!video_codecs.empty()); |
| 1906 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 1907 | for (std::map<int, int>::const_iterator it = rtx_mapping.begin(); |
| 1908 | it != rtx_mapping.end(); |
| 1909 | ++it) { |
| 1910 | if (!payload_used[it->first]) { |
| 1911 | LOG(LS_ERROR) << "RTX mapped to payload not in codec list."; |
| 1912 | return std::vector<VideoCodecSettings>(); |
| 1913 | } |
| 1914 | if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO) { |
| 1915 | LOG(LS_ERROR) << "RTX not mapped to regular video codec."; |
| 1916 | return std::vector<VideoCodecSettings>(); |
| 1917 | } |
| 1918 | } |
| 1919 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1920 | // TODO(pbos): Write tests that figure out that I have not verified that RTX |
| 1921 | // codecs aren't mapped to bogus payloads. |
| 1922 | for (size_t i = 0; i < video_codecs.size(); ++i) { |
| 1923 | video_codecs[i].fec = fec_settings; |
| 1924 | if (rtx_mapping[video_codecs[i].codec.id] != 0) { |
| 1925 | video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id]; |
| 1926 | } |
| 1927 | } |
| 1928 | |
| 1929 | return video_codecs; |
| 1930 | } |
| 1931 | |
| 1932 | std::vector<WebRtcVideoChannel2::VideoCodecSettings> |
| 1933 | WebRtcVideoChannel2::FilterSupportedCodecs( |
| 1934 | const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs) { |
| 1935 | std::vector<VideoCodecSettings> supported_codecs; |
| 1936 | for (size_t i = 0; i < mapped_codecs.size(); ++i) { |
| 1937 | if (encoder_factory_->SupportsCodec(mapped_codecs[i].codec)) { |
| 1938 | supported_codecs.push_back(mapped_codecs[i]); |
| 1939 | } |
| 1940 | } |
| 1941 | return supported_codecs; |
| 1942 | } |
| 1943 | |
| 1944 | } // namespace cricket |
| 1945 | |
| 1946 | #endif // HAVE_WEBRTC_VIDEO |