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