Remove cricket::VideoEncoderConfig.

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 326 matching lines @@
     codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultH264PlType,
                                                              kH264CodecName));
   }
   codecs.push_back(
       VideoCodec::CreateRtxCodec(kDefaultRtxVp8PlType, kDefaultVp8PlType));
   codecs.push_back(VideoCodec(kDefaultRedPlType, kRedCodecName));
   codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
   return codecs;
 }
 
-static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
-                                   const VideoCodec& requested_codec,
-                                   VideoCodec* matching_codec) {
-  for (size_t i = 0; i < codecs.size(); ++i) {
-    if (requested_codec.Matches(codecs[i])) {
-      *matching_codec = codecs[i];
-      return true;
-    }
-  }
-  return false;
-}
-
 std::vector<webrtc::VideoStream>
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
     const VideoCodec& codec,
     const VideoOptions& options,
     int max_bitrate_bps,
     size_t num_streams) {
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
 
   return GetSimulcastConfig(
@@ skipping 123 matching lines @@
 
 WebRtcVideoEngine2::~WebRtcVideoEngine2() {
   LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
 }
 
 void WebRtcVideoEngine2::Init() {
   LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
   initialized_ = true;
 }
 
-bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
-    const VideoEncoderConfig& config) {
-  const VideoCodec& codec = config.max_codec;
-  bool supports_codec = false;
-  for (size_t i = 0; i < video_codecs_.size(); ++i) {
-    if (CodecNamesEq(video_codecs_[i].name, codec.name)) {
-      video_codecs_[i].width = codec.width;
-      video_codecs_[i].height = codec.height;
-      video_codecs_[i].framerate = codec.framerate;
-      supports_codec = true;
-      break;
-    }
-  }
-
-  if (!supports_codec) {
-    LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
-                  << codec.ToString();
-    return false;
-  }
-
-  return true;
-}
-
 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
     webrtc::Call* call,
     const VideoOptions& options) {
   RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
   return new WebRtcVideoChannel2(call, options, video_codecs_,
       external_encoder_factory_, external_decoder_factory_);
 }
 
 const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
@@ skipping 59 matching lines @@
   // with this code (that doesn't ask the factory).
   for (size_t j = 0; j < video_codecs_.size(); ++j) {
     VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
     if (codec.Matches(in)) {
       return true;
     }
   }
   return false;
 }
 
-// Tells whether the |requested| codec can be transmitted or not. If it can be
-// transmitted |out| is set with the best settings supported. Aspect ratio will
-// be set as close to |current|'s as possible. If not set |requested|'s
-// dimensions will be used for aspect ratio matching.
-bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
-                                      const VideoCodec& current,
-                                      VideoCodec* out) {
-  RTC_DCHECK(out != NULL);
-
-  if (requested.width != requested.height &&
-      (requested.height == 0 || requested.width == 0)) {
-    // 0xn and nx0 are invalid resolutions.
-    return false;
-  }
-
-  VideoCodec matching_codec;
-  if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
-    // Codec not supported.
-    return false;
-  }
-
-  out->id = requested.id;
-  out->name = requested.name;
-  out->preference = requested.preference;
-  out->params = requested.params;
-  out->framerate = std::min(requested.framerate, matching_codec.framerate);
-  out->params = requested.params;
-  out->feedback_params = requested.feedback_params;
-  out->width = requested.width;
-  out->height = requested.height;
-  if (requested.width == 0 && requested.height == 0) {
-    return true;
-  }
-
-  while (out->width > matching_codec.width) {
-    out->width /= 2;
-    out->height /= 2;
-  }
-
-  return out->width > 0 && out->height > 0;
-}
-
 // Ignore spammy trace messages, mostly from the stats API when we haven't
 // gotten RTCP info yet from the remote side.
 bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
   static const char* const kTracesToIgnore[] = {NULL};
   for (const char* const* p = kTracesToIgnore; *p; ++p) {
     if (trace.find(*p) == 0) {
       return true;
     }
   }
   return false;
@@ skipping 2074 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO