Home | History | Annotate | Download | only in video_engine 
      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 
     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 
     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 
     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 
    105 ViECodecImpl::ViECodecImpl(ViESharedData* shared_data)
    106     : shared_data_(shared_data) {
    107 }
    108 
    109 ViECodecImpl::~ViECodecImpl() {
    110 }
    111 
    112 int ViECodecImpl::NumberOfCodecs() const {
    113   // +2 because of FEC(RED and ULPFEC)
    114   return static_cast<int>((VideoCodingModule::NumberOfCodecs() + 2));
    115 }
    116 
    117 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 
    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 
    253 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 
    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 
    289 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 
    305 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 
    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 
    345 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 
    362 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 
    378 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 
    396 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 
    407 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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    594 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 
    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