Replace WebRtcVideoEncoderFactory::VideoCodec with cricket::VideoCodec

webrtc/api/android/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 39 matching lines @@
 using webrtc::kVideoCodecVP8;
 using webrtc::kVideoCodecVP9;
 using webrtc::QualityScaler;
 
 namespace webrtc_jni {
 
 // H.264 start code length.
 #define H264_SC_LENGTH 4
 // Maximum allowed NALUs in one output frame.
 #define MAX_NALUS_PERFRAME 32
-// Maximum supported HW video encoder resolution.
-#define MAX_VIDEO_WIDTH 1280
-#define MAX_VIDEO_HEIGHT 1280
 // Maximum supported HW video encoder fps.
 #define MAX_VIDEO_FPS 30
 // Maximum allowed fps value in SetRates() call.
 #define MAX_ALLOWED_VIDEO_FPS 60
 // Maximum allowed frames in encoder input queue.
 #define MAX_ENCODER_Q_SIZE 2
 // Maximum amount of dropped frames caused by full encoder queue - exceeding
 // this threshold means that encoder probably got stuck and need to be reset.
 #define ENCODER_STALL_FRAMEDROP_THRESHOLD 60
 
@@ skipping 1230 matching lines @@
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
   supported_codecs_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp8HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp8_hw_supported) {
     ALOGD << "VP8 HW Encoder supported.";
-    supported_codecs_.push_back(VideoCodec(kVideoCodecVP8, "VP8",
-        MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
+    supported_codecs_.push_back(cricket::VideoCodec("VP8"));
   }
 
   bool is_vp9_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp9HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp9_hw_supported) {
     ALOGD << "VP9 HW Encoder supported.";
-    supported_codecs_.push_back(VideoCodec(kVideoCodecVP9, "VP9",
-        MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
+    supported_codecs_.push_back(cricket::VideoCodec("VP9"));
   }
 
   bool is_h264_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isH264HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_h264_hw_supported) {
     ALOGD << "H.264 HW Encoder supported.";
-    supported_codecs_.push_back(VideoCodec(kVideoCodecH264, "H264",
-        MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
+    supported_codecs_.push_back(cricket::VideoCodec("H264"));
   }
 }
 
 MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {
   ALOGD << "MediaCodecVideoEncoderFactory dtor";
   if (egl_context_) {
     JNIEnv* jni = AttachCurrentThreadIfNeeded();
     jni->DeleteGlobalRef(egl_context_);
   }
 }
 
 void MediaCodecVideoEncoderFactory::SetEGLContext(
     JNIEnv* jni, jobject egl_context) {
   ALOGD << "MediaCodecVideoEncoderFactory::SetEGLContext";
   if (egl_context_) {
     jni->DeleteGlobalRef(egl_context_);
     egl_context_ = nullptr;
   }
   egl_context_ = jni->NewGlobalRef(egl_context);
   if (CheckException(jni)) {
     ALOGE << "error calling NewGlobalRef for EGL Context.";
   }
 }
 
 webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
-    VideoCodecType type) {
+    const cricket::VideoCodec& codec) {
   if (supported_codecs_.empty()) {
-    ALOGW << "No HW video encoder for type " << (int)type;
+    ALOGW << "No HW video encoder for codec " << codec.name;
     return nullptr;
   }
-  for (std::vector<VideoCodec>::const_iterator it = supported_codecs_.begin();
-         it != supported_codecs_.end(); ++it) {
-    if (it->type == type) {
-      ALOGD << "Create HW video encoder for type " << (int)type <<
-          " (" << it->name << ").";
-      return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type,
-                                        egl_context_);
-    }
+  if (IsCodecSupported(supported_codecs_, codec)) {
+    ALOGD << "Create HW video encoder for " << codec.name;
+    const VideoCodecType type = cricket::CodecTypeFromName(codec.name);
+    return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type,
+                                      egl_context_);
   }
-  ALOGW << "Can not find HW video encoder for type " << (int)type;
+  ALOGW << "Can not find HW video encoder for type " << codec.name;
   return nullptr;
 }
 
-const std::vector<MediaCodecVideoEncoderFactory::VideoCodec>&
-MediaCodecVideoEncoderFactory::codecs() const {
+const std::vector<cricket::VideoCodec>&
+MediaCodecVideoEncoderFactory::supported_codecs() const {
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni