1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/video_engine/vie_codec_impl.h"
12
13 #include <list>
14
15 #include "webrtc/engine_configurations.h"
16 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
17 #include "webrtc/system_wrappers/interface/logging.h"
18 #include "webrtc/video_engine/include/vie_errors.h"
19 #include "webrtc/video_engine/vie_capturer.h"
20 #include "webrtc/video_engine/vie_channel.h"
21 #include "webrtc/video_engine/vie_channel_manager.h"
22 #include "webrtc/video_engine/vie_defines.h"
23 #include "webrtc/video_engine/vie_encoder.h"
24 #include "webrtc/video_engine/vie_impl.h"
25 #include "webrtc/video_engine/vie_input_manager.h"
26 #include "webrtc/video_engine/vie_shared_data.h"
27
28 namespace webrtc {
29
LogCodec(const VideoCodec & codec)30 static void LogCodec(const VideoCodec& codec) {
31 LOG(LS_INFO) << "CodecType " << codec.codecType
32 << ", pl_type " << static_cast<int>(codec.plType)
33 << ", resolution " << codec.width
34 << " x " << codec.height
35 << ", start br " << codec.startBitrate
36 << ", min br " << codec.minBitrate
37 << ", max br " << codec.maxBitrate
38 << ", max fps " << static_cast<int>(codec.maxFramerate)
39 << ", max qp " << codec.qpMax
40 << ", number of streams "
41 << static_cast<int>(codec.numberOfSimulcastStreams);
42 if (codec.codecType == kVideoCodecVP8) {
43 LOG(LS_INFO) << "VP8 specific settings";
44 LOG(LS_INFO) << "pictureLossIndicationOn "
45 << codec.codecSpecific.VP8.pictureLossIndicationOn
46 << ", feedbackModeOn "
47 << codec.codecSpecific.VP8.feedbackModeOn
48 << ", complexity "
49 << codec.codecSpecific.VP8.complexity
50 << ", resilience "
51 << codec.codecSpecific.VP8.resilience
52 << ", numberOfTemporalLayers "
53 << static_cast<int>(
54 codec.codecSpecific.VP8.numberOfTemporalLayers)
55 << ", keyFrameinterval "
56 << codec.codecSpecific.VP8.keyFrameInterval;
57 for (int idx = 0; idx < codec.numberOfSimulcastStreams; ++idx) {
58 LOG(LS_INFO) << "Stream " << codec.simulcastStream[idx].width
59 << " x " << codec.simulcastStream[idx].height;
60 LOG(LS_INFO) << "Temporal layers "
61 << static_cast<int>(
62 codec.simulcastStream[idx].numberOfTemporalLayers)
63 << ", min br "
64 << codec.simulcastStream[idx].minBitrate
65 << ", target br "
66 << codec.simulcastStream[idx].targetBitrate
67 << ", max br "
68 << codec.simulcastStream[idx].maxBitrate
69 << ", qp max "
70 << codec.simulcastStream[idx].qpMax;
71 }
72 }
73 }
74
75
GetInterface(VideoEngine * video_engine)76 ViECodec* ViECodec::GetInterface(VideoEngine* video_engine) {
77 #ifdef WEBRTC_VIDEO_ENGINE_CODEC_API
78 if (!video_engine) {
79 return NULL;
80 }
81 VideoEngineImpl* vie_impl = static_cast<VideoEngineImpl*>(video_engine);
82 ViECodecImpl* vie_codec_impl = vie_impl;
83 // Increase ref count.
84 (*vie_codec_impl)++;
85 return vie_codec_impl;
86 #else
87 return NULL;
88 #endif
89 }
90
Release()91 int ViECodecImpl::Release() {
92 LOG(LS_INFO) << "ViECodec::Release.";
93 // Decrease ref count.
94 (*this)--;
95
96 int32_t ref_count = GetCount();
97 if (ref_count < 0) {
98 LOG(LS_WARNING) << "ViECodec released too many times.";
99 shared_data_->SetLastError(kViEAPIDoesNotExist);
100 return -1;
101 }
102 return ref_count;
103 }
104
ViECodecImpl(ViESharedData * shared_data)105 ViECodecImpl::ViECodecImpl(ViESharedData* shared_data)
106 : shared_data_(shared_data) {
107 }
108
~ViECodecImpl()109 ViECodecImpl::~ViECodecImpl() {
110 }
111
NumberOfCodecs() const112 int ViECodecImpl::NumberOfCodecs() const {
113 // +2 because of FEC(RED and ULPFEC)
114 return static_cast<int>((VideoCodingModule::NumberOfCodecs() + 2));
115 }
116
GetCodec(const unsigned char list_number,VideoCodec & video_codec) const117 int ViECodecImpl::GetCodec(const unsigned char list_number,
118 VideoCodec& video_codec) const {
119 if (list_number == VideoCodingModule::NumberOfCodecs()) {
120 memset(&video_codec, 0, sizeof(VideoCodec));
121 strcpy(video_codec.plName, "red");
122 video_codec.codecType = kVideoCodecRED;
123 video_codec.plType = VCM_RED_PAYLOAD_TYPE;
124 } else if (list_number == VideoCodingModule::NumberOfCodecs() + 1) {
125 memset(&video_codec, 0, sizeof(VideoCodec));
126 strcpy(video_codec.plName, "ulpfec");
127 video_codec.codecType = kVideoCodecULPFEC;
128 video_codec.plType = VCM_ULPFEC_PAYLOAD_TYPE;
129 } else if (VideoCodingModule::Codec(list_number, &video_codec) != VCM_OK) {
130 shared_data_->SetLastError(kViECodecInvalidArgument);
131 return -1;
132 }
133 return 0;
134 }
135
SetSendCodec(const int video_channel,const VideoCodec & video_codec)136 int ViECodecImpl::SetSendCodec(const int video_channel,
137 const VideoCodec& video_codec) {
138 LOG(LS_INFO) << "SetSendCodec for channel " << video_channel;
139 LogCodec(video_codec);
140 if (!CodecValid(video_codec)) {
141 // Error logged.
142 shared_data_->SetLastError(kViECodecInvalidCodec);
143 return -1;
144 }
145
146 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
147 ViEChannel* vie_channel = cs.Channel(video_channel);
148 if (!vie_channel) {
149 shared_data_->SetLastError(kViECodecInvalidChannelId);
150 return -1;
151 }
152
153 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
154 assert(vie_encoder);
155 if (vie_encoder->Owner() != video_channel) {
156 LOG_F(LS_ERROR) << "Receive only channel.";
157 shared_data_->SetLastError(kViECodecReceiveOnlyChannel);
158 return -1;
159 }
160 // Set a max_bitrate if the user hasn't set one.
161 VideoCodec video_codec_internal;
162 memcpy(&video_codec_internal, &video_codec, sizeof(VideoCodec));
163 if (video_codec_internal.maxBitrate == 0) {
164 // Max is one bit per pixel.
165 video_codec_internal.maxBitrate = (video_codec_internal.width *
166 video_codec_internal.height *
167 video_codec_internal.maxFramerate)
168 / 1000;
169 LOG(LS_INFO) << "New max bitrate set " << video_codec_internal.maxBitrate;
170 }
171
172 if (video_codec_internal.startBitrate < video_codec_internal.minBitrate) {
173 video_codec_internal.startBitrate = video_codec_internal.minBitrate;
174 }
175 if (video_codec_internal.startBitrate > video_codec_internal.maxBitrate) {
176 video_codec_internal.startBitrate = video_codec_internal.maxBitrate;
177 }
178
179 VideoCodec encoder;
180 vie_encoder->GetEncoder(&encoder);
181
182 // Make sure to generate a new SSRC if the codec type and/or resolution has
183 // changed. This won't have any effect if the user has set an SSRC.
184 bool new_rtp_stream = false;
185 if (encoder.codecType != video_codec_internal.codecType) {
186 new_rtp_stream = true;
187 }
188
189 ViEInputManagerScoped is(*(shared_data_->input_manager()));
190
191 // Stop the media flow while reconfiguring.
192 vie_encoder->Pause();
193
194 if (vie_encoder->SetEncoder(video_codec_internal) != 0) {
195 shared_data_->SetLastError(kViECodecUnknownError);
196 return -1;
197 }
198
199 // Give the channel(s) the new information.
200 ChannelList channels;
201 cs.ChannelsUsingViEEncoder(video_channel, &channels);
202 for (ChannelList::iterator it = channels.begin(); it != channels.end();
203 ++it) {
204 bool ret = true;
205 if ((*it)->SetSendCodec(video_codec_internal, new_rtp_stream) != 0) {
206 ret = false;
207 }
208 if (!ret) {
209 shared_data_->SetLastError(kViECodecUnknownError);
210 return -1;
211 }
212 }
213
214 // TODO(mflodman) Break out this part in GetLocalSsrcList().
215 // Update all SSRCs to ViEEncoder.
216 std::list<unsigned int> ssrcs;
217 if (video_codec_internal.numberOfSimulcastStreams == 0) {
218 unsigned int ssrc = 0;
219 if (vie_channel->GetLocalSSRC(0, &ssrc) != 0) {
220 LOG_F(LS_ERROR) << "Could not get ssrc.";
221 }
222 ssrcs.push_back(ssrc);
223 } else {
224 for (int idx = 0; idx < video_codec_internal.numberOfSimulcastStreams;
225 ++idx) {
226 unsigned int ssrc = 0;
227 if (vie_channel->GetLocalSSRC(idx, &ssrc) != 0) {
228 LOG_F(LS_ERROR) << "Could not get ssrc for stream " << idx;
229 }
230 ssrcs.push_back(ssrc);
231 }
232 }
233 vie_encoder->SetSsrcs(ssrcs);
234 shared_data_->channel_manager()->UpdateSsrcs(video_channel, ssrcs);
235
236 // Update the protection mode, we might be switching NACK/FEC.
237 vie_encoder->UpdateProtectionMethod(vie_encoder->nack_enabled());
238
239 // Get new best format for frame provider.
240 ViEFrameProviderBase* frame_provider = is.FrameProvider(vie_encoder);
241 if (frame_provider) {
242 frame_provider->FrameCallbackChanged();
243 }
244 // Restart the media flow
245 if (new_rtp_stream) {
246 // Stream settings changed, make sure we get a key frame.
247 vie_encoder->SendKeyFrame();
248 }
249 vie_encoder->Restart();
250 return 0;
251 }
252
GetSendCodec(const int video_channel,VideoCodec & video_codec) const253 int ViECodecImpl::GetSendCodec(const int video_channel,
254 VideoCodec& video_codec) const {
255 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
256 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
257 if (!vie_encoder) {
258 shared_data_->SetLastError(kViECodecInvalidChannelId);
259 return -1;
260 }
261 return vie_encoder->GetEncoder(&video_codec);
262 }
263
SetReceiveCodec(const int video_channel,const VideoCodec & video_codec)264 int ViECodecImpl::SetReceiveCodec(const int video_channel,
265 const VideoCodec& video_codec) {
266 LOG(LS_INFO) << "SetReceiveCodec for channel " << video_channel;
267 LOG(LS_INFO) << "Codec type " << video_codec.codecType
268 << ", payload type " << video_codec.plType;
269
270 if (CodecValid(video_codec) == false) {
271 shared_data_->SetLastError(kViECodecInvalidCodec);
272 return -1;
273 }
274
275 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
276 ViEChannel* vie_channel = cs.Channel(video_channel);
277 if (!vie_channel) {
278 shared_data_->SetLastError(kViECodecInvalidChannelId);
279 return -1;
280 }
281
282 if (vie_channel->SetReceiveCodec(video_codec) != 0) {
283 shared_data_->SetLastError(kViECodecUnknownError);
284 return -1;
285 }
286 return 0;
287 }
288
GetReceiveCodec(const int video_channel,VideoCodec & video_codec) const289 int ViECodecImpl::GetReceiveCodec(const int video_channel,
290 VideoCodec& video_codec) const {
291 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
292 ViEChannel* vie_channel = cs.Channel(video_channel);
293 if (!vie_channel) {
294 shared_data_->SetLastError(kViECodecInvalidChannelId);
295 return -1;
296 }
297
298 if (vie_channel->GetReceiveCodec(&video_codec) != 0) {
299 shared_data_->SetLastError(kViECodecUnknownError);
300 return -1;
301 }
302 return 0;
303 }
304
GetCodecConfigParameters(const int video_channel,unsigned char config_parameters[kConfigParameterSize],unsigned char & config_parameters_size) const305 int ViECodecImpl::GetCodecConfigParameters(
306 const int video_channel,
307 unsigned char config_parameters[kConfigParameterSize],
308 unsigned char& config_parameters_size) const {
309 LOG(LS_INFO) << "GetCodecConfigParameters " << video_channel;
310
311 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
312 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
313 if (!vie_encoder) {
314 shared_data_->SetLastError(kViECodecInvalidChannelId);
315 return -1;
316 }
317
318 if (vie_encoder->GetCodecConfigParameters(config_parameters,
319 config_parameters_size) != 0) {
320 shared_data_->SetLastError(kViECodecUnknownError);
321 return -1;
322 }
323 return 0;
324 }
325
SetImageScaleStatus(const int video_channel,const bool enable)326 int ViECodecImpl::SetImageScaleStatus(const int video_channel,
327 const bool enable) {
328 LOG(LS_INFO) << "SetImageScaleStates for channel " << video_channel
329 << ", enable: " << enable;
330
331 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
332 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
333 if (!vie_encoder) {
334 shared_data_->SetLastError(kViECodecInvalidChannelId);
335 return -1;
336 }
337
338 if (vie_encoder->ScaleInputImage(enable) != 0) {
339 shared_data_->SetLastError(kViECodecUnknownError);
340 return -1;
341 }
342 return 0;
343 }
344
GetSendCodecStastistics(const int video_channel,unsigned int & key_frames,unsigned int & delta_frames) const345 int ViECodecImpl::GetSendCodecStastistics(const int video_channel,
346 unsigned int& key_frames,
347 unsigned int& delta_frames) const {
348 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
349 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
350 if (!vie_encoder) {
351 shared_data_->SetLastError(kViECodecInvalidChannelId);
352 return -1;
353 }
354
355 if (vie_encoder->SendCodecStatistics(&key_frames, &delta_frames) != 0) {
356 shared_data_->SetLastError(kViECodecUnknownError);
357 return -1;
358 }
359 return 0;
360 }
361
GetReceiveCodecStastistics(const int video_channel,unsigned int & key_frames,unsigned int & delta_frames) const362 int ViECodecImpl::GetReceiveCodecStastistics(const int video_channel,
363 unsigned int& key_frames,
364 unsigned int& delta_frames) const {
365 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
366 ViEChannel* vie_channel = cs.Channel(video_channel);
367 if (!vie_channel) {
368 shared_data_->SetLastError(kViECodecInvalidChannelId);
369 return -1;
370 }
371 if (vie_channel->ReceiveCodecStatistics(&key_frames, &delta_frames) != 0) {
372 shared_data_->SetLastError(kViECodecUnknownError);
373 return -1;
374 }
375 return 0;
376 }
377
GetReceiveSideDelay(const int video_channel,int * delay_ms) const378 int ViECodecImpl::GetReceiveSideDelay(const int video_channel,
379 int* delay_ms) const {
380 assert(delay_ms != NULL);
381
382 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
383 ViEChannel* vie_channel = cs.Channel(video_channel);
384 if (!vie_channel) {
385 shared_data_->SetLastError(kViECodecInvalidChannelId);
386 return -1;
387 }
388 *delay_ms = vie_channel->ReceiveDelay();
389 if (*delay_ms < 0) {
390 return -1;
391 }
392 return 0;
393 }
394
395
GetCodecTargetBitrate(const int video_channel,unsigned int * bitrate) const396 int ViECodecImpl::GetCodecTargetBitrate(const int video_channel,
397 unsigned int* bitrate) const {
398 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
399 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
400 if (!vie_encoder) {
401 shared_data_->SetLastError(kViECodecInvalidChannelId);
402 return -1;
403 }
404 return vie_encoder->CodecTargetBitrate(static_cast<uint32_t*>(bitrate));
405 }
406
GetDiscardedPackets(const int video_channel) const407 unsigned int ViECodecImpl::GetDiscardedPackets(const int video_channel) const {
408 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
409 ViEChannel* vie_channel = cs.Channel(video_channel);
410 if (!vie_channel) {
411 shared_data_->SetLastError(kViECodecInvalidChannelId);
412 return -1;
413 }
414 return vie_channel->DiscardedPackets();
415 }
416
SetKeyFrameRequestCallbackStatus(const int video_channel,const bool enable)417 int ViECodecImpl::SetKeyFrameRequestCallbackStatus(const int video_channel,
418 const bool enable) {
419 LOG(LS_INFO) << "SetKeyFrameRequestCallbackStatus for " << video_channel
420 << ", enacle " << enable;
421
422 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
423 ViEChannel* vie_channel = cs.Channel(video_channel);
424 if (!vie_channel) {
425 shared_data_->SetLastError(kViECodecInvalidChannelId);
426 return -1;
427 }
428 if (vie_channel->EnableKeyFrameRequestCallback(enable) != 0) {
429 shared_data_->SetLastError(kViECodecUnknownError);
430 return -1;
431 }
432 return 0;
433 }
434
SetSignalKeyPacketLossStatus(const int video_channel,const bool enable,const bool only_key_frames)435 int ViECodecImpl::SetSignalKeyPacketLossStatus(const int video_channel,
436 const bool enable,
437 const bool only_key_frames) {
438 LOG(LS_INFO) << "SetSignalKeyPacketLossStatus for " << video_channel
439 << "enable, " << enable
440 << ", only key frames " << only_key_frames;
441
442 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
443 ViEChannel* vie_channel = cs.Channel(video_channel);
444 if (!vie_channel) {
445 shared_data_->SetLastError(kViECodecInvalidChannelId);
446 return -1;
447 }
448 if (vie_channel->SetSignalPacketLossStatus(enable, only_key_frames) != 0) {
449 shared_data_->SetLastError(kViECodecUnknownError);
450 return -1;
451 }
452 return 0;
453 }
454
RegisterEncoderObserver(const int video_channel,ViEEncoderObserver & observer)455 int ViECodecImpl::RegisterEncoderObserver(const int video_channel,
456 ViEEncoderObserver& observer) {
457 LOG(LS_INFO) << "RegisterEncoderObserver for channel " << video_channel;
458
459 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
460 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
461 if (!vie_encoder) {
462 shared_data_->SetLastError(kViECodecInvalidChannelId);
463 return -1;
464 }
465 if (vie_encoder->RegisterCodecObserver(&observer) != 0) {
466 shared_data_->SetLastError(kViECodecObserverAlreadyRegistered);
467 return -1;
468 }
469 return 0;
470 }
471
DeregisterEncoderObserver(const int video_channel)472 int ViECodecImpl::DeregisterEncoderObserver(const int video_channel) {
473 LOG(LS_INFO) << "DeregisterEncoderObserver for channel " << video_channel;
474
475 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
476 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
477 if (!vie_encoder) {
478 shared_data_->SetLastError(kViECodecInvalidChannelId);
479 return -1;
480 }
481 if (vie_encoder->RegisterCodecObserver(NULL) != 0) {
482 shared_data_->SetLastError(kViECodecObserverNotRegistered);
483 return -1;
484 }
485 return 0;
486 }
487
RegisterDecoderObserver(const int video_channel,ViEDecoderObserver & observer)488 int ViECodecImpl::RegisterDecoderObserver(const int video_channel,
489 ViEDecoderObserver& observer) {
490 LOG(LS_INFO) << "RegisterDecoderObserver for channel " << video_channel;
491
492 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
493 ViEChannel* vie_channel = cs.Channel(video_channel);
494 if (!vie_channel) {
495 shared_data_->SetLastError(kViECodecInvalidChannelId);
496 return -1;
497 }
498 if (vie_channel->RegisterCodecObserver(&observer) != 0) {
499 shared_data_->SetLastError(kViECodecObserverAlreadyRegistered);
500 return -1;
501 }
502 return 0;
503 }
504
DeregisterDecoderObserver(const int video_channel)505 int ViECodecImpl::DeregisterDecoderObserver(const int video_channel) {
506 LOG(LS_INFO) << "DeregisterDecodeObserver for channel " << video_channel;
507
508 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
509 ViEChannel* vie_channel = cs.Channel(video_channel);
510 if (!vie_channel) {
511 shared_data_->SetLastError(kViECodecInvalidChannelId);
512 return -1;
513 }
514 if (vie_channel->RegisterCodecObserver(NULL) != 0) {
515 shared_data_->SetLastError(kViECodecObserverNotRegistered);
516 return -1;
517 }
518 return 0;
519 }
520
SendKeyFrame(const int video_channel)521 int ViECodecImpl::SendKeyFrame(const int video_channel) {
522 LOG(LS_INFO) << "SendKeyFrame on channel " << video_channel;
523
524 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
525 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
526 if (!vie_encoder) {
527 shared_data_->SetLastError(kViECodecInvalidChannelId);
528 return -1;
529 }
530 if (vie_encoder->SendKeyFrame() != 0) {
531 shared_data_->SetLastError(kViECodecUnknownError);
532 return -1;
533 }
534 return 0;
535 }
536
WaitForFirstKeyFrame(const int video_channel,const bool wait)537 int ViECodecImpl::WaitForFirstKeyFrame(const int video_channel,
538 const bool wait) {
539 LOG(LS_INFO) << "WaitForFirstKeyFrame for channel " << video_channel
540 << ", wait " << wait;
541
542 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
543 ViEChannel* vie_channel = cs.Channel(video_channel);
544 if (!vie_channel) {
545 shared_data_->SetLastError(kViECodecInvalidChannelId);
546 return -1;
547 }
548 if (vie_channel->WaitForKeyFrame(wait) != 0) {
549 shared_data_->SetLastError(kViECodecUnknownError);
550 return -1;
551 }
552 return 0;
553 }
554
StartDebugRecording(int video_channel,const char * file_name_utf8)555 int ViECodecImpl::StartDebugRecording(int video_channel,
556 const char* file_name_utf8) {
557 LOG(LS_INFO) << "StartDebugRecording for channel " << video_channel;
558 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
559 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
560 if (!vie_encoder) {
561 return -1;
562 }
563 return vie_encoder->StartDebugRecording(file_name_utf8);
564 }
565
StopDebugRecording(int video_channel)566 int ViECodecImpl::StopDebugRecording(int video_channel) {
567 LOG(LS_INFO) << "StopDebugRecording for channel " << video_channel;
568 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
569 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
570 if (!vie_encoder) {
571 return -1;
572 }
573 return vie_encoder->StopDebugRecording();
574 }
575
SuspendBelowMinBitrate(int video_channel)576 void ViECodecImpl::SuspendBelowMinBitrate(int video_channel) {
577 LOG(LS_INFO) << "SuspendBelowMinBitrate for channel " << video_channel;
578 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
579 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
580 if (!vie_encoder) {
581 return;
582 }
583 vie_encoder->SuspendBelowMinBitrate();
584 ViEChannel* vie_channel = cs.Channel(video_channel);
585 if (!vie_channel) {
586 return;
587 }
588 // Must enable pacing when enabling SuspendBelowMinBitrate. Otherwise, no
589 // padding will be sent when the video is suspended so the video will be
590 // unable to recover.
591 vie_channel->SetTransmissionSmoothingStatus(true);
592 }
593
GetSendSideDelay(int video_channel,int * avg_delay_ms,int * max_delay_ms) const594 bool ViECodecImpl::GetSendSideDelay(int video_channel, int* avg_delay_ms,
595 int* max_delay_ms) const {
596 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
597 ViEChannel* vie_channel = cs.Channel(video_channel);
598 if (!vie_channel) {
599 shared_data_->SetLastError(kViECodecInvalidChannelId);
600 return false;
601 }
602 return vie_channel->GetSendSideDelay(avg_delay_ms, max_delay_ms);
603 }
604
CodecValid(const VideoCodec & video_codec)605 bool ViECodecImpl::CodecValid(const VideoCodec& video_codec) {
606 // Check pl_name matches codec_type.
607 if (video_codec.codecType == kVideoCodecRED) {
608 #if defined(WIN32)
609 if (_strnicmp(video_codec.plName, "red", 3) == 0) {
610 #else
611 if (strncasecmp(video_codec.plName, "red", 3) == 0) {
612 #endif
613 // We only care about the type and name for red.
614 return true;
615 }
616 LOG_F(LS_ERROR) << "Invalid RED configuration.";
617 return false;
618 } else if (video_codec.codecType == kVideoCodecULPFEC) {
619 #if defined(WIN32)
620 if (_strnicmp(video_codec.plName, "ULPFEC", 6) == 0) {
621 #else
622 if (strncasecmp(video_codec.plName, "ULPFEC", 6) == 0) {
623 #endif
624 // We only care about the type and name for ULPFEC.
625 return true;
626 }
627 LOG_F(LS_ERROR) << "Invalid ULPFEC configuration.";
628 return false;
629 } else if ((video_codec.codecType == kVideoCodecVP8 &&
630 strncmp(video_codec.plName, "VP8", 4) == 0) ||
631 (video_codec.codecType == kVideoCodecI420 &&
632 strncmp(video_codec.plName, "I420", 4) == 0)) {
633 // OK.
634 } else if (video_codec.codecType != kVideoCodecGeneric) {
635 LOG(LS_ERROR) << "Codec type and name mismatch.";
636 return false;
637 }
638
639 if (video_codec.plType == 0 || video_codec.plType > 127) {
640 LOG(LS_ERROR) << "Invalif payload type: " << video_codec.plType;
641 return false;
642 }
643
644 if (video_codec.width > kViEMaxCodecWidth ||
645 video_codec.height > kViEMaxCodecHeight) {
646 LOG(LS_ERROR) << "Invalid codec resolution " << video_codec.width
647 << " x " << video_codec.height;
648 return false;
649 }
650
651 if (video_codec.startBitrate < kViEMinCodecBitrate) {
652 LOG(LS_ERROR) << "Invalid start bitrate.";
653 return false;
654 }
655 if (video_codec.minBitrate < kViEMinCodecBitrate) {
656 LOG(LS_ERROR) << "Invalid min bitrate.";
657 return false;
658 }
659 return true;
660 }
661
662 } // namespace webrtc
663